唯快不破：Python Paste 学习笔记

一、写在前面

这篇文章主要介绍了Python的Paste库的使用，学习过程中主要参考官网文档以及自己的理解,整理成笔记以便后续自己查阅。
如果转载，请保留作者信息。
邮箱地址：[e-mail]
Python Paste：http://pythonpaste.org/

二、简介

Python Paste 通常称为Paste，是一套在Python的Web开发工具，在WSGI的基础上包装了几层，让应用管理和实现变得方便，Paste已被描述为“a framework for web frameworks”。
Python Paste 中包含的Python模块有助于实现WSGI中间件，包括一个CGI应用程序框架，还包括一个简单的Web服务器可以产生WSGI请求。
Paste是一个长期运行的开源项目，可追溯到至少2005年，由于它的发展，它已经从Paste核心代码分离了几个模块，这些模块是Paste项目的一部分，但形成自己的包，有自己的版本号。 他们包括：

• Webob：WSGI中对请求环境变量request environment进行包装。
• Paste Deploy：通过一个配置文件完成WSGI应用和服务器的构建。
• Paste Script, WebTest, ScriptType, INITools, Tempita, WaitForIt, WPHP, WSGIFilter, 和WSGIProxy等一些包。

本文主要介绍Paste Deploy库的实用。

三、Paste Deploy

文件：

paste.deploy.loadwsgi — — 从配置文件加载 WSGI 应用程序
paste.deploy.config — — 配置和环境的中间件
paste.deploy.converters — — 用于字符串配置的转换

介绍：

Paste Deployment通过一个配置文件完成WSGI应用和服务器的构建。对于WSGI application用户提供一个单独的简单的函数（loadapp），用于从配置文件或者python egg中加载WSGI application。Paste Deployment目前已经不需要Paste项目的其他部分支持，可以单独做一个package进行使用。Paste Deployment用于加载WSGI的应用，大多数的Python框架都支持WSGI。主要的函数是paste.deploy.loadapp，基本使用方法如下：

from paste.deploy import loadapp
wsgi_app = loadapp('config:/path/to/config.ini')

安装：

sudo pip install PasteDeploy

配置文件:

一个配置文件后缀为ini，内容被分为很多段（section），Paste Deploy只关心带有前缀的段，比如[app:main]或者[filter:errors]，总的来说，一个section的标识就是[type:name],不是这种类型的section将会被忽略。一个section的内容是以键=值来标示的。#是一个注释。在段的定义中，有以下几类：

• [app:main]:定义WSGI应用，main表示只有一个应用，有多个应用的话main改为应用名字,具体调用那个python module中的app则由use来指定,use有很多类型，大概看看就知道每种的含义了。
  config: another_config_file.ini#app_name表示从另外一个config.ini文件中找app。
  egg: MyApp是从python egg包中找。
  call: my.project:myapplication是直接调用某个模块中的myapplication。
  use = myotherapp则是在其它section找app。

• [server:main]:定义WSGI的一个server。

• [composite:xxx]：表示需要将一个请求调度定向（dispatched）到多个,或者多种应用上,这个类型的section会的把具体的URL请求分配到VALUE对应的section中的APP上去。use表明具体
  的分配方法，换句话说这里的KEY = VALUE是egg:Paste#urlmap，urlmap 表示我们将使用Pasteegg包中
  urlmap来实现composite，
• [fliter-app:]： filter-app就是一个过滤，也就是说一个请求过来后，会先走filter-app中的use指定的app，如果那个app过滤了这个request，那么这个request就不会发送到next指定的app中去进行下一步处理了。如果没有过滤，则会发送给next指定的app。这个filter-app虽然有过滤的名字，但其实也不一定要做过滤这档子事情，可以用来记录些日志啥的，比如每次来个请求就log些东西，然后再转给后面的app去处理。fiter-app必须要有next，这个和filter不一样。
• [fliter:]：和filter-app差不多，但是没有next。
• [DEFAULT]：定义一些默认变量的值。
• [pipeline]：pipeline就是简化了filter-app，不然你想，如果我有十个filter，那不是要写十个filter-app，通过pipeline，我就可以把这些filter都连起来写在一行，很方便。但要注意的是这些filter需要有一个app作为结尾。

