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]
