web.py框架之高级应用

二、高级应用

2.1 web.ctx

获取客户端信息，比如：来源页面、客户端浏览器类型等。

web.ctx基于 threadeddict类，又被叫做 ThreadDict。这个类创建了一个类似字典(dictionary-like)的对象，对象中的值都是与线程 id 相对应的。这样做很妙,因为很多用户同时访问系统时，这个字典对象能做到仅为某一特定的 HTTP 请求提供数据(因为没有数据共享，所以对象是线程安全的)。

web.ctx保存每个HTTP请求的特定信息，比如客户端环境变量。假设，我们想知道正在访问某页面的用户从哪个网页跳转而来的：

class example:
    def GET(self):
        referer = web.ctx.env.get("HTTP_REFERER", "http://gogle.com")
        raise web.seeother(referer)

上述代码用 web.ctx.env 获取 HTTP_REFERER 的值。如果 HTTP＿REFERER 不存在，就会将 google.com 做为默认值。接下来，用户就会被重定向回到之前的来源页面。

web.ctx 另一个特性，是它可以被 loadhook 赋值。例如：当一个请求被处理时，会话(Session)就会被设置并保存在 web.ctx 中。由于 web.ctx是线程安全的，所以我们可以象使用普通的 python 对象一样，来操作会话(Session)。

ctx中的数据成员
request
environ 又被写作.evn -- 包含标准WSGI环境变量的字典
home -- 应用的http根路径(注释：可以理解为应用的起始网址，协议+站点域名+应用所在路径)例如：http://example.org/admin
homedomain -- 应用所在站点(可以理解为协议+域名)http://example.org
host -- 主机名（域名）＋用户请求的端口（如果没有的话，就是默认的 80 端口），例如： example.org, example.org:8080 
ip –- 用户的 IP 地址，例如： xxx.xxx.xxx.xxx 
method – 所用的 HTTP 方法，例如： GET 
path –- 用户请求路径，它是基于当前应用的相对路径。在子应用中，匹配外部应用的那部分网址将被去掉。例如：主应用在 code.py中，而子应用在 admin.py 中。在 code.py中, 我们将/admin 关联到admin.app。 在 admin.py 中, 将/stories 关联到 stories类。在stories 中, web.ctx.path 就是/stories, 而非/admin/stories。形如： /articles/845 
protocol –- 所用协议，例如： https 
query –- 跟在'？'字符后面的查询字符串。如果不存在查询参数，它就是一个空字符串。例如： ?fourlegs=good&twolegs=bad 
fullpath 可以视为 path + query – 包查询参数的请求路径，但不包括'homepath'。例如：/articles/845?fourlegs=good&twolegs=bad 

response
status –- HTTP 状态码（默认是'200 OK') 401 Unauthorized 经授权
headers –- 包 HTTP 头信息(headers)的二元组列表。 
output –- 包响应实体的字符串。 

 2.2 应用处理器(Application processors)

使用应用处理器加载钩子(loadhook)和卸载钩子(unloadhook)。

web.py可以在处理请求之前或之后，通过添加处理器(processor)来完成某些操作：

def my_processor(handler):
    print "before handling"
    result = handler()
    print "after handling"
    return result


app.add_processor(my_processor)

web.py也可以通过加载钩子(loadhook)和卸载钩子(unloadhook)的方式来完成同样的操作，他们分别在请求开始和请求结束工作：

def my_loadhook():
    print "my load hook"

def my_unloadhook():
    print "my unload hook"

app.add_processor(web.loadhook(my_loadhook))
app.add_processor(web.unloadhook(my_unloadhook))

上边两个例子，如果加在主应用里面，则主应用和子应用的接口都会加上这个处理器；如果只在某个子应用里面加这个处理器，则只有这个子应用的接口被加了这个处理器。如果一个加在主应用，另一个加载子应用，则主应用的属于全局，不论访问主应用合适访问子应用都要走；子应用的不仅要走主应用的处理器，还要走自己的处理器。顺序如下：主befor 》子befor 》子after 》主after

 2.3 web.background

web.background 和 web.backgrounder 都是 python 装饰器，它可以让某个函式在一个单独的 background 线程中运行，而主线程继续处理当前的 HTTP 请求，并在稍后报告 background 线程的状态(事实上，后台函式的标准输出(stdout)被返回给启动该线程的"backrounder")。 译注：我本来想将 background thread 翻译为后台线程，后来认为作者本意是想表达“被 background 修饰的函式所在的线程”，最后翻译采用“background 线程”。 这样，服务器就可以在处理其他 http 请求的同时，快速及时地响应当前客户端请求。同时，background 线程继续执行需要长时间运行的函式。

