当前位置: 首页 > 工具软件 > Python Paste > 使用案例 >

唯快不破:Python Paste 学习笔记

姜宏放
2023-12-01

一、写在前面

这篇文章主要介绍了Python的Paste库的使用,学习过程中主要参考官网文档以及自己的理解,整理成笔记以便后续自己查阅。
如果转载,请保留作者信息。
邮箱地址:jpzhang.ht@gmail.com
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 = webmaster@example.com

[app:main]
use = ...
set admin_email = bob@example.com

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
 类似资料: