備份：

— 備份某個資料庫

mysqldump -u root -p db_name > backup.sql;

— 備份所有資料庫

mysqldump -u root -p --all-databases > backup.sql;

附註：備所有資料庫，遇到 database 版本不同時，會有問題，例如 mysql 5.6 到 5.7 會造成系統預設的欄位長度不符的錯誤。

備份用的 shell script:

#!/bin/sh 
pw='your-password'
mysqldump --all-databases --add-drop-table -h 127.0.0.1 -u root -p$pw > your-backup-file.sql
bzip2 -f your-backup-file.sql

bz2 壓縮：

bzip2 -z FileName

bz2 解壓縮：
bzip2 -d FileName.bz2

還原：

mysql -u root -p < backup.sql

如果出現 no database selected 是因為 backup.sql 裡沒有包括了 create database 的指令，只有去 drop table. 所以要在一還原的地方指定好要被貼回來的 database name:

mysql DATABASE_NAME -u root -p < backup.sql

進階一點的備份：

MySQL 自動備份 Shell Script
https://stackoverflow.max-everyday.com/2018/01/mysql-shell-script/

https://github.com/tornadoweb/tornado/issues/1046

完整版Source code:
http://tornado-doc-chs.readthedocs.io/en/latest/_modules/tornado/web.html

class StaticFileHandler(RequestHandler):

Alright this time I found the actual solution:

            # Note: only return HTTP 206 if less than the entire range has been
            # requested. Not only is this semantically correct, but Chrome
            # refuses to play audio if it gets an HTTP 206 in response to
            # ``Range: bytes=0-``.

This note applies to audio only, chrome will play video that begins be returning a 206.

    @asynchronous
    @gen.coroutine
    def get(self, path, include_body=True):
        #Assume that path is correct, validation will be handeled elsewhere
        self.absolute_path = os.path.abspath(path)
        self.path = self.absolute_path
        if self.absolute_path is None:
            return

        self.modified = self.get_modified_time()
        self.set_headers()

        if self.should_return_304():
            self.set_status(304)
            return

        request_range = None
        range_header = self.request.headers.get("Range")
        if range_header:
            # As per RFC 2616 14.16, if an invalid Range header is specified,
            # the request will be treated as if the header didn't exist.
            request_range = httputil._parse_request_range(range_header)

        if request_range:
            start, end = request_range
            size = self.get_content_size()
            if (start is not None and start >= size) or end == 0:
                # As per RFC 2616 14.35.1, a range is not satisfiable only: if
                # the first requested byte is equal to or greater than the
                # content, or when a suffix with length 0 is specified
                self.set_status(416)  # Range Not Satisfiable
                self.set_header("Content-Type", "text/plain")
                self.set_header("Content-Range", "bytes */%s" % (size, ))
                return
            if start is not None and start < 0:
                start += size
            if end is not None and end > size:
                # Clients sometimes blindly use a large range to limit their
                # download size; cap the endpoint at the actual file size.
                end = size

            self.set_status(206)  # Partial Content
            self.set_header("Content-Range",
                            httputil._get_content_range(start, end, size))
        else:
            start = end = None

        content = self.get_content(self.absolute_path, start, end)

        for chunk in content:
            self.write(chunk)
            yield gen.Task(self.flush)
        self.finish()

related:
HTTP STATUS: 206 PARTIAL CONTENT AND RANGE REQUESTS
https://benramsey.com/blog/2008/05/206-partial-content-and-range-requests/

File “zipextimporter.pyc”, line 98, in load_module
ImportError: MemoryLoadLibrary failed loading netifaces.pyd

錯誤畫面載圖：

發生的原因是 py2exe 無法透過 data_files 參數，或 includes 或 packages 這些參數把 netifaces.pyd 打包進去。

由於 py2exe for python 2.7 已經沒有在維護，不建議繼續使用，所以改用python 3 + py2exe 新版，或 pyinstaller + python 2.7.

全部改寫成 python 3 太累，太多 code 要重測，所以切換到 pyinstaller 比較快。

要開始／結束 ActionMode 是用：

