def __init__(self): self.info = IPCServerInfoWindow() self.senders = {} self.receivers = {} self.widgets = {} self.protocol_map = {} self.processor = CommandProcessor()
def __init__(self): self.info = IPCServerInfoWindow() self.senders = {} self.receivers = {} self.widgets = {} self.protocol_map = {} self.processor = CommandProcessor()
class IPCFacade(with_metaclass(Singleton, object)): """ The Singleton that encapsulates all IPC functionality Use this to register new server modules or send broadcasts """ def __init__(self): self.info = IPCServerInfoWindow() self.senders = {} self.receivers = {} self.widgets = {} self.protocol_map = {} self.processor = CommandProcessor() def register_shell(self, shell): """ This sets the shell. Must be called before incoming command can be executed :param shell: the ilastik shell """ self.processor.set_shell(shell) def register_widget(self, widget, title, key): """ Add a new widget to the IPCServerWindow :param widget: the widget to add :param title: the title to appear in the tab bar :param key: the key to identify and reference the widget """ if key in self.widgets: raise RuntimeError("Widget {} already exists".format(key)) self.widgets[key] = widget self.info.add_widget(title, widget) def register_module(self, module, type_, key, widget_key=None, protocol=None, start=False): """ Adds a new module to the IPCServer :param module: the module e.g. TCPServer, ZMQPublisher :param type_: "sender" or "receiver" :param key: the key to identify the module later :param widget_key: a reference to the view widget. If not None the module will connect to it :param protocol: set this to redirect handshake command with the matching protocol to this module :param start: if set the module will start immediately """ if type_ == "receiver": container = self.receivers self.processor.connect_receiver(module) elif type_ == "sender": container = self.senders else: raise RuntimeError("Type {} is invalid".format(type_)) if key in container: raise RuntimeError("{} {} already exists".format(type_, key)) container[key] = module if widget_key is not None: module.connect_widget(self.widgets[widget_key]) if protocol is not None: self.protocol_map[protocol] = module if start: module.start() def handshake(self, protocol, name, address): """ Redirects a handshake command to the registered module Currently only TCPClient handles handshake commands from TCPServer :param protocol: the protocol to identify the handler ( e.g. tcp ) :param name: the name of the peer ( e.g. KNIME ) :param address: the address of the peer. Depends on the protocol ( e.g. for tcp => (str: host, int: port) """ if protocol not in self.protocol_map: raise RuntimeError("No such protocol {}".format(protocol)) self.protocol_map[protocol].add_peer(name, address) @property def sending(self): """ Check if the senders are running ( e.g. any(IPCFacade().running) or all(IPCFacade().running) :return: a list containing True or False for each sender """ return (sender.running for sender in self.senders.values()) @property def receiving(self): """ The same as IPCFacade.sending for the receivers """ return (rec.running for rec in self.receivers.values()) def start(self): """ Start all registered modules """ for module in self._all_modules(): module.start() def stop(self): """ Stop all registered modules """ for module in self._all_modules(): module.stop() def _all_modules(self): return chain(iter(self.senders.values()), iter(self.receivers.values())) @lazy def broadcast(self, command): """ Creates functions that can directly be passed to Qt's connect mechanism e.g. action = IPCFacade().broadcast( ... a command ... ) qtSignal.connect(action) :param command: the command ( dict ) """ # from pprint import PrettyPrinter # PrettyPrinter(indent=4).pprint(command) message = json.dumps(command, cls=NumpyJsonEncoder) log = Protocol.verbose(command) for server in self.senders.values(): server.broadcast(message, log) def show_info(self): """ Displays the IPC Info Widget or moves the windows to the top :return: """ self.info.show() self.info.activateWindow() # bring to top
class IPCFacade(with_metaclass(Singleton, object)): """ The Singleton that encapsulates all IPC functionality Use this to register new server modules or send broadcasts """ def __init__(self): self.info = IPCServerInfoWindow() self.senders = {} self.receivers = {} self.widgets = {} self.protocol_map = {} self.processor = CommandProcessor() def register_shell(self, shell): """ This sets the shell. Must be called before incoming command can be executed :param shell: the ilastik shell """ self.processor.set_shell(shell) def register_widget(self, widget, title, key): """ Add a new widget to the IPCServerWindow :param widget: the widget to add :param title: the title to appear in the tab bar :param key: the key to identify and reference the widget """ if key in self.widgets: raise RuntimeError("Widget {} already exists".format(key)) self.widgets[key] = widget self.info.add_widget(title, widget) def register_module(self, module, type_, key, widget_key=None, protocol=None, start=False): """ Adds a new module to the IPCServer :param module: the module e.g. TCPServer, ZMQPublisher :param type_: "sender" or "receiver" :param key: the key to identify the module later :param widget_key: a reference to the view widget. If not None the module will connect to it :param protocol: set this to redirect handshake command with the matching protocol to this module :param start: if set the module will start immediately """ if type_ == "receiver": container = self.receivers self.processor.connect_receiver(module) elif type_ == "sender": container = self.senders else: raise RuntimeError("Type {} is invalid".format(type_)) if key in container: raise RuntimeError("{} {} already exists".format(type_, key)) container[key] = module if widget_key is not None: module.connect_widget(self.widgets[widget_key]) if protocol is not None: self.protocol_map[protocol] = module if start: module.start() def handshake(self, protocol, name, address): """ Redirects a handshake command to the registered module Currently only TCPClient handles handshake commands from TCPServer :param protocol: the protocol to identify the handler ( e.g. tcp ) :param name: the name of the peer ( e.g. KNIME ) :param address: the address of the peer. Depends on the protocol ( e.g. for tcp => (str: host, int: port) """ if protocol not in self.protocol_map: raise RuntimeError("No such protocol {}".format(protocol)) self.protocol_map[protocol].add_peer(name, address) @property def sending(self): """ Check if the senders are running ( e.g. any(IPCFacade().running) or all(IPCFacade().running) :return: a list containing True or False for each sender """ return (sender.running for sender in self.senders.values()) @property def receiving(self): """ The same as IPCFacade.sending for the receivers """ return (rec.running for rec in self.receivers.values()) def start(self): """ Start all registered modules """ for module in self._all_modules(): module.start() def stop(self): """ Stop all registered modules """ for module in self._all_modules(): module.stop() def _all_modules(self): return chain(iter(self.senders.values()), iter(self.receivers.values())) @lazy def broadcast(self, command): """ Creates functions that can directly be passed to Qt's connect mechanism e.g. action = IPCFacade().broadcast( ... a command ... ) qtSignal.connect(action) :param command: the command ( dict ) """ #from pprint import PrettyPrinter #PrettyPrinter(indent=4).pprint(command) message = json.dumps(command, cls=NumpyJsonEncoder) log = Protocol.verbose(command) for server in self.senders.values(): server.broadcast(message, log) def show_info(self): """ Displays the IPC Info Widget or moves the windows to the top :return: """ self.info.show() self.info.activateWindow() # bring to top