也可以參考看看 tornado 的 blog 範例, 他的 router 下法:

class Application(tornado.web.Application):
    def __init__(self, db):
        self.db = db
        handlers = [
            (r"/", HomeHandler),
            (r"/archive", ArchiveHandler),
            (r"/feed", FeedHandler),
            (r"/entry/([^/]+)", EntryHandler),
            (r"/compose", ComposeHandler),
            (r"/auth/create", AuthCreateHandler),
            (r"/auth/login", AuthLoginHandler),
            (r"/auth/logout", AuthLogoutHandler),
        ]

在 EntryHandler 裡, 存取 slug 就可以拿到 url 裡的我們要的 id.

class EntryHandler(BaseHandler):
    async def get(self, slug):
        entry = await self.queryone("SELECT * FROM entries WHERE slug = %s", slug)
        if not entry:
            raise tornado.web.HTTPError(404)
        self.render("entry.html", entry=entry)

如果確定是拿 /…/edit 的, 也可以設定成這樣子:

(r'/your-object/(.*)/edit', 'app.controller.ObjectEditorHandler'),

Flash 的使用方法, 真的很直覺, 程式碼也超短:
https://stackoverflow.max-everyday.com/2023/02/flask-web-server-static-file/

Tornado 對靜態檔案的說明:
https://www.tornadoweb.org/en/stable/web.html#tornado.web.StaticFileHandler

使用下面的範例, 就可以存取到靜態檔案:

import asyncio
import tornado
from tornado.web import Application
from tornado.web import StaticFileHandler

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return Application([
        (r"/", MainHandler),
        (r"/content/(.*)", StaticFileHandler, {"path": "./content"}),
    ])

async def main():
    app = make_app()
    app.listen(8888)
    await asyncio.Event().wait()

if __name__ == "__main__":
    asyncio.run(main())

說明: ./content/ 輸出網頁的 /content/

使用的執行範例:
http://127.0.0.1:8888/content/static.py

有一個奇怪的坑是, 如果你在 create Application(routes, **app_settings) object 時, 所帶入的 app_settings = dict( ) 中間使用 static_path, 例如:

app_settings = dict(
    template_path=os.path.join(os.path.dirname(__file__), "templates"),
    static_path=os.path.join(os.path.dirname(__file__), "static"),

這時候, 又在 routes 裡設了 static, 例如:

handlers = [
        (r'/', MainHandler),
        (r'/static/(.*)', StaticFileHandler, {'path': "static"}),
    ]

2邊就會衝突, 原本應該正常顯示的靜態檔案都會成錯誤訊息:

Traceback (most recent call last):
  File "D:\Programs\Python\Python39-32\lib\site-packages\tornado\web.py", line 1713, in _execute
    result = await result
  File "D:\Programs\Python\Python39-32\lib\site-packages\tornado\web.py", line 2611, in get
    self.absolute_path = self.validate_absolute_path(self.root, absolute_path)
  File "D:\Programs\Python\Python39-32\lib\site-packages\tornado\web.py", line 2813, in validate_absolute_path
    raise HTTPError(404)
tornado.web.HTTPError: HTTP 404: Not Found

根目錄以下到 /static/目錄下取檔案, 並針對 404 不存在的檔案做客製化:

class MyStaticFileHandler(StaticFileHandler):
    def write_error(self, status_code, *args, **kwargs):
        my_404_page = os.path.join(options.app_root, 'template/error_404.html')
        self.set_status(status_code)
        if status_code in [404]:
            self.render(my_404_page)
        else:
            self.write("Error: %d" % status_code)

handlers = [
    (r'/', 'app.controller.HomeHandler'),
    (r'/(.*)', MyStaticFileHandler, {'path': os.path.join(app_root, 'static/')}),
]

 '_xsrf' argument missing from POST

解法:
https://stackoverflow.com/questions/12890105/tornado-xsrf-argument-missing-from-post

I imagine you have Cross-site request forgery cookies enabled in your settings (by default it is on).

Tornado’s XSRF is here

To fix this turn it off in your settings:

settings = {
    "xsrf_cookies": False,
}

Note: Normally you dont want to turn this off and normally you’d be generating HTML in a template like this: Please note the xsrf bit which adds the XSRF cookie.

 <form method="post" action="/register">
     <input name="user_name" value="test@test.com"/>
     <input name="password" type="password"/>
     <input type="submit" value="submit"/>
{% raw xsrf_form_html() %}
 </form>

—EDIT following comments— Instead of:

  def get(self):
        loader = template.Loader("resources")
        page_contents = loader.load('register_page.html').generate()
        self.write(page_contents)

Do:

  def get(self):
     self.render("../resources/register_page.html")

or better:

  def get(self):
     self.render("register_page.html")

(and put it in your templates directory)

user nginx;
worker_processes 1;

error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
    use epoll;
}

