tacker.wsgi module

tacker.wsgi module

Utility methods for working with WSGI servers

class tacker.wsgi.ActionDispatcher

Bases: object

Maps method name to local methods through action name.

default(data)
dispatch(*args, **kwargs)

Find and call local method.

class tacker.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 tacker.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 tacker.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.

class tacker.wsgi.Debug(application)

Bases: tacker.wsgi.Middleware

Middleware for debugging.

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

static print_generator(app_iter)

Print contents of a wrapper string iterator when iterated.

class tacker.wsgi.DictSerializer

Bases: tacker.wsgi.ActionDispatcher

Default request body serialization.

default(data)
serialize(data, action='default')
exception tacker.wsgi.Fault(exception, body_function=None)

Bases: webob.exc.HTTPException

Generates an HTTP response from a webob HTTP exception.

class tacker.wsgi.JSONDeserializer

Bases: tacker.wsgi.TextDeserializer

default(datastring)
class tacker.wsgi.JSONDictSerializer

Bases: tacker.wsgi.DictSerializer

Default JSON request body serialization.

default(data)
class tacker.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 tacker.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)
  2. Content-type header
  3. Accept* headers
best_match_language()

Determines best available locale from the Accept-Language header.

Returns:the best language match or None if the ‘Accept-Language’ header was not available in the request.
context
get_content_type()
class tacker.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 tacker.wsgi.RequestHeadersDeserializer

Bases: tacker.wsgi.ActionDispatcher

Default request headers deserializer.

default(request)
deserialize(request, action)
class tacker.wsgi.Resource(controller, fault_body_function, deserializer=None, serializer=None)

Bases: tacker.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 tacker.wsgi.ResponseHeaderSerializer

Bases: tacker.wsgi.ActionDispatcher

Default response headers serialization.

default(response, data)
serialize(response, data, action)
class tacker.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 tacker.wsgi.Router(mapper)

Bases: object

WSGI middleware that maps incoming requests to WSGI apps.

classmethod factory(global_config, **local_config)

Return an instance of the WSGI Router class.

class tacker.wsgi.Serializer(metadata=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 tacker.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', workers=0)

Run a WSGI server with the given application.

stop()
wait()

Wait until all servers have completed running.

class tacker.wsgi.TextDeserializer

Bases: tacker.wsgi.ActionDispatcher

Default request body deserialization.

default(datastring)
deserialize(datastring, action='default')
class tacker.wsgi.WorkerService(service, application)

Bases: oslo_service.service.ServiceBase

Wraps a worker to be handled by ProcessLauncher.

reset()

Reset service.

Called in case service running in daemon mode receives SIGHUP.

start()

Start service.

stop()

Stop service.

wait()

Wait for service to complete.

tacker.wsgi.config_opts()
tacker.wsgi.encode_body(body)

Encode unicode body.

WebOb requires to encode unicode body used to update response body.

Creative Commons Attribution 3.0 License

Except where otherwise noted, this document is licensed under Creative Commons Attribution 3.0 License. See all OpenStack Legal Documents.