def loadresolvers(paths):
"""Load input path modules in order to register external resolvers.
:param list paths: list of paths to load."""
for path in paths:
lookup(path)
def processexpr(self, expr, ctx=None, **kwargs):
result = []
if ctx is None:
ctx = Context()
items = kwargs.setdefault('items', self.items)
for item in items:
try:
getsubitem(item, expr.name, error=True)
except KeyError:
pass
else:
result.append(item)
if not result: # if not item match, try to lookup the expression
try:
result = lookup(expr.name)
except ImportError:
if isinstance(items, list):
items[:] = result
else:
if isinstance(items, list):
items[:] = result
ctx[expr] = result
return result
def __call__(self, svalue):
result = []
if svalue:
for item in svalue.split(','):
item = item.strip()
if not isinstance(item, self.ptype):
try:
item = self.ptype(item)
except (TypeError, ValueError):
item = lookup(item)
if issubclass(item, self.ptype):
item = item()
if isinstance(item, self.ptype):
result.append(item)
else:
raise TypeError(
'Wrong item type, {0} expected'.format(self.ptype)
)
return result
def read_callback(self, value):
if value is None:
value = read_callback
if isinstance(value, string_types):
value = lookup(value)
self._read_callback = value
def shutdown_callback(self, value):
if value is None:
value = shutdown_callback
if isinstance(value, string_types):
value = lookup(value)
self._shutdown_callback = value
def write_callback(self, value):
if value is None:
value = write_callback
if isinstance(value, string_types):
value = lookup(value)
self._write_callback = value
def notification_callback(self, value):
if value is None:
value = notification_callback
if isinstance(value, string_types):
value = lookup(value)
self._notification_callback = value
def read_callback(self, value):
if value is None:
value = read_callback
if isinstance(value, string_types):
value = lookup(value)
self._read_callback = value
def shutdown_callback(self, value):
if value is None:
value = shutdown_callback
if isinstance(value, string_types):
value = lookup(value)
self._shutdown_callback = value
def exception_processing(self, value):
if value is None:
value = exception_processing
if isinstance(value, string_types):
value = lookup(value)
self._exception_processing = value
def notification_callback(self, value):
if value is None:
value = notification_callback
if isinstance(value, string_types):
value = lookup(value)
self._notification_callback = value
def flush_callback(self, value):
if value is None:
value = flush_callback
if isinstance(value, string_types):
value = lookup(value)
self._flush_callback = value
def write_callback(self, value):
if value is None:
value = write_callback
if isinstance(value, string_types):
value = lookup(value)
self._write_callback = value
def flush_callback(self, value):
if value is None:
value = flush_callback
if isinstance(value, string_types):
value = lookup(value)
self._flush_callback = value
def get(self, name):
if name in _OPERATORS_BY_NAME:
return _OPERATORS_BY_NAME[name]
else:
try:
return lookup(name)
except ImportError:
pass
def loadmodules(self, modules=None, rel=None):
"""ry to (re)load modules and return loaded modules.
:param modules: list of module (name) to load.
:param bool rel: flag for forcing reload of module. Default is this
rel flag (false by default).
:rtype: list
:return: loaded modules."""
result = []
if rel is None:
rel = self.rel
if modules is None:
modules = self._modules
for module in modules:
if isinstance(module, string_types):
name = module
module = lookup(name)
elif isinstance(module, ModuleType):
name = module.__name__
else:
raise TypeError(
'wrong value {0} in {1}. List of str/module expected.'
.format(
module, modules
)
)
if not rel and module in self._loadedmodules:
continue
reload_module(module)
result.append(module)
self._loadedmodules.add(module)
return result
def _load_drivers(self, drivers):
result = []
for module in drivers:
if isinstance(module, string_types):
try:
module = lookup(module)
except ImportError as err:
raise_from(
ValueError(
'Impossible to load module: {0}'.format(module)
),
err
)
elif not isinstance(module, ModuleType):
raise TypeError(
'Expected module or string, got: {0}'.format(type(module))
)
result.append(module)
return result
def _getparams_rtype(cls, function):
"""Get function params from input function and rtype.
:return: OrderedDict, rtype, vargs and kwargs.
:rtype: tuple
"""
try:
args, vargs, kwargs, default = getargspec(function)
except TypeError:
args, vargs, kwargs, default = (), (), (), ()
indexlen = len(args) - (0 if default is None else len(default))
params = OrderedDict()
for index, arg in enumerate(args):
pkwargs = {'name': arg, 'mandatory': True} # param kwargs
if index >= indexlen: # has default value
value = default[index - indexlen]
pkwargs['default'] = value
pkwargs['ref'] = None if value is None else data2schema(value)
pkwargs['mandatory'] = False
params[arg] = pkwargs
rtype = None
# parse docstring
if function.__doc__ is not None and not isbuiltin(function):
scope = get_function_globals(function)
for match in cls._REC.findall(function.__doc__):
if rtype is None:
rrtype = match[4].strip() or None
if rrtype:
rtypes = rrtype.split(',')
schemas = []
for rtype_ in rtypes:
rtype_ = rtype_.strip()
islist = False
try:
lkrtype = lookup(rtype_, scope=scope)
except ImportError:
islist = True
try:
if rtype_[-1] == 's':
lkrtype = lookup(rtype_[:-1],
scope=scope)
elif rtype_.startswith('list of '):
lkrtype = lookup(rtype_[8:],
scope=scope)
else:
raise
except ImportError:
msg = 'rtype "{0}" ({1}) from {2} not found.'
raise ImportError(
msg.format(rtype_, rrtype, function))
try:
schemacls = datatype2schemacls(lkrtype)
except TypeError:
schemacls = ParamTypeSchema(type=lkrtype)
rschema = schemacls()
if islist:
rschema = ArraySchema(itemtype=rschema)
schemas.append(rschema)
if len(rtypes) > 1:
rtype = OneOfSchema(schemas=schemas, nullable=True)
else:
rtype = schemas[0]
continue
pname = (match[1] or match[2]).strip()
if pname and pname in params:
ptype = (match[0] or match[3]).strip()
ptypes = ptype.split(',')
schemas = []
for ptype in ptypes:
ptype = ptype.strip()
islist = False
try:
lkptype = lookup(ptype, scope=scope)
except ImportError:
islist = True
try:
if ptype[-1] == 's':
lkptype = lookup(ptype[:-1], scope=scope)
elif ptype.startswith('list of '):
lkptype = lookup(ptype[8:], scope=scope)
else:
raise
except ImportError:
msg = 'Error on ptype "{0}" ({1}) from {2} not found.'
raise ImportError(
msg.format(pname, ptype, function))
try:
schemacls = datatype2schemacls(lkptype)
except TypeError:
schemacls = ParamTypeSchema(type=lkptype)
pschema = schemacls()
if islist:
pschema = ArraySchema(itemtype=pschema)
schemas.append(pschema)
if len(ptypes) > 1:
pschema = OneOfSchema(schemas=schemas, nullable=True)
else:
pschema = schemas[0]
params[pname]['ref'] = pschema
return params, rtype, vargs, kwargs
def _getparams_rtype(cls, function):
"""Get function params from input function and rtype.
:return: OrderedDict, rtype, vargs and kwargs.
:rtype: tuple
"""
try:
args, vargs, kwargs, default = getargspec(function)
except TypeError:
args, vargs, kwargs, default = (), (), (), ()
indexlen = len(args) - (0 if default is None else len(default))
params = OrderedDict()
for index, arg in enumerate(args):
pkwargs = {
'name': arg,
'mandatory': True
} # param kwargs
if index >= indexlen: # has default value
value = default[index - indexlen]
pkwargs['default'] = value
pkwargs['ref'] = None if value is None else data2schema(value)
pkwargs['mandatory'] = False
params[arg] = pkwargs
rtype = None
# parse docstring
if function.__doc__ is not None and not isbuiltin(function):
scope = get_function_globals(function)
for match in cls._REC.findall(function.__doc__):
if rtype is None:
rrtype = match[4].strip() or None
if rrtype:
rtypes = rrtype.split(',')
schemas = []
for rtype_ in rtypes:
rtype_ = rtype_.strip()
islist = False
try:
lkrtype = lookup(rtype_, scope=scope)
except ImportError:
islist = True
try:
if rtype_[-1] == 's':
lkrtype = lookup(
rtype_[:-1], scope=scope
)
elif rtype_.startswith('list of '):
lkrtype = lookup(
rtype_[8:], scope=scope
)
else:
raise
except ImportError:
msg = 'rtype "{0}" ({1}) from {2} not found.'
raise ImportError(
msg.format(rtype_, rrtype, function)
)
try:
schemacls = datatype2schemacls(lkrtype)
except TypeError:
schemacls = ParamTypeSchema(type=lkrtype)
rschema = schemacls()
if islist:
rschema = ArraySchema(itemtype=rschema)
schemas.append(rschema)
if len(rtypes) > 1:
rtype = OneOfSchema(schemas=schemas, nullable=True)
else:
rtype = schemas[0]
continue
pname = (match[1] or match[2]).strip()
if pname and pname in params:
ptype = (match[0] or match[3]).strip()
ptypes = ptype.split(',')
schemas = []
for ptype in ptypes:
ptype = ptype.strip()
islist = False
try:
lkptype = lookup(ptype, scope=scope)
except ImportError:
islist = True
try:
if ptype[-1] == 's':
lkptype = lookup(ptype[:-1], scope=scope)
elif ptype.startswith('list of '):
lkptype = lookup(ptype[8:], scope=scope)
else:
raise
except ImportError:
msg = 'Error on ptype "{0}" ({1}) from {2} not found.'
raise ImportError(
msg.format(pname, ptype, function)
)
try:
schemacls = datatype2schemacls(lkptype)
except TypeError:
schemacls = ParamTypeSchema(type=lkptype)
pschema = schemacls()
if islist:
pschema = ArraySchema(itemtype=pschema)
schemas.append(pschema)
if len(ptypes) > 1:
pschema = OneOfSchema(schemas=schemas, nullable=True)
else:
pschema = schemas[0]
params[pname]['ref'] = pschema
return params, rtype, vargs, kwargs
def dispatch(self, req, resp):
"""
Dispatch request to handler, which will fill response.
:param req: request object
:type req: link.wsgi.req.Request
:param resp: response object
:type resp: link.wsgi.resp.Response
"""
for urlpattern in self.urlpatterns:
# check URL for every configured patterns
if match(urlpattern, req.path) is not None:
self.logger.debug('URLPattern({0})'.format(urlpattern))
route = self.urlpatterns[urlpattern]
# check if request method is allowed for route
if req.method in route:
try:
h = hash('{0}{1}'.format(urlpattern, req.method))
# check if handler has already been instantiated
if h not in self.objcache:
# fetch handler, instantiate it if it's a class
handler = lookup(route[req.method])
if isclass(handler):
# the handler for a class is a method
# the method's name is the request method
handler = getattr(
handler(),
req.method.lower()
)
self.objcache[h] = handler
else:
handler = self.objcache[h]
# instantiate middlewares if needed
middlewares = []
for middleware in self.middlewares:
h = hash(middleware)
if h not in self.objcache:
self.objcache[h] = lookup(middleware)()
middlewares.append(self.objcache[h])
# apply middlewares on request/response/handler
abort = False
for middleware in middlewares:
if middleware.before(req, resp, handler):
abort = True
break
# if a middleware returned True, the request is aborted
if abort:
self.logger.debug('Request aborted')
break
# pass request/response to the handler
handler(req, resp)
# apply middlewares on request/response/handler again
for middleware in reversed(middlewares):
if middleware.after(req, resp, handler):
break
except Exception:
# if any error happens, return a 500 internal error
resp.status = 500
resp.content = traceback.format_exc()
else:
# if the method was not configured for the route, return a
# 405 method not allowed
resp.status = 405
resp.content = 'Unkown method: {0}'.format(req.method)
# here a handler was found, successfully executed or not
# we do not need to check for another urlpattern
break
else:
# no urlpattern matched, return a 404 not found
resp.status = 404
resp.content = 'No route matching URL: {0}'.format(req.path)
# -*- coding: utf-8 -*-
from aloe import step, world
from link.kvstore.core import KeyValueStore
from b3j0f.utils.path import lookup
from time import sleep
# make sure driver is registered
lookup('link.riak.driver')
@step(r'I connect to "([^"]*)"')
def connect_to_kvstore(step, uri):
world.store = KeyValueStore.get_middleware_by_uri(uri)
@step(r'I disconnect from the store')
def disconnect_from_kvstore(step):
del world.store
@step(r'I wait (\d*) seconds')
def wait(step, seconds):
sleep(int(seconds))