class Dispatcher (BaseDispatcher): """ Loads modules, resolving their requirements, in order to create listeners for the BaseDispatcher. """ def __init__ (self, module_names): """ Load modules and hand them to the dispatcher """ super(Dispatcher, self).__init__() self.module_loader = EntryPointLoader('aleph.modules', log=self.log) # Load the initial set of modules self.module_loader.load(*module_names) # Resolve the dependencies of each module self.modules = OrderedDict() for name in module_names: self.resolve(name, list()) self.log.info("Using modules: %s", ', '.join(self.modules.keys())) self.listeners = self.load_listeners() def resolve (self, name, unresolved): """ Resolve a modules requirements - The module is placed in `unresolved` during resolution. - If the module has a requirements list, for each requirement: - Load it if not loaded - If it has not already been resolved, resolve it - Once the module is resolved it is placed in `resolved` """ module = self.module_loader[name] unresolved.append(name) if hasattr(module, 'requirements') and bool(module.requirements): for requirement_name in module.requirements: # Ensure the module is loaded self.module_loader.load(requirement_name) # Resolve the required module if it has not already been resolved if requirement_name not in self.modules.keys(): requirement = self.module_loader[requirement_name] if requirement_name in unresolved: raise Exception('Circular reference detected: {name} -> {requirement}'.format(name, requirement=requirement.__name__)) else: self.resolve(requirement_name, unresolved) unresolved.remove(name) self.modules[name] = module def load_listeners (self): """ Creates a dictionary containing event types and the listeners attached to them """ listeners = defaultdict(list) for module in self.modules.values(): for event_type, function in module: listeners[event_type].append(function) return listeners
class Reactor(BaseReactor): """ Manages aleph's protocols and connections on top of the BaseReactor """ def __init__(self, config, connections, callback=None): super(Reactor, self).__init__(callback) self.config = config self.protocol_loader = EntryPointLoader("aleph.protocols", self.log) self.connections = [self.create_connection(c) for c in connections] def create_connection(self, c): """ Creates a connection from it's configuration dictionary """ Protocol = self.protocol_loader.load_entry_point(c.pop("protocol")) return Protocol(InheritDict(c, parent=self.config)) def __enter__(self): """ Connect to all handlers """ for handler in self.connections: self.connect(handler) def loop(self): with self: while self.fd: try: self.tick() except KeyboardInterrupt: print break def __exit__(self, *e): """ Disconnect all connected handlers """ for handler in self.fd.values(): self.disconnect(handler)
def __init__ (self, module_names): """ Load modules and hand them to the dispatcher """ super(Dispatcher, self).__init__() self.module_loader = EntryPointLoader('aleph.modules', log=self.log) # Load the initial set of modules self.module_loader.load(*module_names) # Resolve the dependencies of each module self.modules = OrderedDict() for name in module_names: self.resolve(name, list()) self.log.info("Using modules: %s", ', '.join(self.modules.keys())) self.listeners = self.load_listeners()
def __init__(self, config, connections, callback=None): super(Reactor, self).__init__(callback) self.config = config self.protocol_loader = EntryPointLoader("aleph.protocols", self.log) self.connections = [self.create_connection(c) for c in connections]