The Problem
- Lots of web frameworks Zope, Quixote, Webware, SkunkWeb and Twisted Web etc
- Applications written for one framework often weren't compatible with the server components of the others
HTTP Basics
- When you request a page the browser sends an HTTP request
- When the server receives that request it will perform some action, (typically running an application) and return an HTTP response
WSGI application
- It is a callable (in this case a simple function) taking environ and start_response as positional parameters
- It calls start_response() with a status code and a list of tuple pairs of headers
- It returns a value.
- It should only be called once.
- The response it returns is an iterable (in this case a list with just one string).
The environ Dictionary :
A dictionary of strings
- CGI strings
- WSGI strings: wsgi.version, wsgi.url_scheme, wsgi.input, wsgi.errors, wsgi.multithread, wsgi.multiprocess, wsgi.run_once
- Server extension strings
easy_install WSGIUtils
Middleware
Component that acts like an application from the server's point of view
- It is a callable that accepts environ and start_response
- Calls start_repsonse once with status and headers etc
- Returns an iterable
with mddleware, you can do the following
- Provide more functionality by adding a key to the environ dictionary
- Change the status
- Intercepting an error
- Adding/removing/changing headers
- Change a response
Middleware Chains
Use Paste
- http://wsgi.readthedocs.org/en/latest/libraries.html
- Paste Deploy is one of the Middleware and libraries for WSGI
例子一
- app.py
from webob import Response
from webob.dec import wsgify
from paste import httpserver
from paste.deploy import loadapp
@wsgify
def application(req):
return Response('Hello World')
def app_factory(global_config, **local_config):
return application
wsgi_app = loadapp('config:/root/paste.ini')
httpserver.serve(wsgi_app, host='127.0.0.1', port=8080)
- paste.ini
[app:main]
paste.app_factory = app:app_factory
例子二
- app.py
from webob import Response
from webob.dec import wsgify
from paste import httpserver
from paste.deploy import loadapp
@wsgify
def application(req):
return Response('Hello World')
@wsgify.middleware()
def my_filter(req, app):
# just print a message to the console
print('my_filter was called')
return app(req)
def app_factory(global_config, **local_config):
return application
def filter_factory(global_config, **local_config):
return my_filter
wsgi_app = loadapp('config:/root/paste.ini')
httpserver.serve(wsgi_app, host='127.0.0.1', port=8080)
- paste.ini
[pipeline:main]
pipeline = myfilter myapp
[app:myapp]
paste.app_factory = app:app_factory
[filter:myfilter]
paste.filter_factory = app:filter_factory
Paste Deploy
- Paste Deployment is a system for finding and configuring WSGI applications and servers.
- For WSGI application consumers:
- it provides a single, simple function (loadapp) for loading a WSGI application from a configuration file or a Python Egg.
- For WSGI application providers
- it only asks for a single, simple entry point to your application
- two URI formats currently supported:
- config: refer to configuration files.
- egg:
- Python Eggs are a distribution and installation format produced by setuptools and distribute that adds metadata to a normal Python package
- Eggs are to Pythons as Jars are to Java
- http://peak.telecommunity.com/DevCenter/PythonEggs
- Global and Local Configurations
- Global configuration to apply to every application defined in a file should go in a special section named [DEFAULT].
[DEFAULT]
admin_email = webmaster@example.com
- Configuration is done through keys besides use
[app:blog]
use = egg:MyBlog
database = mysql://localhost/blogdb
blogname = This Is My Blog!
- Tree types of sections:
- Applications
- Composite Applications
- Filter Composition
- Application section: There’s two ways to indicate the Python code for the application.
- The first is to refer to another URI or name:
#points to application section in other config files
[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
- The other way to define an application is to point exactly to some Python code:
[app:myapp]
paste.app_factory = myapp.modulename:app_factory
- Composite Applications
- “Composite” applications are things that act like applications, but are made up of other applications.
- One example would be a URL mapper, where you mount applications at different URL paths.
[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
- Filter Composition: several ways to apply filters to applications:
- The first way is to use the filter-with setting
[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 defines a filter, and then a special key next which points to the application to apply the filter to.
[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
- pipeline: is used when you need apply a number of filters.
[pipeline:main]
pipeline = filter1 egg:FilterEgg#filter2 filter3 app
[filter:filter1]
...
- Factories
- paste.app_factory
- paste.composite_factory
- paste.filter_factory
- paste.server_factory
- keystoneclient/middleware/auth_token.py
class AuthProtocol(object):
"""Auth Middleware that handles authenticating client calls."""
def __init__(self, app, conf):
……
def __call__(self, env, start_response):
"""Handle incoming request.
Authenticate send downstream on success. Reject request if we can't authenticate.
def filter_factory(global_conf, **local_conf):
"""Returns a WSGI filter app for use with paste.deploy."""
conf = global_conf.copy()
conf.update(local_conf)
def auth_filter(app):
return AuthProtocol(app, conf)
return auth_filter
def app_factory(global_conf, **local_conf):
conf = global_conf.copy()
conf.update(local_conf)
return AuthProtocol(None, conf)
[composite:rootapp]
paste.composite_factory = glance.api:root_app_factory
/: apiversions
/v1: apiv1app
/v2: apiv2app
def root_app_factory(loader, global_conf, **local_conf):
if not CONF.enable_v1_api:
del local_conf['/v1']
if not CONF.enable_v2_api:
del local_conf['/v2']
return paste.urlmap.urlmap_factory(loader, global_conf, **local_conf)