以下是典型的配置文件：

[composite:main]
use = egg:Paste#urlmap
/ = home
/blog = blog
/wiki = wiki
/cms = config:cms.ini

[app:home]
use = egg:Paste#static
document_root = %(here)s/htdocs

[filter-app:blog]
use = egg:Authentication#auth
next = blogapp
roles = admin
htpasswd = /home/me/users.htpasswd

[app:blogapp]
use = egg:BlogApp
database = sqlite:/home/me/blog.db

[app:wiki]
use = call:mywiki.main:application
database = sqlite:/home/me/wiki.db

配置文件分为多个section，每个section的名字的格式是TYPE:NAME，每个section中参数的格式一般是KEY = VALUE。

解释每个部分：

[composite:main]
use = egg:Paste#urlmap
/ = home
/blog = blog
/wiki = wiki
/cms = config:cms.ini

这是一个composite段，表示这将会根据一些条件将web请求调度到不同的应用。use = egg:Paste#urlmap表示我们将使用Paste egg包中urlmap来实现composite，这一个段(urlmap)可以算是一个通用的composite程序了。根据web请求的path的前缀进行一个到应用的映射(map)。这些被映射的程序就包括blog,home,wiki,config:cms.ini（映射到了另外一个配置文件，Paste Deploy再根据这个文件进行载入）

[app:home]
use = egg:Paste#static
document_root = %(here)s/htdocs

app是一个callable object，接受的参数(environ,start_response)，这是paste系统交给application的，符合WSGI规范的参数. app需要完成的任务是响应envrion中的请求，准备好响应头和消息体，然后交给start_response处理，并返回响应消息体。egg:Paste#static也是Paste包中的一个简单程序，它只处理静态文件。它需要一个配置文件document_root,后面的值可以是一个变量,形式为%（var）s相应的值应该在[DEFAULT]字段指明以便Paste读取。

[filter-app:blog]
use = egg:Authentication#auth
next = blogapp
roles = admin
htpasswd = /home/me/users.htpasswd

[app:blogapp]
use = egg:BlogApp
database = sqlite:/home/me/blog.db

filter是一个callable object，其唯一参数是(app)，这是WSGI的application对象，filter需要完成的工作是将application包装成另一个application（“过滤”），并返回这个包装后的application。

[filter-app:blog]fliter-app字段表明你希望对某个应用进行包装，需要包装的应用通过next指明（表明在下一个段中），这个字段的意思就是，在正式调用blogapp之前，我会调用egg:Authentication#auth进行一个用户的验证，随后才会调用blogapp进行处理。后面的[app:blogapp]则是定义了blogapp，并指明了需要的database参数。

[app:wiki]
use = call:mywiki.main:application
database = sqlite:/home/me/wiki.db

这个段和之前的app段定义类似，不同的是对于wiki这个应用，我们没有使用egg包，而是直接对mywiki.main这个模块中的application对象使用了call方法。python，中一切皆对象，作为WSGI app的可以是一个函数，一个类，或者一个实例，使用call的话，相应的函数，类，实例中必须实现call()方法。此类app的格式用冒号分割: call(表示使用call方法):模块的完成路径名字:应用变量的完整名字

基本使用:

from paste.deploy import loadapp
wsgi_app = loadapp('config:/path/to/config.ini')

目前支持两种URI模式config：和egg：

Uri:

(1)、 config:URIs

config:URIs——URI表示配置文件，此处的配置文件是用于指示，所需要加载的application是哪些的位置