http {
    # Enumerate all the Tornado servers here
    upstream frontends {
        server 127.0.0.1:8000;
        server 127.0.0.1:8001;
        server 127.0.0.1:8002;
        server 127.0.0.1:8003;
    }

    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    access_log /var/log/nginx/access.log;

    keepalive_timeout 65;
    proxy_read_timeout 200;
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    gzip on;
    gzip_min_length 1000;
    gzip_proxied any;
    gzip_types text/plain text/html text/css text/xml
               application/x-javascript application/xml
               application/atom+xml text/javascript;

    # Only retry if there was a communication error, not a timeout
    # on the Tornado server (to avoid propagating "queries of death"
    # to all frontends)
    proxy_next_upstream error;

    server {
        listen 80;

        # Allow file uploads
        client_max_body_size 50M;

        location ^~ /static/ {
            root /var/www;
            if ($query_string) {
                expires max;
            }
        }
        location = /favicon.ico {
            rewrite (.*) /static/favicon.ico;
        }
        location = /robots.txt {
            rewrite (.*) /static/robots.txt;
        }

        location / {
            proxy_pass_header Server;
            proxy_set_header Host $http_host;
            proxy_redirect off;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Scheme $scheme;
            proxy_pass http://frontends;
        }
    }
}

網友 1號建議：

You need to wrap favicon.ico with parenthesis and escape the period in the regular expression. Your code will become

favicon_path = '/path/to/favicon.ico'

settings = {
    'debug': True, 
    'static_path': os.path.join(PATH, 'static')}

handlers = [
    (r'/', WebHandler),
    (r'/(favicon\.ico)', tornado.web.StaticFileHandler, {'path': favicon_path})]

application = tornado.web.Application(handlers, **settings)
application.listen(port)
tornado.ioloop.IOLoop.instance().start()

網友2號建議：

You can simply do something like this:

a. delete static_path from the app settings.

b.

handlers = [
            (r'/favicon.ico', tornado.web.StaticFileHandler, {'path': favicon_path}),
            (r'/static/(.*)', tornado.web.StaticFileHandler, {'path': static_path}),
            (r'/', WebHandler)
]

haven’t tested but I see no reason it shouldn’t work.

官方是一定可以run, 但用起來有點怪怪的，因為當不使用 nginx 時就無法使用 /favicon.ico

我的解法：

(r’/(favicon\.ico)’, MyStaticFileHandler, {‘path’: favicon_path}),

favicon_path 放的是 static 的這一個 folder, 不是指到 /static/favicon.ico 但實際會存取 /static/favicon.ico 這樣真的很神奇。

如果是tornado处理全部请求的话的确要求写static_path，或者使用tornado.web.StaticHandler，而一般生产环境下部署的时候，我们一般会在前端部署一个nginx的，可以在这里做静态文件处理，把static目录下的文件让nginx来执行。