#!/usr/bin/env python 
# -*- coding: utf-8 -*- 

from web import run, background, backgrounder 
from datetime import datetime; now = datetime.now 
from time import sleep 
 
urls = (     
    '/', 'index',     
) 
 
class index:     
    @backgrounder 
    def GET(self):         
    print "Started at %s" % now()         
    print "hit f5 to refresh!"         
    longrunning() 
 
 
@background 
def longrunning():     
    for i in range(10):         
        sleep(1)         
        print "%s: %s" % (i, now()) 
 
if __name__ == '__main__':     
        run(urls, globals())

在请求 http://localhost:8080/时，将自动重定向到类似http://localhost:8080/?_t=3080772748 的网址(t 后面的数字就是background 线程 id)，接下来(在点击几次刷新之后)就会看到如下信息：

Started at 2008-06-14 15:50:26.764474 
hit f5 to refresh! 
0: 2008-06-14 15:50:27.763813 
1: 2008-06-14 15:50:28.763861 
2: 2008-06-14 15:50:29.763844 
3: 2008-06-14 15:50:30.763853 
4: 2008-06-14 15:50:31.764778 
5: 2008-06-14 15:50:32.763852 
6: 2008-06-14 15:50:33.764338 
7: 2008-06-14 15:50:34.763925 
8: 2008-06-14 15:50:35.763854 
9: 2008-06-14 15:50:36.763789 

web.py 在 background.threaddb 字典中保存线程信息。这就很容易检查线程的状态：

class threaddbviewer:     
    def GET(self):         
        for k, v in background.threaddb.items():            
            print "%s - %s" % ( k, v ) 

