def _dispatch_message(self, message, args, target, type_: str): if isinstance(message, str): message = getattr(self._message_factory, type_)(message, ffd.build_argument_list(args.__dict__, target)) else: message = message(ffd.build_argument_list(args.__dict__, target)) if type_ == 'command': return self._bus.invoke(message) if type_ == 'event': return self._bus.dispatch(message) return self._bus.query(message)
def __call__(self, message: ffd.Message, next_: Callable) -> ffd.Message: if not self._initialized: self._initialize() not_for_this_context = message.get_context() != 'firefly' and \ self._context_map.get_context(message.get_context()) is None is_async = hasattr(message, '_async') and getattr(message, '_async') is True if not_for_this_context or is_async: return self._transfer_message(message) args = message.to_dict() args['_message'] = message if str(message) not in self._command_handlers: raise ffd.ConfigurationError(f'No command handler registered for {message}') service = self._command_handlers[str(message)] if self._service_is_batch_capable(service) and self._batch_service.is_registered(service.__class__): self.debug('Deferring to batch service') return self._batch_service.handle(service, args) else: parsed_args = ffd.build_argument_list(args, service) self.debug('Calling service %s with arguments: %s', service, parsed_args) return service(**parsed_args)
def __call__(self, **kwargs): try: aggregate = self._registry(self._type()).find( kwargs[self._aggregate_name_snake()]) except KeyError: raise ffd.MissingArgument(self._aggregate_name_snake()) method = getattr(aggregate, self._method) return self._buffer_events( method(**ffd.build_argument_list(kwargs, method)))
def __call__(self, **kwargs) -> ffd.Entity: type_ = self._type() method = self._find_factory_method(type_) if method is not None: entity = method(type_, **kwargs) else: entity = type_(**ffd.build_argument_list(kwargs, type_)) self._registry(type_).append(entity) self.dispatch( self._build_event(type_, 'create', asdict(entity), kwargs['_context'])) return entity
def __call__(self, message: ffd.Message, next_: Callable) -> ffd.Message: if not self._initialized: self._initialize() # TODO Fix the local dev server to work with multiple contexts if self._context is not None and message.get_context() != 'firefly' and message.get_context() != self._context: return self._transfer_message(message) args = message.to_dict() args['_message'] = message for service, query_type in self._query_handlers.items(): if message.is_this(query_type): return service(**ffd.build_argument_list(args, service)) raise ffd.ConfigurationError(f'No query handler registered for {message}')
def __call__(self, message: ffd.Message, next_: Callable) -> ffd.Message: if not self._initialized: self._initialize() if message.get_context() != 'firefly' and self._context_map.get_context(message.get_context()) is None: return self._transfer_message(message) args = message.to_dict() args['_message'] = message for service, query_type in self._query_handlers.items(): if message.is_this(query_type): parsed_args = ffd.build_argument_list(args, service) self.debug('Calling service with arguments: %s', parsed_args) return service(**parsed_args) raise ffd.ConfigurationError(f'No query handler registered for {message}')
def __call__(self, message: ffd.Message, next_: Callable) -> ffd.Message: if not self._initialized: self._initialize() # TODO Fix the local dev server to work with multiple contexts if self._context is not None and message.get_context( ) != 'firefly' and message.get_context() != self._context: return self._transfer_message(message) args = message.to_dict() args['_message'] = message if str(message) not in self._command_handlers: raise ffd.ConfigurationError( f'No command handler registered for {message}') service = self._command_handlers[str(message)] return service(**ffd.build_argument_list(args, service))
def __call__(self, message: ffd.Message, next_: Callable) -> ffd.Message: if not self._initialized: self._initialize() self.debug('Message context: %s', message.get_context()) self.debug('This context: %s', self._context) self.debug('Environment: %s', self._ff_environment) if message.get_context() != 'firefly' and \ message.get_context() == self._context and \ not message.headers.get('external', False) and \ self._ff_environment != 'test': self.debug( 'EventResolvingMiddleware - event originated from this context. Dispatching.' ) self._publish_message(message) return next_(message) args = message.to_dict(recursive=False) args['_message'] = message if str(message) in self._event_listeners: services = self._event_listeners[str(message)] for service in services: try: if self._service_is_batch_capable( service) and self._batch_service.is_registered( service.__class__): self.debug('Deferring to batch service') return self._batch_service.handle(service, args) else: parsed_args = ffd.build_argument_list(args, service) self.debug('Calling service %s with arguments: %s', service.__class__.__name__, parsed_args) service(**parsed_args) except TypeError as e: self.exception(e) raise ffd.FrameworkError( f'Error calling {service.__class__.__name__}:\n\n{str(e)}' ) else: self.info('No event listener found for message %s', message) return next_(message)
def deserialize(self, data): try: if isinstance(data, (str, bytes, bytearray)): ret = json.loads(data) else: ret = data except json.JSONDecodeError: raise ffd.InvalidArgument('Could not deserialize data') if isinstance(ret, dict) and '_name' in ret: fqn = f'{ret["_context"]}.{ret["_name"]}' t = ffd.load_class(fqn) if t is None: args = [fqn] if ret['_type'] == 'query': args.append(None) args.append(ret) return getattr(self._message_factory, ret['_type'])(*args) return t(**ffd.build_argument_list(ret, t)) return ret
def __call__(self, **kwargs) -> ffd.Entity: type_ = self._type() hints = get_type_hints(type_) for field_ in fields(type_): if ffd.is_aggregate_reference(hints[field_.name]): value = ffd.apply_aggregate(kwargs[field_.name], hints[field_.name], self._load_aggregate_reference) if value is not None: kwargs[field_.name] = value method = self._find_factory_method(type_) if method is not None: entity = method(type_, **kwargs) else: entity = type_(**ffd.build_argument_list(kwargs, type_)) self._registry(type_).append(entity) self.dispatch( self._build_event(type_, 'create', entity.to_dict(force_all=True), entity.get_class_context())) return entity
def __call__(self, message: ffd.Message, next_: Callable) -> ffd.Message: if not self._initialized: self._initialize() if message.get_context() != 'firefly' and \ message.get_context() == self._context and \ not message.headers.get('external', False): self._publish_message(message) return next_(message) args = message.to_dict(recursive=False) args['_message'] = message if str(message) in self._event_listeners: services = self._event_listeners[str(message)] for service in services: try: service(**ffd.build_argument_list(args, service)) except TypeError as e: raise ffd.FrameworkError( f'Error calling {service.__class__.__name__}:\n\n{str(e)}' ) return next_(message)
def __call__(self, message: ffd.Message, next_: Callable) -> ffd.Message: args = asdict(message) args['_message'] = message return next_( self._service(**ffd.build_argument_list(args, self._service)))