server 
{
        listen 80;
        server_name www.abc.com;
        index index.html index.htm index.php;
        root  /storage/www/abc;
        server_name_in_redirect  off;
        access_log  off;
        # Allow file uploads
        client_max_body_size 10M;
        proxy_read_timeout 10;

        location = /favicon.ico {
            rewrite (.*) /static/favicon.ico;
        }
        location = /robots.txt {
            rewrite (.*) /static/robots.txt;
        }

    location ^~ /static/ {
                    root /storage/www/abc;
                    if ($query_string) {
                        expires max;
                    }
                }

        location / {
            proxy_pass_header Server;
            proxy_set_header Host $http_host;
            proxy_redirect off;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Scheme $scheme;
            proxy_pass http://abc;
        }
}

当然，开发时为了方便，在tornado里配置一个static目录比较好。

不知道為何，我的nginx 版本好像跟別人的不相容，上面的寫法都無法正確被套用到，我的設定值如下：

upstream myfrontends {
    server 127.0.0.1:5444;
}

server {
    listen       5443;
    server_name  my_server_name;
    charset utf-8;
    ssl on;
    ssl_certificate /etc/nginx/ssl/Server.pem;
    ssl_certificate_key /etc/nginx/ssl/Server.key;

    index index.html index.htm;
    root /my_server_path/static;
    server_name_in_redirect  off;
    access_log  off;

    location = /favicon.ico {
        rewrite (.*) /static/favicon.ico;
    }
    location = /robots.txt {
        rewrite (.*) /static/robots.txt;
    }

    location /static/
    {
        alias /my_server_path/static/;
    }
    location /css/
    {
        alias /my_server_path/static/css/;
    }
    location /js/
    {
        alias /my_server_path/static/js/;
    }
    location /images/
    {
        alias /my_server_path/static/images/;
    }

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_pass http://myfrontends;
    }
}

The file specified in default_filename should be in given static path. So if you move error.htmlto assets/js directory, than navigate to /js/ you will see content of error.html.

Basically this functionality is a helper with limited usecase (imho). More at https://stackoverflow.com/a/27891339/681044.

Custom error pages

Every request handler handles/renders errors in write_error function. This is the recommended way to create custom error pages:

class MyStaticFileHandler(tornado.web.StaticFileHandler):

    def write_error(self, status_code, *args, **kwargs):
        # custom 404 page
        if status_code in [404]:
            self.render('templates/error.html')
        else:
            super().write_error(status_code, *args, **kwargs)

[W 170906 08:19:15 iostream:1327] SSL Error on 9 ('192.168.1.55', 62014): [SSL: TLSV1_ALERT_UNKNOWN_CA] tlsv1 alert unknown ca (_ssl.c:661)

而且是無窮迴圈， client side 會一直 retry…，大約每1秒可以呼叫到 8個 request。

解法當然就是 web server 分在不同台就好了…

我是透過下面的指令來建立自有憑證：

I created SSL certificates using these steps:

Create the CA private key:

openssl genrsa -des3 -out servercakey.pem 

Create the CA public certificate (When you create a certificate, there must be one unique name (a Distinguished Name (DN)), which is different for each certificate that you create):

openssl req -new -x509 -key servercakey.pem -out root.crt 

Create the server’s private key file:

openssl genrsa -out server.key 

Create the server certificate request:

openssl req -new -out reqout.txt -key server.key 

Use the CA private key file to sign the server’s certificate:

openssl x509 -req -in reqout.txt -days 3650 -sha1 -CAcreateserial -CA root.crt -CAkey servercakey.pem -out server.crt 

Create the client’s private key file:

openssl genrsa -out client.key 

Create the client certificate request:

openssl req -new -out reqout.txt -key client.key 

Use the CA private key file to sign the client’s certificate:

openssl x509 -req -in reqout.txt -days 3650 -sha1 -CAcreateserial -CA root.crt -CAkey servercakey.pem -out client.crt 

Creating pem file for Server:

cat server.crt root.crt > server.pem