Whenever you are creating/starting ActionMode Create by

mMode = startActionMode(....);

To Dismiss it use following Syntax

if (mMode != null) 
 {
     mMode.finish();
 }

from:
http://stackoverflow.com/questions/11158957/how-to-close-an-actionmode-menu-programmatically-on-honeycomb

這要寫的有效率，似乎滿難的。

發現把某一個 function 加入 @gen.coroutine，主程式遇到這一個 function 自動變成 muti-thread .. @_@;

相關文章：

Tornado – getting return value from IOLoop.add_callback()
http://stackoverflow.com/questions/33742023/tornado-getting-return-value-from-ioloop-add-callback

I’m not sure what the difference is between the following two functions:

 IOLoop.add_callback(callback, *args, **kwargs) 

AND

IOLoop.spawn_callback(callback, *args, **kwargs)

You can’t get a return value, at least not in the way you’re thinking of. Your callback can’t even run until the function that called spawn_callback (i.e. on_message) returns. Just do whatever you want to do when that callback finishes in the callback itself (or pass it another callback to invoke with its result).

stack_context is an error-handling mechanism for callback-oriented code. It doesn’t let you handle exceptions in the calling function, but it does let you establish an error handler in the calling function that will “follow” the code even through a chain of multiple add_callback calls. This turned out to be confusing as often as it helped, so now that coroutines are available I recommend using coroutines as much as possible and when you do need to fall back to raw callbacks, use spawn_callback instead of add_callback and put your try/except handler in the callback itself.

https://huangxiaohen2738.gitbooks.io/tornado-tcp-program/content/chapter2-2.html

2.2 ioloop的回调函数

1.IOLoop.add_callback(callback, args, *kwargs)

这个函数是最简单的，在ioloop开启后执行的回调函数callback，args和*kwargs都是这个回调函数的参数。一般我们的server都是单进程单线程的，即使是多线程，那么这个函数也是安全的。

8.IOLoop.spawn_callback(callback, args, *kwargs)

这个函数也是去执行一个回调函数，但是和上面说过的其他callback不同，它和回调者的栈上下文没有关联，因此呢，他比较时候去做一些独立的功能回调。

Tornado Execution Order Spawn callback
http://stackoverflow.com/questions/38696131/tornado-execution-order-spawn-callback

No, in fact you’re guaranteed that all the functions are spawned before any of them starts running, because first does not yield between spawning func and spawning func2. You can verify this yourself by testing your code:

from tornado import gen, ioloop

@gen.coroutine
def func():
    print('func started')
    yield gen.moment
    print('func done')


@gen.coroutine
def func2():
    print('func2 started')
    yield gen.moment
    print('func2 done')


@gen.coroutine
def first():
    for i in range(2):
        ioloop.IOLoop.current().spawn_callback(func)

    ioloop.IOLoop.current().spawn_callback(func2)
    yield gen.sleep(1)

ioloop.IOLoop.current().run_sync(first)

It prints:

func started
func started
func2 started
func done
func done
func2 done

See, func2 begins before the coroutines running func complete.

To accomplish what you want:

@gen.coroutine
def first():
    yield [func() for i in range(2)]
    ioloop.IOLoop.current().spawn_callback(func2)

This prints:

func started
func started
func done
func done
func2 started
func2 done

If you want first to wait for func2 to finish before it exits, then:

@gen.coroutine
def first():
    yield [func() for i in range(2)]
    yield func2()

For more info on calling coroutines from coroutines, see my Refactoring Tornado Coroutines.

官方文件：

http://www.tornadoweb.org/en/stable/ioloop.html

Running in the background

PeriodicCallback is not normally used with coroutines. Instead, a coroutine can contain a while True: loop and use tornado.gen.sleep:

@gen.coroutine
def minute_loop():
    while True:
        yield do_something()
        yield gen.sleep(60)

# Coroutines that loop forever are generally started with
# spawn_callback().
IOLoop.current().spawn_callback(minute_loop)

