zask.ext.zerorpc package

Module contents

zask.ext.zerorpc

Add zerorpc support to zask.

copyright:

3. 2015 by the J5.

license:

BSD, see LICENSE for more details.

class zask.ext.zerorpc.AccessLogMiddleware(app)

Bases: object

This can’t be used before initialize the logger.

server_after_exec(request_event, reply_event)

server_before_exec(request_event)

server_inspect_exception(request_event, reply_event, task_context, exc_infos)

set_class_name(class_name)

exception zask.ext.zerorpc.ClientMissingVersionException

Bases: exceptions.Exception

class zask.ext.zerorpc.ConfigCustomHeaderMiddleware(app)

Bases: zask.ext.zerorpc.ConfigEndpointMiddleware

Besides resolve the endpoint by service name, add custome header to the client.

Server side will do the validation for the access key and service version.

client_before_request(event)

load_task_context(event_header)

set_server_version(version)

class zask.ext.zerorpc.ConfigEndpointMiddleware(app)

Bases: zask.ext.zerorpc.ConfigMiddleware

Resolve the endpoint by service name.

resolve_endpoint(endpoint)

class zask.ext.zerorpc.ConfigMiddleware(app)

Bases: object

A middleware work with configure of zask application.

This is the base class for all the config based middlewares.

get_access_key(name)

get_client_keys(name)

get_endpoint(name, version)

get_version(name, version)

class zask.ext.zerorpc.HandleEndpoint

Bases: object

static decode(endpoint)

static encode(name, version)

exception zask.ext.zerorpc.MissingAccessKeyException(config_name)

Bases: exceptions.Exception

exception zask.ext.zerorpc.MissingConfigException(config_name)

Bases: exceptions.Exception

exception zask.ext.zerorpc.MissingMiddlewareException(middleware)

Bases: exceptions.Exception

Raised when Zask tries to invoke a functionality provided by a specific middleware, but that middleware is not loaded.

exception zask.ext.zerorpc.NoNameException

Bases: exceptions.Exception

exception zask.ext.zerorpc.NoSuchAccessKeyException(access_key)

Bases: exceptions.Exception

exception zask.ext.zerorpc.NoVersionException

Bases: exceptions.Exception

class zask.ext.zerorpc.RequestChainMiddleware(app)

Bases: object

Generate UUID for requests and store in greenlet’s local storage

clear_uuid()

client_before_request(event)

get_uuid()

server_after_exec(request_event, reply_event)

server_before_exec(request_event)

server_inspect_exception(request_event, reply_event, task_context, exc_infos)

set_uuid(uuid)

class zask.ext.zerorpc.RequestEventMiddleware

Bases: object

Exposes the request_event to the object being passed to Server() via self.get_request_event() from a service endpoint.

server_before_exec(request_event)

Injects the request_event into greenlet’s local storage context.

exception zask.ext.zerorpc.VersionNotMatchException(access_key, request_version, server_version)

Bases: exceptions.Exception

class zask.ext.zerorpc.ZeroRPC(app=None, middlewares=['header', 'uuid', 'access_log', 'event'])

Bases: object

This is a class used to integrate zerorpc to the Zask application.

ZeroRPC extention provides a few powful middlewares.

Take CONFIG_ENDPOINT_MIDDLEWARE as example, which will resolve endpoint according to the zask application configuration. To use that you can setup a ZeroRPC like this:

app = Zask(__name__)
app.config['ZERORPC_SOME_SERVICE'] = {
    '1.0': endpoint,
}
rpc = ZeroRPC(app, middlewares=[CONFIG_ENDPOINT_MIDDLEWARE])

Then create a server and a client:

class Srv(object):
    __version__ = "1.0"
    __service_name__ = "some_service"

def hello(self):
    return 'world'

client = rpc.Client('some_service', version='1.0')
client.hello()

Application will look for RPC_SOME_SERVICE config. You can set a default version to make the client initialization more easier:

app.config['ZERORPC_SOME_SERVICE'] = {
    '1.0': endpoint,
    '2.0': [ # set list if you have multiple endpoints
        endpoint1,
        endpoint2
    ]
    'default': '1.0'
}
client = rpc.Client('some_service')
client.hello()

But if you don’t want to use the middlewares, just set middlewares to None:

app = Zask(__name__)
rpc = ZeroRPC(app, middlewares=None)

Or set a new context to the Server/Client during the runtime:

app = Zask(__name__)
rpc = ZeroRPC(app, middlewares=[CONFIG_ENDPOINT_MIDDLEWARE])

default_context = zerorpc.Context().get_instance()
srv = rpc.Server(Srv(), context=default_context)
client = rpc.Client(context=default_context)

init_app(app)

Initial the access logger and zerorpc exception handlers.

Parameters:app – current zask application

register_middleware(middleware)

zask.ext.zerorpc.access_log(cls)

[Deprecated] A decorator for zerorpc server class to generate access logs:

@access_log
Class MySrv(Object):

    def foo(self)
        return "bar"

Every request from client will create a log:

[2014-12-18 13:33:16,433] - None - "MySrv" - "foo" - OK - 1ms

Parameters:cls – the class object

zask.ext.zerorpc.init_zerorpc(app)

Baskward compatibility.