注意：
文件名是永远不会视为相对于当前的工作目录，这是一个不可预知的位置。通常，当一个 URI 具有上下文那么它将看作相对位置;例如，如果你的config:里面有另一个配置文件的 URI，该路径是相对于包含配置文件的目录。

配置文件：

配置文件是在 INI 格式。这是一个简单的格式，看起来像:

[section_name]
key = value
another key = a long value
    that extends over multiple lines

所有值都均为字符串 (不加引号是必要的)。key和section name区分大小写，并且可能包含标点符号和空格,但是头部和尾部的空白部分将会去掉。如果出现需要断行的情况，只需要在下一行开始时是空白符即可
以# (首选) 或;开头的行被视为注释。

应用程序:

在一个文件中可以定义多个application，每个application都应该有自己独立的section，即使仅有一个application存在，也需要写入到section中。每个定义一个application的section都应该以app：前缀开头。main section进入[app：main]或[app]指定运行application的Python code方式有两种：

第一是指另一个 URI 或名称:

[app:myapp]
#调用其他的配置文件（可能定义了多个应用程序），并需要执行的应用程序的名称
use = config:another_config_file.ini#app_name

# or any URI:
[app:myotherapp]
use = egg:MyApp

# or a callable from a module:
[app:mythirdapp]
use = call:my.project:myapplication

# or even another section:
[app:mylastapp]
use = myotherapp

config:another_config_file.ini#app_name表示从另外一个config.ini文件中找app。
egg:MyApp是从python egg包中找。
call:my.project:myapplication是直接调用某个模块中的myapplication。
use = myotherapp则是在其它section找app。

配置:
配置了use字段或者通过协议名称（上面提到的两种方法），就完成了配置文件最基本的配置，section中其他的key都会作为关键字参数传递给factory。下面看一个例子：

[app:blog]
use = egg:MyBlog
database = mysql://localhost/blogdb
blogname = This Is My Blog!

定义了一个application，名字为blog，运行的程序是MyBlog（他是一个egg），需要传递给MyBlog的参数是database和blogname。

重写section去覆盖上面的配置:

[app:otherblog]
use = blog
blogname = The other face of my blog

use = blog”表明使用的应用程序是section blog；但是传递的参数是：blogname = The other face of my blog，覆盖掉了section blog的对应的配置信息。这种设置方式也可以定义在普通的配置文件中，即使用use = config:other_config_file 这种方式进行。

全局配置:

当多个application需要共享相同的配置时，我们可以采用上述的方法，使用其他的section，如果想要不同的value值，则重新定义覆盖掉它。但是这种方法，不能够添加其他的配置参数，即只能覆盖掉use的section中已经定义的部分。
全局配置，适用于在一个文件中定义的每个应用程序相同的配置，可以使用[DEFUALT]方法定义全局的配置信息，[DEFUALT]的配置信息将会全部传入到所有的Application中，通常情况下，也可作为application的默认设置。application可以自主定义覆盖全局的默认值免去对所有application配置全局共享信息的麻烦可以使用[DEUALT]section，注意DEFUALT是大小写敏感的。

[DEFAULT]
admin_email = [e-mail]

[app:main]
use = ...
set admin_email = [e-mail]

set关键字使用，将会覆盖掉global的对应的配置。

(2)、 定义application需要运行的Python code

[app:myapp]
paste.app_factory = myapp.modulename:app_factory

这种方式必须明确指定使用的protocol（此例中是paste.app_factory），value值表示需要import的内容。此例中是import myapp.modulename，然后检测app_factory执行。

application的其他类型：composition application
composition application：类似与application，但是他是由多个application组成的，一个简单的例子就是URL mapper，例如：

[composite:main]
use = egg:Paste#urlmap
/ = mainapp
/files = staticapp

[app:mainapp]
use = egg:MyApp

[app:staticapp]
use = egg:Paste#static
document_root = /path/to/docroot

使用loadapp加载composition application， “main” 看起来就是和其他应用程序相同的，仅是一个application，但是根据配置文件的设置，“main”是可以访问其他的application的。