Sometimes a more complicated loop may be desirable. For example, the previous loop runs every 60+N seconds, where N is the running time of do_something(). To run exactly every 60 seconds, use the interleaving pattern from above:

@gen.coroutine
def minute_loop2():
    while True:
        nxt = gen.sleep(60)   # Start the clock.
        yield do_something()  # Run while the clock is ticking.
        yield nxt             # Wait for the timer to run out.

雖然，沒有下 commit() 不會寫到 database 裡，但由於為了效能，我偷偷的把 connection 放在記憶體裡重覆使用，connection 沒有被 close() 掉，所以還在這一個 request 的這一個 begin trans 裡，這一個 request 裡的垃圾，會被queue  在 memory 裡，等下一個 request 的 會把沒有被 commit 的 trans commit 進 database 裡，解法是使用預設的 isolation 遇到 error 就要多執行一次 rollback() 把 queue 在 memory 裡的垃圾清掉。

但，這還是會遇到一個問題，就是其他關於Database 的 Object 被包裝起來，這些 Object 為確保table 一定存在，所以會先執行 create table if. 遇到 create table connect 就被 commit 了。 @_@;

I am trying to figure out how to properly override the auto-transaction when using SQLite in Python. When I try and run

cursor.execute("BEGIN;")
.....an assortment of insert statements...
cursor.execute("END;")

I get the following error:

OperationalError: cannot commit - no transaction is active

you have to set isolation level to None. Code example:

s = sqlite3.connect("./data.db")
s.isolation_level = None

try:
    c = s.cursor()
    c.execute("begin")
    ...
    c.execute("commit")
except:
    c.execute("rollback")

11.13.6. Controlling Transactions¶

By default, the sqlite3 module opens transactions implicitly before a Data Modification Language (DML) statement (i.e. INSERT/UPDATE/DELETE/REPLACE), and commits transactions implicitly before a non-DML, non-query statement (i. e. anything other than SELECT or the aforementioned).

So if you are within a transaction and issue a command like CREATE TABLE ..., VACUUM, PRAGMA, the sqlite3 module will commit implicitly before executing that command. There are two reasons for doing that. The first is that some of these commands don’t work within transactions. The other reason is that sqlite3 needs to keep track of the transaction state (if a transaction is active or not).

You can control which kind of BEGIN statements sqlite3 implicitly executes (or none at all) via the isolation_level parameter to the connect() call, or via the isolation_level property of connections.

If you want autocommit mode, then set isolation_level to None.

Otherwise leave it at its default, which will result in a plain “BEGIN” statement, or set it to one of SQLite’s supported isolation levels: “DEFERRED”, “IMMEDIATE” or “EXCLUSIVE”.

isolation_level

Get or set the current isolation level. None for autocommit mode or one of “DEFERRED”, “IMMEDIATE” or “EXCLUSIVE”. See section Controlling Transactions for a more detailed explanation.

commit()

This method commits the current transaction. If you don’t call this method, anything you did since the last call to commit() is not visible from other database connections. If you wonder why you don’t see the data you’ve written to the database, please check you didn’t forget to call this method.

rollback()

This method rolls back any changes to the database since the last call to commit().

close()

This closes the database connection. Note that this does not automatically call commit(). If you just close your database connection without calling commit() first, your changes will be lost!

在被刪除的路徑上面，建立了一樣的路徑，發現還是連不進去。

把垃圾桶裡的 shared folder restore 回來之後，還是無法透過之前的 hyperlink 連進去 shared folder, 但是 folder 上的圖示顯示還是在 share 狀態。

再去取得該 shared folder 的hyperlink 發現會產生成新的 URL, 這點滿特別的。之前同一個 folder 第1次產生出來的url, 在重新設定 share folder 的屬性後，重新產生 URL, 會取得相目的 URL.

os.path.join(path, filename)

If path and filename are unicodes then everthing will work as expected. But what will happen if filename is an UTF-8 encoded string which contains “öäü.jpg”?

Python always uses unicodes to join a string with an unicode. Therefore Python will decode the string with it’s default encoding (ascii).

os.path.join(path, filename.decode('ascii'))

