forked from Infra/risotto
179 lines
6.9 KiB
Python
179 lines
6.9 KiB
Python
|
from tiramisu import Config
|
||
|
from inspect import signature
|
||
|
from traceback import print_exc
|
||
|
from copy import copy
|
||
|
|
||
|
from .utils import undefined, _
|
||
|
from .error import RegistrationError, CallError, NotAllowedError
|
||
|
from .message import get_messages
|
||
|
from .logger import log
|
||
|
from .config import DEBUG
|
||
|
from .context import Context
|
||
|
|
||
|
|
||
|
def register(uri: str,
|
||
|
notification: str=undefined):
|
||
|
version, uri = uri.split('.', 1)
|
||
|
def decorator(function):
|
||
|
dispatcher.set_function(version, uri, function)
|
||
|
return decorator
|
||
|
|
||
|
|
||
|
class URI:
|
||
|
def __init__(self, ):
|
||
|
self.functions = {}
|
||
|
|
||
|
|
||
|
class Dispatcher:
|
||
|
def __init__(self):
|
||
|
self.modules = {}
|
||
|
self.uris = {}
|
||
|
self.function_names = {}
|
||
|
self.messages, self.option = get_messages()
|
||
|
config = Config(self.option)
|
||
|
|
||
|
def get_function_args(self, function):
|
||
|
# remove self
|
||
|
first_argument_index = 1
|
||
|
return [param.name for param in list(signature(function).parameters.values())[first_argument_index:]]
|
||
|
|
||
|
def _valid_rpc_params(self, version, uri, function, module_name):
|
||
|
""" parameters function must have strictly all arguments with the correct name
|
||
|
"""
|
||
|
def get_message_args():
|
||
|
# load config
|
||
|
config = Config(self.option)
|
||
|
config.property.read_write()
|
||
|
# set message to the uri name
|
||
|
config.option('message').value.set(uri)
|
||
|
# get message argument
|
||
|
subconfig = config.option(uri)
|
||
|
return set(config.option(uri).value.dict().keys())
|
||
|
|
||
|
# compare message arguments with function parameter
|
||
|
# it must not have more or less arguments
|
||
|
message_args = get_message_args()
|
||
|
function_args = self.get_function_args(function)
|
||
|
# risotto_context is a special argument, remove it
|
||
|
if function_args[0] == 'risotto_context':
|
||
|
function_args = function_args[1:]
|
||
|
function_args = set(function_args)
|
||
|
if message_args != function_args:
|
||
|
msg = []
|
||
|
missing_function_args = message_args - function_args
|
||
|
if missing_function_args:
|
||
|
msg.append(_(f'missing arguments: {missing_function_args}'))
|
||
|
extra_function_args = function_args - message_args
|
||
|
if extra_function_args:
|
||
|
msg.append(_(f'extra arguments: {extra_function_args}'))
|
||
|
function_name = function.__name__
|
||
|
msg = _(' and ').join(msg)
|
||
|
raise RegistrationError(_(f'error with {module_name}.{function_name} arguments: {msg}'))
|
||
|
|
||
|
|
||
|
|
||
|
def set_function(self, version, uri, function):
|
||
|
""" register a function to an URI
|
||
|
URI is a message
|
||
|
"""
|
||
|
# xxx module can only be register with v1.xxxx..... message
|
||
|
module_name = function.__module__.split('.')[-2]
|
||
|
uri_namespace = uri.split('.', 1)[0]
|
||
|
if uri_namespace != module_name:
|
||
|
raise RegistrationError(_(f'cannot registered to {uri} message in module {module_name}'))
|
||
|
|
||
|
# check if message exists
|
||
|
try:
|
||
|
if not Config(self.option).option(uri).option.type() == 'message':
|
||
|
raise RegistrationError(_(f'{uri} is not a valid message'))
|
||
|
except AttributeError:
|
||
|
raise RegistrationError(_(f'{uri} is not a valid message'))
|
||
|
|
||
|
# check if a function is already register for this uri
|
||
|
if version not in self.uris:
|
||
|
self.uris[version] = {}
|
||
|
self.function_names[version] = {}
|
||
|
if uri in self.uris[version]:
|
||
|
raise RegistrationError(_(f'uri {uri} already imported'))
|
||
|
|
||
|
# valid function's arguements
|
||
|
self._valid_rpc_params(version, uri, function, module_name)
|
||
|
|
||
|
# valid function is unique per module
|
||
|
if module_name not in self.function_names[version]:
|
||
|
self.function_names[version][module_name] = []
|
||
|
function_name = function.__name__
|
||
|
if function_name in self.function_names[version][module_name]:
|
||
|
raise RegistrationError(_(f'multiple registration of {module_name}.{function_name} function'))
|
||
|
self.function_names[version][module_name].append(function_name)
|
||
|
|
||
|
# True if first argument is the risotto_context
|
||
|
inject_risotto_context = self.get_function_args(function)[0] == 'risotto_context'
|
||
|
|
||
|
# register this function
|
||
|
self.uris[version][uri] = {'module': module_name,
|
||
|
'function': function,
|
||
|
'risotto_context': inject_risotto_context}
|
||
|
|
||
|
def set_module(self, module_name, module):
|
||
|
""" register a new module
|
||
|
"""
|
||
|
try:
|
||
|
self.modules[module_name] = module.Risotto()
|
||
|
except AttributeError as err:
|
||
|
raise RegistrationError(_(f'unable to register the module {module_name}, this module must have Risotto class'))
|
||
|
|
||
|
def validate(self):
|
||
|
""" check if all messages have a function
|
||
|
"""
|
||
|
# FIXME only v1 supported
|
||
|
missing_messages = set(self.messages.keys()) - set(self.uris['v1'].keys())
|
||
|
if missing_messages:
|
||
|
raise RegistrationError(_(f'missing uri {missing_messages}'))
|
||
|
|
||
|
async def call(self, version, uri, risotto_context, public_only=False, **kwargs):
|
||
|
""" execute the function associate with specified uri
|
||
|
arguments are validate before
|
||
|
"""
|
||
|
new_context = Context()
|
||
|
new_context.paths = copy(risotto_context.paths)
|
||
|
new_context.paths.append(version + '.' + uri)
|
||
|
new_context.username = risotto_context.username
|
||
|
if public_only and not self.messages[uri]:
|
||
|
raise NotAllowedError()
|
||
|
try:
|
||
|
config = Config(self.option)
|
||
|
config.property.read_write()
|
||
|
config.option('message').value.set(uri)
|
||
|
subconfig = config.option(uri)
|
||
|
for key, value in kwargs.items():
|
||
|
try:
|
||
|
subconfig.option(key).value.set(value)
|
||
|
except ValueError as err:
|
||
|
raise ValueError(str(err))
|
||
|
except AttributeError:
|
||
|
raise AttributeError(_(f'unknown parameter "{key}"'))
|
||
|
config.property.read_only()
|
||
|
mandatories = list(config.value.mandatory())
|
||
|
if mandatories:
|
||
|
mand = [mand.split('.')[-1] for mand in mandatories]
|
||
|
raise ValueError(_(f'missing parameters: {mand}'))
|
||
|
obj = self.uris[version][uri]
|
||
|
kw = config.option(uri).value.dict()
|
||
|
if obj['risotto_context']:
|
||
|
kw['risotto_context'] = new_context
|
||
|
returns = await obj['function'](self.modules[obj['module']], **kw)
|
||
|
except CallError as err:
|
||
|
raise err
|
||
|
except Exception as err:
|
||
|
if DEBUG:
|
||
|
print_exc()
|
||
|
log.error_msg(version, uri, new_context, kwargs, err)
|
||
|
raise CallError(str(err))
|
||
|
log.info_msg(version, uri, new_context, kwargs, returns)
|
||
|
return returns
|
||
|
|
||
|
|
||
|
dispatcher = Dispatcher()
|
||
|
|