risotto/src/risotto/dispatcher.py

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()