Due to the missing öäü within the ASCII codepage you’ll get an unicode exception! That’s the reason why you must explicitly convert the string to unicode!

os.path.join(path, filename.decode('utf-8'))

Here’s some interesting stuff from the documentation:

sys.getfilesystemencoding()

Return the name of the encoding used to convert Unicode filenames into system file names, or None if the system default encoding is used. The result value depends on the operating system: On Mac OS X, the encoding is ‘utf-8’. On Unix, the encoding is the user’s preference according to the result of nl_langinfo(CODESET), or None if the nl_langinfo(CODESET) failed. On Windows NT+, file names are Unicode natively, so no conversion is performed. getfilesystemencoding() still returns ‘mbcs’, as this is the encoding that applications should use when they explicitly want to convert Unicode strings to byte strings that are equivalent when used as file names. On Windows 9x, the encoding is ‘mbcs’.

New in version 2.3.

If I understand this correctly, you should pass the file name as unicode:

f = open(unicode(path, encoding))

Python 編碼問題整理
幾個概念性的東西
ANSCII:
標準的 ANSCII 編碼只使用7個比特來表示一個字符，因此最多編碼128個字符。擴充的 ANSCII 使用8個比特來表示一個字符，最多也只能
編碼 256 個字符。
UNICODE:
使用2個甚至4個字節來編碼一個字符，因此可以將世界上所有的字符進行統一編碼。
UTF:
UNICODE編碼轉換格式，就是用來指導如何將 unicode 編碼成適合文件存儲和網絡傳輸的字節序列的形式 (unicode ->
str)。像其他的一些編碼方式 gb2312, gb18030, big5 和 UTF 的作用是一樣的，只是編碼方式不同。
Python 裡面有兩種數據模型來支持字符串這種數據類型，一種是 str，另外一種是 unicode ，它們都是 sequence 的派生類
型，這個可以參考 Python Language Ref 中的描述：

Strings

The items of a string are characters. There is no separate
character type; a character is represented by a string of one item.
Characters represent (at least) 8-bit bytes. The built-in functions
chr() and ord() convert between characters and nonnegative integers
representing the byte values. Bytes with the values 0-127 usually
represent the corresponding ASCII values, but the interpretation of
values is up to the program. The string data type is also used to
represent arrays of bytes, e.g., to hold data read from a file.
(On systems whose native character set is not ASCII, strings
may use EBCDIC in their internal representation, provided the
functions chr() and ord() implement a mapping between ASCII and
EBCDIC, and string comparison preserves the ASCII order. Or perhaps
someone can propose a better rule?)

Unicode

The items of a Unicode object are Unicode code units. A
Unicode code unit is represented by a Unicode object of one item and
can hold either a 16-bit or 32-bit value representing a Unicode
ordinal (the maximum value for the ordinal is given in sys.maxunicode,
and depends on how Python is configured at compile time). Surrogate
pairs may be present in the Unicode object, and will be reported as
two separate items. The built-in functions unichr() and ord() convert
between code units and nonnegative integers representing the Unicode
ordinals as defined in the Unicode Standard 3.0. Conversion from and
to other encodings are possible through the Unicode method encode()
and the built-in function unicode().