上面很多指令是多餘的，產生的檔案也都沒有使用到，tornado 只使用到 2個：

 server_https = HTTPServer(self.app, xheaders=True, ssl_options = {
 "certfile": os.path.join(options.certificate_path, "server.crt"),
 "keyfile": os.path.join(options.certificate_path, "server.key"),
 })

Static files and aggressive file caching

You can serve static files from Tornado by specifying the static_path setting in your application:

settings = {
    "static_path": os.path.join(os.path.dirname(__file__), "static"),
    "cookie_secret": "__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
    "login_url": "/login",
    "xsrf_cookies": True,
}
application = tornado.web.Application([
    (r"/", MainHandler),
    (r"/login", LoginHandler),
    (r"/(apple-touch-icon\.png)", tornado.web.StaticFileHandler,
     dict(path=settings['static_path'])),
], **settings)

This setting will automatically make all requests that start with /static/ serve from that static directory, e.g., http://localhost:8888/static/foo.png will serve the file foo.png from the specified static directory. We also automatically serve /robots.txt and /favicon.ico from the static directory (even though they don’t start with the /static/ prefix).

from:
http://www.tornadoweb.org/en/stable/guide/running.html

實際上 class StaticFileHandler(RequestHandler): 的 source code 及用法：

https://github.com/tornadoweb/tornado/blob/master/tornado/web.py

如果沒有搭配nginx 處理 favicon.ico 的解法：

python tornado favicon 的設定方法
https://stackoverflow.max-everyday.com/2017/09/python-tornado-favicon/

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

發現把某一個 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.

解法是使用非同步的寫法在tornado web server 上。伺服器的執行畫面：

說明， 在呼叫了 /1/files/upload 只花了 10.27ms 就結束和使用者的連線。在此修改之前，同步等縮圖處理完需要 400~500ms 才能結束連線。

修改前的執行結果：

相關文章：

認識 tornado 的 coroutine 和 asynchronous

在 single thread 下，你執行到一個 blocking function，這時候如果讓 CPU 去做其他事情是不是很好，等到 I/O 有回應的，再跳回來原本的地方繼續執行。前提是執行在 single thread.

官方的說明文件：
http://www.tornadoweb.org/en/stable/guide/coroutines.html

或

http://www.tornadoweb.org/en/stable/guide/async.html

或

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

用 tornado 做网站 (7)
http://wiki.jikexueyuan.com/project/start-learning-python/309.html

Blocking tasks in Tornado
https://lbolla.info/blog/2013/01/22/blocking-tornado

使用tornado让你的请求异步非阻塞
http://www.dongwm.com/archives/shi-yong-tornadorang-ni-de-qing-qiu-yi-bu-fei-zu-sai/

Here is a sample synchronous function:

from tornado.httpclient import HTTPClient

def synchronous_fetch(url):
    http_client = HTTPClient()
    response = http_client.fetch(url)
    return response.body

修改成非同步：

And here is the same function rewritten to be asynchronous with a callback argument:

from tornado.httpclient import AsyncHTTPClient

def asynchronous_fetch(url, callback):
    http_client = AsyncHTTPClient()
    def handle_response(response):
        callback(response.body)
    http_client.fetch(url, callback=handle_response)

再修改成 coroutine:

Here is the coroutine version of our sample function, which is very similar to the original synchronous version:

from tornado import gen

@gen.coroutine
def fetch_coroutine(url):
    http_client = AsyncHTTPClient()
    response = yield http_client.fetch(url)
    raise gen.Return(response.body)

The statement raise gen.Return(response.body) is an artifact of Python 2, in which generators aren’t allowed to return values. To overcome this, Tornado coroutines raise a special kind of exception called a Return. The coroutine catches this exception and treats it like a returned value. In Python 3.3 and later, a return response.body achieves the same result

asynchronous 範例，發出一個 HTTP request 去抓 Yahoo weather 的資訊，然後利用 XML parser 從回應得資料中取出溫度：

from tornado.ioloop import IOLoop
from tornado.web import Application, RequestHandler, asynchronous
from tornado.httpclient import AsyncHTTPClient
from xml.dom import minidom
 