filter composition

有几种方法来将filter应用于application。它主要取决于多少个filter，和您要以何种顺序应用它们。

第一种方法是使用filter的设置，如:

[app:main]
use = egg:MyEgg
filter-with = printdebug

[filter:printdebug]
use = egg:Paste#printdebug
# and you could have another filter-with here, and so on...

另一种方法：filter-app pipeline 除外，还有两个特殊的section可以添加filter到application中去：[filter-app:…] [pipeline:…]

filter-app：定义一个filter，并且使用一个特殊的关键字next指向application，将application添加到filter中(这与[filter：…]很类似)

pipeline:当需要定义一系列的fiter时应用。在configuration中添加关键字pipeline，pipeline是一个filters的链表，以一个application结束，例如:

[pipeline:main]
pipeline = filter1 egg:FilterEgg#filter2 filter3 app

[filter:filter1]
...

Defining Factories

这允许您指向工厂 (即服从我们提到的特定协议)。但这不是多大用处，除非你可以为您的应用程序创建的工厂。
还有几个协议: paste.app_factory、paste.composite_factory、 paste.filter_factory，和paste.server_factory。每个预期可调用 (如函数、 方法或类)。

• paste.app_factory
  应用程序是最常见的。你定义一个像:

  def app_factory(global_config, **local_conf):
  return wsgi_app

  该global_config是一个字典，和本地的配置作为关键字参数传递。

• paste.composite_factory

  composite稍微复杂一些:

  def composite_factory(loader, global_config,**local_conf):
      return wsgi_app

  loader参数是一个对象，有几个有趣的方法。 get_app (name_or_uri， global_conf = None)返回具有给定名称的 WSGI 应用。 get_filter和get_server的工作方式相同。

更有趣的例子可能是做了一个composite factory。例如，考虑一个”pipeline”应用程序:

def pipeline_factory(loader, global_config, pipeline):
    # space-separated list of filter and app names:
    pipeline = pipeline.split()
    filters = [loader.get_filter(n) for n in pipeline[:-1]]
    app = loader.get_app(pipeline[-1])
    filters.reverse() # apply in reverse order!
    for filter in filters:
        app = filter(app)
    return app

然后我们用它:

[composite:main]
use = <pipeline_factory_uri>
pipeline = egg:Paste#printdebug session myapp

[filter:session]
use = egg:Paste#session
store = memory

[app:myapp]
use = egg:MyApp

• paste.filter_factory

filter工厂，像 app 工厂，除了他们返回filter。filter是 callables，采取 WSGI 应用作为唯一的参数，并返回该应用程序的”filter”版本。

下面是一个filter，检查设置REMOTE_USER CGI 变量，创建真正简单身份验证filter示例:

def auth_filter_factory(global_conf, req_usernames):
    # space-separated list of usernames:
    req_usernames = req_usernames.split()
    def filter(app):
        return AuthFilter(app, req_usernames)
    return filter

class AuthFilter(object):
    def __init__(self, app, req_usernames):
        self.app = app
        self.req_usernames = req_usernames

    def __call__(self, environ, start_response):
        if environ.get('REMOTE_USER') in self.req_usernames:
            return self.app(environ, start_response)
        start_response(
            '403 Forbidden', [('Content-type', 'text/html')])
        return ['You are forbidden to view this resource']

• paste.filter_app_factory
  这非常类似于paste.filter_factory，只是它也采用wsgi_app作为参数，并返回一个 WSGI 应用程序。所以，如果你改变了对上面的例子:

class AuthFilter(object):
    def __init__(self, app, global_conf, req_usernames):
        ....

然后AuthFilter将作为 filter_app_factory (req_usernames是所需的本地配置的关键在这种情况下)。

• paste.server_factory
  这需要相同的签名应用程序和过滤器,但返回服务器。服务器是可调用采用一个 WSGI 应用程序的单个参数。例如：