這裡面是這麼幾句：
 "The items of a string are characters", "The items of a Unicode object
 are Unicode code units", "The string data type is also used to
 represent arrays of bytes, e.g., to hold data read from a file."
 一二句說明 str 和 unicode 的組成單元(item)是什麼（因為它們同是 sequence ) 。sequence 默認的
 __len__ 函數的返回值正是該序列組成單元的個數。這樣的話，len('abcd') == 4 和 len(u'我是中文') == 4 就很
 容易理解了。
 第三句告訴我們像從文件輸入輸出的時候是用 str 來表示數據的數組。不止是文件操作，我想在網絡傳輸的時候應該也是這樣的。這就是為什麼一個
 unicode 字符串在寫入文件或者在網絡上傳輸的時候要進行編碼的原因了。
 Python 裡面的編碼和解碼也就是 unicode 和 str 這兩種形式的相互轉化。編碼是 unicode -> str，相反的，解碼就
 是 str -> unicode。
 下面剩下的問題就是確定何時需要進行編碼或者解碼了，像一些庫是 unicode 版的，這樣我們在將這些庫函數的返回值進行傳輸或者寫入文件的時候就
 要考慮將它編碼成合適的類型。
 關於文件開頭的"編碼指示"，也就是 # -*- coding: -*- 這個語句。Python 默認腳本文件都是 ANSCII 編碼的，當文件
 中有非 ANSCII 編碼範圍內的字符的時候就要使用"編碼指示"來修正。
 關於 sys.defaultencoding，這個在解碼沒有明確指明解碼方式的時候使用。比如我有如下代碼：
 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
 s = '中文' # 注意這裡的 str 是 str 類型的，而不是 unicode
 s.encode('gb18030')
 這句代碼將 s 重新編碼為 gb18030 的格式，即進行 unicode -> str 的轉換。因為 s 本身就是 str 類型的，因此
 Python 會自動的先將 s 解碼為 unicode ，然後再編碼成 gb18030。因為解碼是python自動進行的，我們沒有指明解碼方
 式，python 就會使用 sys.defaultencoding 指明的方式來解碼。很多情況下 sys.defaultencoding 是
 ANSCII，如果 s 不是這個類型就會出錯。
 拿上面的情況來說，我的 sys.defaultencoding 是 anscii，而 s 的編碼方式和文件的編碼方式一致，是 utf8 的，所
 以出錯了:
 UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position
 0: ordinal not in range(128)
 對於這種情況，我們有兩種方法來改正錯誤：
 一是明確的指示出 s 的編碼方式
 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
 s = '中文'
 s.decode('utf-8').encode('gb18030')

python 2中是將字串分作 str及Unicode兩種物件，”中文”這個字串實例建立時是處在 UTF-8編碼的狀態。若想要得到”中文”二字的 Unicode，你可以透過 .decode()來實現。另外，你也可以在字串前面加上一個英文字母 u，如u”中文”，來直接建立一個 unicode物件的實例。

input ###

print type("中文")
print type("中文".decode("utf-8"))
print type(u"中文")

output ###

type 'str'
type 'unicode'
type 'unicode'

當你想要從 UTF-8編碼狀態轉換成 Big5編碼狀態時，你必需要將編碼狀態的字串先解碼成 Unicode後，再重新編碼成 Big5的編碼狀態才能成功。

print "中文" # encoded in utf-8
print "中文".decode("utf-8").encode("big5") # encoded in big5

編碼不同除了造成亂碼之外，也會造成文本分析的錯誤，最明顯的例子就是計算字數的問題。當你用 len()這個內建的函式(built-in function)來計算”中文”這個字串有幾個字時，你會發現結果並不是預期的 2而是 6。

input ###

print len("中文")
print len("中文".decode("utf-8"))
print len(u"中文")

output ###

6
2
2

這跟 len()這個函式演算法的設計有關，當字串是編碼狀態時就會無法得到正確的字數。若要修正這個問題，請記得一定要以 unicode去計算才會得到正確的結果。這也是為什麼許多中文處理套件的第一步總是先將字串轉換成 unicode的原因。

python 3中是將字串分作 str及 byte兩種物件，分別對應到 Unicode以及編碼狀態。你發現差異了嗎？這就表示說，當你建立一個字串實例如”中文”時，這個字串就會是 Unicode的文字了。以 Unicode優先的這種設計避掉了許多因編碼不同而挖的坑，像是前面舉例使用 len()計算字數的問題。

input ###

print(type("中文"))
print(type("中文".encode("utf-8")))
print(type(u"中文"))
print(len("中文"))

output ###

class 'str'
class 'bytes'
class 'str'
2

資料來源：

Python not able to open file with non-english characters in path
http://stackoverflow.com/questions/2004137/unicodeencodeerror-on-joining-file-name

python os.walk filename ‘ascii’ codec can’t decode
https://stackoverflow.max-everyday.com/2017/03/os-walk-filename-ascii-codec-cant-decode/