web.py 并不会主动去清空 threaddb 词典，这使得输出(如http://localhost:8080/?_t=3080772748)会一直执行，直到内存被用满。
通常是在 backgrounder 函式中做线程清理工作，是因为 backgrounder可以获得线程 id(通过 web.input()得到"_t"的值，就是线程 id)，从而根据线程 id 来回收资源。这是因为虽然 background 能知道自己何时结束，但它无法获得自己的线程 id，所以 background 无法自己完成线程清理。
还要注意 How not to do thread local storage with Python 在 python 中如何避免多线程本地存储 - 线程 ID 有时会被重用(可能会引发错误) 。

在使用 web.background 时，还是那句话－－“小心为上”！

2.4 自定义NotFound消息

import web

urls = (
    ...
)

app = web.application(urls, globals())

def notfound():
    return web.notfound("Sorry, the page you were looking for was not found!"
    # return web.notfound(render.notfound())
    # return web.notfound(str(render.notfound()))

app.notfound = notfound

要返回自定义的NotFound消息，这么做即可：

class example:
    def GET(self):
        raise web.notfound()

这个返回的是 404 Not Found
也可以用同样的方法自定义500错误消息：

def internalerror():
    return web.internalerror("Bad, bad server. No donut for you."

app.internalerror = internalerror

2.5 使用流来传输大文件

要用流的方式传输大文件，需要添加传输译码(Transfer-Eencoding)区块头，这样才能一边下载一边显示。否则，浏览器将缓存所有数据直到下载完毕才显示。

如果这样写：直接修改基础字符串(例中就是j)，然后用yield返回——是没有效果的。如果要用yield，就要向所有内容使用yield。因为这个函式此时是一个产生器。

# coding: utf-8
# 简单流式服务器演示
# 使用time.sleep模拟大文件读取

import web
import time

urls = (     
    "/", "count_holder",     
    "/(.*)", "count_down",     
) 

app = web.application(urls, globals())

class count_down:
    def GET(self, count):
        # 这些头使它在浏览器中工作
        web.header("Content-Type",  "text/html")
        web.header("Transfer-Encoding", "chunked")
        yield "<h2>Prepare for Launch!</h2>"
        j = "<li>Liftoff in %s...</li>"
        yield "<ul>"
        count = int(count)
        for i in range(count, 0, -1):
            out = j % i
            time.sleep(1)
            yield out
            yield "</ul>"
            time.sleep(1)
            yield "<h1>Life off</h1>"

class count_holder:
    def GET(self):
        web.header("Content-Type", "text/html")
        web.header("Transfer-Encoding", "chunked")
        boxes = 4
        delay = 3
        countdown = 10
        for i in range(boxes):
            output = "<iframe src='/%d' width='200' height='500'></iframe>"%(countdown - i)             
            yield output             
            time.sleep(delay) 
 
if __name__ == "__main__":     
app.run() 

2.6 管理自带的webserver日志

 我们可以用wsgilog来操作内置的webserver的日志，并将其作为中间件加到应用中。

写一个Log类继承wsgilog.WsgiLog，在__init__中把参数传给基类。

如下：

import sys, logging
from wsgilog from WsgiLog, LogI0
import config

class Log(WsgiLog):
    def __init__(self, application):
        WsgiLog.__init__(
            self,
            application,
            logformat = "%(message)s",
            tofile = True,             
            file = config.log_file,             
            interval = config.log_interval,             
            backups = config.log_backups
            )         
        sys.stdout = LogIO(self.logger, logging.INFO)         
        sys.stderr = LogIO(self.logger, logging.ERROR) 

接下来，当应用运行时，传递一个引用给上例中的 Log 类即可(假设上面代码是'mylog'模块的一部分，代码如下)：

from mylog import Log 
application = web.application(urls, globals()) 
application.run(Log) 

2.7 用cheerypy提供SSL支持

import web 
from web.wsgiserver import CherryPyWSGIServer 
 
CherryPyWSGIServer.ssl_certificate = "path/to/ssl_certificate" 
CherryPyWSGIServer.ssl_private_key = "path/to/ssl_private_key" 
 
urls = ("/.*", "hello") 
app = web.application(urls, globals()) 
 
class hello:     
    def GET(self):         
        return 'Hello, world!' 
 
if __name__ == "__main__":     
    app.run() 

2.8 实时语言切换

首先你必须阅读模板语言中的i18n支持, 然后尝试下面的代码。

文件: code.py

import os
import sys
import gettext
import web

# File location directory.
rootdir = os.path.abspath(os.path.dirname(__file__))

# i18n directory.
localedir = rootdir + '/i18n'

# Object used to store all translations.
allTranslations = web.storage()

def get_translations(lang='en_US'):
    # Init translation.
    if allTranslations.has_key(lang):
        translation = allTranslations[lang]
    elif lang is None:
        translation = gettext.NullTranslations()
    else:
        try:
            translation = gettext.translation(
                    'messages',
                    localedir,
                    languages=[lang],
                    )
        except IOError:
            translation = gettext.NullTranslations()
    return translation

def load_translations(lang):
    """Return the translations for the locale."""
    lang = str(lang)
    translation  = allTranslations.get(lang)
    if translation is None:
        translation = get_translations(lang)
        allTranslations[lang] = translation

        # Delete unused translations.
        for lk in allTranslations.keys():
            if lk != lang:
                del allTranslations[lk]
    return translation

def custom_gettext(string):
    """Translate a given string to the language of the application."""
    translation = load_translations(session.get('lang'))
    if translation is None:
        return unicode(string)
    return translation.ugettext(string)

urls = (
'/', 'index'
)

render = web.template.render('templates/',
        globals={
            '_': custom_gettext,
            }
        )

app = web.application(urls, globals())

# Init session.
session = web.session.Session(app,
        web.session.DiskStore('sessions'),
        initializer={
            'lang': 'en_US',
            }
        )

class index:
    def GET(self):
        i = web.input()
        lang = i.get('lang', 'en_US')

        # Debug.
        print >> sys.stderr, 'Language:', lang

        session['lang'] = lang
        return render.index()

if __name__ == "__main__": app.run()

模板文件: templates/index.html.

$_('Hello')

不要忘记生成必要的 po&mo 语言文件。参考: 模板语言中的i18n支持

现在运行 code.py:

$ python code.py 
http://0.0.0.0:8080/ 

然后用你喜欢的浏览器访问下面的地址，检查语言是否改变:

http://your_server:8080/ 
http://your_server:8080/?lang=en_US 
http://your_server:8080/?lang=zh_CN 

你必须:

• 确保语言文件(en_US、zh_CN等)可以动态改变。
• 确保custom_gettext()调用越省资源约好。

参考:

• 这里有使用app.app_processor()的另一个方案。