def server_factory(global_conf, host, port):
    port = int(port)
    def serve(app):
        s = Server(app, host=host, port=port)
        s.serve_forever()
    return serve

• paste.server_runner
  像paste.server_factory，除了作为第一个参数传递wsgi_app和服务器应该立即运行。

四、例子：

配置文件案例：

[composite:blog]
use=egg:Paste # urlmap 表示我们将使用Pasteegg包中urlmap来实现composite，这一个段(urlmap)可以算是一个通用的composite程序了。
/:portal  ＃ 根据web请求的path的前缀进行一个到应用的映射(map)
/admin:admin

[pipeline:admin] ＃ 指明一串app的传递链，由一些filter、app组成，最后一个是应用，即将前面的fiiter应用到app。
pipeline = logrequest adminWeb

# App
# - app是一个callable object，接受的参数(environ,start_response)，这是paste系统交给application的，符合
# WSGI规范的参数. app需要完成的任务是响应envrion中的请求，准备好响应头和消息体，然后交给start_response处理，并返回响应消息体。
[app:portal]
version = 1.0.0 ＃参数
description = This is an blog portal. ＃参数
paste.app_factory = pastedeploylab:Portal.factory

[app:adminWeb]
version = 1.0.0 # 参数
description = This is an blog admin. ＃参数
paste.app_factory = pastedeploylab:AdminWeb.factory

# - app_factory是一个callable object，其接受的参数是一些关于application的配置信息：(global_conf,**kwargs)，
# global_conf是在ini文件中default section中定义的一系列key-value对，而**kwargs，即一些本地配置，是在ini文件中，
# app:xxx section中定义的一系列key-value对。app_factory返回值是一个application对象


# Filter
# - filter是一个callable object，其唯一参数是(app)，这是WSGI的application对象，
# filter需要完成的工作是将application包装成另一个application（“过滤”），并返回这个包装后的application。

[filter:logrequest]
paste.filter_factory = pastedeploylab:LogFilter.factory
# - filter_factory是一个callable object，其接受的参数是一系列关于filter的配置信息：(global_conf,**kwargs)，
# global_conf是在ini文件中default section中定义的一系列key-value对，而**kwargs，即一些本地配置，是在ini文件中，
# filter:xxx section中定义的一系列key-value对。filter_factory返回一个filter对象

import os
from paste.deploy import loadapp
from wsgiref.simple_server import make_server

class Portal():
    def __init__(self):
        pass

    def __call__(self,environ,start_response):
        start_response("200 OK",[("Content-type", "text/plain")])
        return ["Paste Deploy Blog Protal: Version = 1.0.0",]

    @classmethod
    def factory(cls,global_conf,**kwargs):
        print "in Protal.factory", global_conf, kwargs
        return Portal()

class AdminWeb():
    def __init__(self):
        pass

    def __call__(self,environ,start_response):
        start_response("200 OK",[("Content-type", "text/plain")])
        return ["Paste Deploy Blog Admin: Version = 1.0.0",]

    @classmethod
    def factory(cls,global_conf,**kwargs):
        # kwargs .ini 传递过来的参数
        print "in Admin.factory", global_conf, kwargs
        return AdminWeb()

#Filter
class LogFilter():
    def __init__(self,app):
        self.app = app
        pass
    def __call__(self,environ,start_response):
        print "filter:LogFilter is called."
        return self.app(environ,start_response)

    @classmethod
    def factory(cls, global_conf, **kwargs):
        print "in LogFilter.factory", global_conf, kwargs
        return LogFilter

if __name__ == '__main__':
    configfile="pastedeploylab.ini"
    appname="blog"
    wsgi_app = loadapp("config:%s" % os.path.abspath(configfile), appname)
    server = make_server('0.0.0.0',8001,wsgi_app)
    server.serve_forever()
    pass

http://blog.csdn.net/u011521019/article/details/50891330