官方網站：
https://github.com/FasterXML/jackson-databind

使用範例：
http://stackoverflow.com/questions/23121765/write-objectnode-to-json-string-with-utf-8-characters-to-escaped-ascii

You should enable the JsonGenerator feature which controls the escaping of the non-ASCII characters. Here is an example:

    ObjectMapper mapper = new ObjectMapper();
    mapper.getFactory().configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true);
    ObjectNode node = mapper.getNodeFactory().objectNode();
    node.put("field1", "Maël Hörz");
    System.out.println(mapper.writeValueAsString(node));

The output is:

{"field1":"Ma\u00EBl H\u00F6rz"}

arg build-in:{“path”:”\/中文字\/abc\/IMG_20170224_211551.jpg“,”client_modified”:1487942151,”platform”:”android”,”device_id”:”b131f953c8fa34c3″,”device_name”:”MI 3W”,”client_version”:”1.0″,”platform_version”:”6.0.1″,”language”:”en_US”}

arg jackson:{“path”:”/\u4E2D\u6587\u5B57/abc/IMG_20170224_211551.jpg“,”client_modified”:1487942151}

加入到 Android Stuiod：

compile 'com.fasterxml.jackson.core:jackson-core:2.7.3'
compile 'com.fasterxml.jackson.core:jackson-annotations:2.7.3'
compile 'com.fasterxml.jackson.core:jackson-databind:2.7.3'

Following android studio conventions. You can find the up to date version at: Maven Central Repository.

Build 起來會遇到 Error:

“Duplicate files copied in APK META-INF/*”

解法：

Add following into respective build.gradle file

packagingOptions {
        exclude 'META-INF/ASL2.0'
        exclude 'META-INF/LICENSE'
        exclude 'META-INF/NOTICE'
        exclude 'META-INF/NOTICE.txt'
        exclude 'META-INF/LICENSE.txt'
        exclude 'META-INF/MANIFEST.MF'
    }

解法：

This is not ideal and it would be far better to have a clean workflow instead of doing this. But for curiosity, this could be informative to people that would wonder if it’s possible.

Yes it is, using a combination of error_page, rewrite, map, proxy_intercept_errors and proxy_redirect directives and $upstream_http var pattern.

Keep in mind that it’s going far off the path nginx is designed to be driven on.

map $upstream_http_location $redirect_uri {
    "~http://[^/]+/(?<location_uri>.*)$" "$location_uri";
}

upstream origin {
    server origin1.com;
}

server {

    listen 80;
    server_name nginx-front.com;

    proxy_set_header Host "origin1.com";
    proxy_redirect http://origin1.com/ /;

    location ~ ^/hls/(\w+)\.mp4\.m3u8$ {
        proxy_pass http://origin/m3ugen/segsrc/$1.mp4;
        proxy_intercept_errors on;
        error_page 301 302 = @handler;    
    }

    location @handler {
        rewrite ^ /$redirect_uri break;
        proxy_pass http://origin;
    }

}

location /some/uri/ {
    error_page 302 = @fallback;
    proxy_intercept_errors on;
    proxy_pass ...;
}
location @fallback {
    rewrite ^ /some/other/uri last;
}

I succeeded in solving a more generic case when a redirect location can be any external URL.

server {
    ...

    location / {
        proxy_pass http://backend;
        # You may need to uncomment the following line if your redirects are relative, e.g. /foo/bar
        #proxy_redirect / /;
        proxy_intercept_errors on;
        error_page 301 302 307 = @handle_redirects;
    }

    location @handle_redirects {
        set $saved_redirect_location '$upstream_http_location';
        proxy_pass $saved_redirect_location;
    }
}

Alternative approach, which is closer to what you describe, is covered in ServerFault answer to this question: http://serverfault.com/questions/641070/nginx-302-redirect-resolve-internally

修改 sample:
https://gist.github.com/sirsquidness/710bc76d7bbc734c7a3ff69c6b8ff591

資料來源：
http://serverfault.com/questions/641070/nginx-302-redirect-resolve-internally