248 lines
10 KiB
Python
248 lines
10 KiB
Python
from tiramisu import Config
|
|
from traceback import print_exc
|
|
from copy import copy
|
|
from typing import Dict, Callable
|
|
|
|
from .utils import _
|
|
from .error import CallError, NotAllowedError
|
|
from .logger import log
|
|
from .config import DEBUG
|
|
from .context import Context
|
|
from . import register
|
|
|
|
|
|
class CallDispatcher:
|
|
def valid_public_function(self,
|
|
risotto_context: Context,
|
|
kwargs: Dict,
|
|
public_only: bool):
|
|
if public_only and not self.messages[risotto_context.version][risotto_context.message]['public']:
|
|
msg = _(f'the message {risotto_context.message} is private')
|
|
log.error_msg(risotto_context, kwargs, msg)
|
|
raise NotAllowedError(msg)
|
|
|
|
def valid_call_returns(self,
|
|
risotto_context: Context,
|
|
returns: Dict,
|
|
kwargs: Dict):
|
|
response = self.messages[risotto_context.version][risotto_context.message]['response']
|
|
module_name = risotto_context.function.__module__.split('.')[-2]
|
|
function_name = risotto_context.function.__name__
|
|
if response.impl_get_information('multi'):
|
|
if not isinstance(returns, list):
|
|
err = _(f'function {module_name}.{function_name} has to return a list')
|
|
log.error_msg(risotto_context, kwargs, err)
|
|
raise CallError(str(err))
|
|
else:
|
|
if not isinstance(returns, dict):
|
|
err = _(f'function {module_name}.{function_name} has to return a dict')
|
|
log.error_msg(risotto_context, kwargs, err)
|
|
raise CallError(str(err))
|
|
returns = [returns]
|
|
if response is None:
|
|
raise Exception('hu?')
|
|
else:
|
|
for ret in returns:
|
|
config = Config(response, display_name=lambda self, dyn_name: self.impl_getname())
|
|
config.property.read_write()
|
|
try:
|
|
for key, value in ret.items():
|
|
config.option(key).value.set(value)
|
|
except AttributeError:
|
|
err = _(f'function {module_name}.{function_name} return the unknown parameter "{key}"')
|
|
log.error_msg(risotto_context, kwargs, err)
|
|
raise CallError(str(err))
|
|
except ValueError:
|
|
err = _(f'function {module_name}.{function_name} return the parameter "{key}" with an unvalid value "{value}"')
|
|
log.error_msg(risotto_context, kwargs, err)
|
|
raise CallError(str(err))
|
|
config.property.read_only()
|
|
mandatories = list(config.value.mandatory())
|
|
if mandatories:
|
|
mand = [mand.split('.')[-1] for mand in mandatories]
|
|
raise ValueError(_(f'missing parameters in response: {mand} in message "{risotto_context.message}"'))
|
|
try:
|
|
config.value.dict()
|
|
except Exception as err:
|
|
err = _(f'function {module_name}.{function_name} return an invalid response {err}')
|
|
log.error_msg(risotto_context, kwargs, err)
|
|
raise CallError(str(err))
|
|
|
|
async def call(self,
|
|
version: str,
|
|
message: str,
|
|
old_risotto_context: Context,
|
|
public_only: bool=False,
|
|
**kwargs):
|
|
""" execute the function associate with specified uri
|
|
arguments are validate before
|
|
"""
|
|
risotto_context = self.build_new_context(old_risotto_context,
|
|
version,
|
|
message,
|
|
'rpc')
|
|
self.valid_public_function(risotto_context,
|
|
kwargs,
|
|
public_only)
|
|
self.check_message_type(risotto_context,
|
|
kwargs)
|
|
try:
|
|
tiramisu_config = self.load_kwargs_to_config(risotto_context,
|
|
kwargs)
|
|
obj = self.messages[version][message]
|
|
kw = tiramisu_config.option(message).value.dict()
|
|
risotto_context.function = obj['function']
|
|
if obj['risotto_context']:
|
|
kw['risotto_context'] = risotto_context
|
|
returns = await risotto_context.function(self.injected_self[obj['module']], **kw)
|
|
except CallError as err:
|
|
raise err
|
|
except Exception as err:
|
|
if DEBUG:
|
|
print_exc()
|
|
log.error_msg(risotto_context,
|
|
kwargs,
|
|
err)
|
|
raise CallError(str(err))
|
|
# valid returns
|
|
self.valid_call_returns(risotto_context,
|
|
returns,
|
|
kwargs)
|
|
# log the success
|
|
log.info_msg(risotto_context,
|
|
kwargs,
|
|
_(f'returns {returns}'))
|
|
# notification
|
|
if obj.get('notification'):
|
|
notif_version, notif_message = obj['notification'].split('.', 1)
|
|
if not isinstance(returns, list):
|
|
send_returns = [returns]
|
|
else:
|
|
send_returns = returns
|
|
for ret in send_returns:
|
|
await self.publish(notif_version,
|
|
notif_message,
|
|
risotto_context,
|
|
**ret)
|
|
return returns
|
|
|
|
|
|
class PublishDispatcher:
|
|
async def publish(self, version, message, old_risotto_context, public_only=False, **kwargs):
|
|
risotto_context = self.build_new_context(old_risotto_context,
|
|
version,
|
|
message,
|
|
'event')
|
|
self.check_message_type(risotto_context,
|
|
kwargs)
|
|
try:
|
|
config = self.load_kwargs_to_config(risotto_context,
|
|
kwargs)
|
|
config_arguments = config.option(message).value.dict()
|
|
except CallError as err:
|
|
return
|
|
except Exception as err:
|
|
# if there is a problem with arguments, just send an error et do nothing
|
|
if DEBUG:
|
|
print_exc()
|
|
log.error_msg(risotto_context, kwargs, err)
|
|
return
|
|
|
|
# config is ok, so publish the message
|
|
for function_obj in self.messages[version][message].get('functions', []):
|
|
function = function_obj['function']
|
|
module_name = function.__module__.split('.')[-2]
|
|
function_name = function.__name__
|
|
info_msg = _(f'in module {module_name}.{function_name}')
|
|
try:
|
|
# build argument for this function
|
|
kw = {}
|
|
for key, value in config_arguments.items():
|
|
if key in function_obj['arguments']:
|
|
kw[key] = value
|
|
if function_obj['risotto_context']:
|
|
kw['risotto_context'] = risotto_context
|
|
# send event
|
|
returns = await function(self.injected_self[function_obj['module']], **kw)
|
|
except Exception as err:
|
|
if DEBUG:
|
|
print_exc()
|
|
log.error_msg(risotto_context, kwargs, err, info_msg)
|
|
continue
|
|
else:
|
|
log.info_msg(risotto_context, kwargs, info_msg)
|
|
# notification
|
|
if function_obj.get('notification'):
|
|
notif_version, notif_message = function_obj['notification'].split('.', 1)
|
|
await self.publish(notif_version,
|
|
notif_message,
|
|
risotto_context,
|
|
**returns)
|
|
|
|
|
|
class Dispatcher(register.RegisterDispatcher, CallDispatcher, PublishDispatcher):
|
|
""" Manage message (call or publish)
|
|
so launch a function when a message is called
|
|
"""
|
|
def build_new_context(self,
|
|
old_risotto_context: Context,
|
|
version: str,
|
|
message: str,
|
|
type: str):
|
|
""" This is a new call or a new publish, so create a new context
|
|
"""
|
|
uri = version + '.' + message
|
|
risotto_context = Context()
|
|
risotto_context.username = old_risotto_context.username
|
|
risotto_context.paths = copy(old_risotto_context.paths)
|
|
risotto_context.paths.append(uri)
|
|
risotto_context.uri = uri
|
|
risotto_context.type = type
|
|
risotto_context.message = message
|
|
risotto_context.version = version
|
|
return risotto_context
|
|
|
|
def check_message_type(self,
|
|
risotto_context: Context,
|
|
kwargs: Dict):
|
|
if self.messages[risotto_context.version][risotto_context.message]['pattern'] != risotto_context.type:
|
|
msg = _(f'{risotto_context.uri} is not a {risotto_context.type} message')
|
|
log.error_msg(risotto_context, kwargs, msg)
|
|
raise CallError(msg)
|
|
|
|
def load_kwargs_to_config(self,
|
|
risotto_context: Context,
|
|
kwargs: Dict):
|
|
""" create a new Config et set values to it
|
|
"""
|
|
# create a new config
|
|
config = Config(self.option)
|
|
config.property.read_write()
|
|
# set message's option
|
|
config.option('message').value.set(risotto_context.message)
|
|
# store values
|
|
subconfig = config.option(risotto_context.message)
|
|
for key, value in kwargs.items():
|
|
try:
|
|
subconfig.option(key).value.set(value)
|
|
except AttributeError:
|
|
if DEBUG:
|
|
print_exc()
|
|
raise AttributeError(_(f'unknown parameter "{key}"'))
|
|
# check mandatories options
|
|
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}'))
|
|
# return the config
|
|
return config
|
|
|
|
def get_service(self,
|
|
name: str):
|
|
return self.injected_self[name]
|
|
|
|
|
|
dispatcher = Dispatcher()
|
|
register.dispatcher = dispatcher
|