class MainHandler(RequestHandler):
    url = "http://weather.yahooapis.com/forecastrss?w=2306179&u=c"
 
    @asynchronous
    def get(self):
        http_client = AsyncHTTPClient()
        http_client.fetch(self.url, callback=self._on_fetch)
 
    def _on_fetch(self, response):
        degree = self._parse_xml(response.body)
        self.finish("Taipei: %d" % degree)
 
    def _parse_xml(self, xml):
        xml_doc = minidom.parseString(xml)
        weather_list = xml_doc.getElementsByTagName('yweather:condition')
        degree = float(weather_list[0].attributes['temp'].value)
        return degree
 
if __name__ == "__main__":
    application = Application([
        (r"/", MainHandler),
    ])
    application.listen(8888)
    IOLoop.instance().start()

換成 coroutine:

from tornado.ioloop import IOLoop
from tornado.web import Application, RequestHandler, asynchronous
from tornado.httpclient import AsyncHTTPClient
import tornado.gen as gen
from xml.dom import minidom
 
class MainHandler(RequestHandler):
    url = "http://weather.yahooapis.com/forecastrss?w=2306179&u=c"
 
    @gen.coroutine
    def get(self):
        http_client = AsyncHTTPClient()
        response = yield http_client.fetch(self.url)
        degree = self._parse_xml(response.body)
        self.finish("Taipei: %d" % degree)
 
    def _parse_xml(self, xml):
        xml_doc = minidom.parseString(xml)
        weather_list = xml_doc.getElementsByTagName('yweather:condition')
        degree = float(weather_list[0].attributes['temp'].value)
        return degree
 
if __name__ == "__main__":
    application = Application([
        (r"/", MainHandler),
    ])
    application.listen(8888)
    IOLoop.instance().start()

asynchronous + callback 範例：

class MainHandler(RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        req1(argument1, callback=self._res1)
 
    @tornado.web.asynchronous
    def _res1(self, response1):
        ...do something with response
        req2(argument2, callback=self._res2)
 
    def _res2(self, response2):
        ...do something with response
        self.finish("result...")

換成 coroutine

class MainHandler(RequestHandler):    
    @tornado.gen.coroutine
    def get(self):
        response1 = yield req1(argument1)
        ...do something with response1
        response2 = yield req2(argument2)
        ...do something with response2
        self.finish("result...")

資料來源：
Coroutine in Tornado Web Framework
http://blog.yslin.tw/2014/04/coroutine-in-tornado-web-framework.html

sample:
http://stackoverflow.com/questions/8812715/using-a-simple-python-generator-as-a-co-routine-in-a-tornado-async-handler?rq=1

Here’s a basic version of what you are describing. To avoid blocking you can pass your generator to the IOLoop via a callback function. The trick here is since you are not using a process that does actual IO and so has no os level process/file handler to add to the IOLoop via add_handler, you can instead use a simple add_callback call and call it repeatedly from within the callback function to keep the function in the IOLoop callback queue until the generator has finished.

import tornado.httpserver
import tornado.ioloop
import tornado.web

class TextHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        self.generator = self.generate_text(1000)
        tornado.ioloop.IOLoop.instance().add_callback(self.loop)

    def loop(self):
        try:
            text = self.generator.next()
            self.write(text)
            tornado.ioloop.IOLoop.instance().add_callback(self.loop)
        except StopIteration:
            self.finish()

    def generate_text(self, n):
        for x in xrange(n):
            if not x % 15:
                yield "FizzBuzz\n"
            elif not x % 5:
                yield "Buzz\n"
            elif not x % 3:
                yield "Fizz\n"
            else:
                yield "%s\n" % x

application = tornado.web.Application([
    (r"/text/", TextHandler),
])

http_server = tornado.httpserver.HTTPServer(application)
http_server.listen(8888)
tornado.ioloop.IOLoop.instance().start()