The quantum.wsgi Module

Utility methods for working with WSGI servers

class quantum.wsgi.ActionDispatcher

Bases: object

Maps method name to local methods through action name.

default(data)

dispatch(*args, **kwargs)

Find and call local method.

class quantum.wsgi.Application

Bases: object

Base WSGI application wrapper. Subclasses need to implement __call__.

classmethod factory(global_config, **local_config)

Used for paste app factories in paste.deploy config files.

Any local configuration (that is, values under the [app:APPNAME] section of the paste config) will be passed into the __init__ method as kwargs.

A hypothetical configuration would look like:

[app:wadl] latest_version = 1.3 paste.app_factory = nova.api.fancy_api:Wadl.factory

which would result in a call to the Wadl class as

import quantum.api.fancy_api fancy_api.Wadl(latest_version=‘1.3’)

You could of course re-implement the factory method in subclasses, but using the kwarg passing it shouldn’t be necessary.

class quantum.wsgi.Controller

Bases: object

WSGI app that dispatched to methods.

WSGI app that reads routing information supplied by RoutesMiddleware and calls the requested action method upon itself. All action methods must, in addition to their normal parameters, accept a ‘req’ argument which is the incoming wsgi.Request. They raise a webob.exc exception, or return a dict which will be serialized by requested content type.

get_default_xmlns(req)

Provide the XML namespace to use if none is otherwise specified.

class quantum.wsgi.Debug(application)

Bases: quantum.wsgi.Middleware

Helper class that can be inserted into any WSGI application chain to get information about the request and response.

static print_generator(app_iter)

Iterator that prints the contents of a wrapper string iterator when iterated.

class quantum.wsgi.DictSerializer

Bases: quantum.wsgi.ActionDispatcher

Default request body serialization

default(data)

serialize(data, action='default')

exception quantum.wsgi.Fault(exception, xmlns=None, body_function=None)

Bases: webob.exc.HTTPException

Generates an HTTP response from a webob HTTP exception

class quantum.wsgi.JSONDeserializer

Bases: quantum.wsgi.TextDeserializer

default(datastring)

class quantum.wsgi.JSONDictSerializer

Bases: quantum.wsgi.DictSerializer

Default JSON request body serialization

default(data)

class quantum.wsgi.Middleware(application)

Bases: object

Base WSGI middleware wrapper. These classes require an application to be initialized that will be called next. By default the middleware will simply call its wrapped app, or you can override __call__ to customize its behavior.

classmethod factory(global_config, **local_config)

Used for paste app factories in paste.deploy config files.

Any local configuration (that is, values under the [filter:APPNAME] section of the paste config) will be passed into the __init__ method as kwargs.

A hypothetical configuration would look like:

[filter:analytics] redis_host = 127.0.0.1 paste.filter_factory = nova.api.analytics:Analytics.factory

which would result in a call to the Analytics class as

import nova.api.analytics analytics.Analytics(app_from_paste, redis_host=‘127.0.0.1’)

You could of course re-implement the factory method in subclasses, but using the kwarg passing it shouldn’t be necessary.

process_request(req)

Called on each request.

If this returns None, the next application down the stack will be executed. If it returns a response then that response will be returned and execution will stop here.

process_response(response)

Do whatever you’d like to the response.

class quantum.wsgi.ProtectedXMLParser(*args, **kwargs)

Bases: xml.etree.ElementTree.XMLTreeBuilder

doctype(name, pubid, system)

start_doctype_decl(name, sysid, pubid, internal)

class quantum.wsgi.Request(environ, charset=None, unicode_errors=None, decode_param_names=None, **kw)

Bases: webob.request.Request

best_match_content_type()

Determine the most acceptable content-type.

Based on:

1. URI extension (.json/.xml)
2. Content-type header
3. Accept* headers

context

get_content_type()

class quantum.wsgi.RequestDeserializer(body_deserializers=None, headers_deserializer=None)

Bases: object

Break up a Request object into more useful pieces.

deserialize(request)

Extract necessary pieces of the request.

Parameters:request – Request object

:returns tuple of expected controller action name, dictionary of

keyword arguments to pass to the controller, the expected content type of the response

deserialize_body(request, action)

deserialize_headers(request, action)

get_action_args(request_environment)

Parse dictionary created by routes library.

get_body_deserializer(content_type)

get_expected_content_type(request)

class quantum.wsgi.RequestHeadersDeserializer

Bases: quantum.wsgi.ActionDispatcher

Default request headers deserializer

default(request)

deserialize(request, action)

class quantum.wsgi.Resource(controller, fault_body_function, deserializer=None, serializer=None)

Bases: quantum.wsgi.Application

WSGI app that handles (de)serialization and controller dispatch.

WSGI app that reads routing information supplied by RoutesMiddleware and calls the requested action method upon its controller. All controller action methods must accept a ‘req’ argument, which is the incoming wsgi.Request. If the operation is a PUT or POST, the controller method must also accept a ‘body’ argument (the deserialized request body). They may raise a webob.exc exception or return a dict, which will be serialized by requested content type.

dispatch(request, action, action_args)

Find action-spefic method on controller and call it.

class quantum.wsgi.ResponseHeaderSerializer

Bases: quantum.wsgi.ActionDispatcher

Default response headers serialization

default(response, data)

serialize(response, data, action)

class quantum.wsgi.ResponseSerializer(body_serializers=None, headers_serializer=None)

Bases: object

Encode the necessary pieces into a response object

get_body_serializer(content_type)

serialize(response_data, content_type, action='default')

Serialize a dict into a string and wrap in a wsgi.Request object.

Parameters:

• response_data – dict produced by the Controller
• content_type – expected mimetype of serialized response body

serialize_body(response, data, content_type, action)

serialize_headers(response, data, action)

class quantum.wsgi.Router(mapper)

Bases: object

WSGI middleware that maps incoming requests to WSGI apps.

classmethod factory(global_config, **local_config)

Returns an instance of the WSGI Router class

class quantum.wsgi.Serializer(metadata=None, default_xmlns=None)

Bases: object

Serializes and deserializes dictionaries to certain MIME types.

deserialize(datastring, content_type)

Deserialize a string to a dictionary.

The string must be in the format of a supported MIME type.

get_deserialize_handler(content_type)

serialize(data, content_type)

Serialize a dictionary into the specified content type.

class quantum.wsgi.Server(name, threads=1000)

Bases: object

Server class to manage multiple WSGI sockets and applications.

host

port

start(application, port, host='0.0.0.0', backlog=128)

Run a WSGI server with the given application.

stop()

wait()

Wait until all servers have completed running.

class quantum.wsgi.TextDeserializer

Bases: quantum.wsgi.ActionDispatcher

Default request body deserialization

default(datastring)

deserialize(datastring, action='default')

class quantum.wsgi.XMLDeserializer(metadata=None)

Bases: quantum.wsgi.TextDeserializer

default(datastring)

class quantum.wsgi.XMLDictSerializer(metadata=None, xmlns=None)

Bases: quantum.wsgi.DictSerializer

default(data)

Parameters:data – expect data to contain a single key as XML root, or

contain another ‘*_links’ key as atom links. Other case will use ‘VIRTUAL_ROOT_KEY’ as XML root.

to_xml_string(node, used_prefixes, has_atom=False)

quantum.wsgi.run_server(application, port)

Run a WSGI server with the given application.