def start(self): log.debug("ExchangeManager.start") total_count = 0 def handle_failure(name, node): log.warn("Node %s could not be started", name) node.ready.set() # let it fall out below # Establish connection(s) to broker for name, cfgkey in CFG.container.messaging.server.iteritems(): if not cfgkey: continue if cfgkey not in CFG.server: raise ExchangeManagerError("Config key %s (name: %s) (from CFG.container.messaging.server) not in CFG.server" % (cfgkey, name)) total_count += 1 log.debug("Starting connection: %s", name) # start it with a zero timeout so it comes right back to us try: cfg_params = CFG.server[cfgkey] if cfg_params['type'] == 'local': node, ioloop = messaging.make_local_node(0, self.container.local_router) else: node, ioloop = messaging.make_node(cfg_params, name, 0) # install a finished handler directly on the ioloop just for this startup period fail_handle = lambda _: handle_failure(name, node) ioloop.link(fail_handle) # wait for the node ready event, with a large timeout just in case node_ready = node.ready.wait(timeout=15) # remove the finished handler, we don't care about it here ioloop.unlink(fail_handle) # only add to our list if we started successfully if not node.running: ioloop.kill() # make sure ioloop dead else: self._nodes[name] = node self._ioloops[name] = ioloop except socket.error as e: log.warn("Could not start connection %s due to socket error, continuing", name) fail_count = total_count - len(self._nodes) if fail_count > 0 or total_count == 0: if fail_count == total_count: raise ExchangeManagerError("No node connection was able to start (%d nodes attempted, %d nodes failed)" % (total_count, fail_count)) log.warn("Some nodes could not be started, ignoring for now") # @TODO change when ready # load interceptors into each map(lambda x: x.setup_interceptors(CFG.interceptor), self._nodes.itervalues()) # prepare priviledged transport self._priviledged_transport = self.get_transport(self._nodes.get('priviledged', self._nodes.get('primary'))) self._priviledged_transport.lock = True # prevent any attempt to close self.default_xs = ExchangeSpace(self, self._priviledged_transport, ION_ROOT_XS) self.xs_by_name[ION_ROOT_XS] = self.default_xs log.debug("Started %d connections (%s)", len(self._nodes), ",".join(self._nodes.iterkeys()))
def start(self): log.debug("ExchangeManager.start") total_count = 0 def handle_failure(name, node, priv): log.warn("Node %s (privileged: %s) could not be started", priv, name) node.ready.set() # let it fall out below # read broker config to get nodes to connect to brokers = [] for broker_name, broker_cfg in CFG.get_safe( 'exchange.exchange_brokers').iteritems(): cfg_key = broker_cfg.get('server', None) if not cfg_key: continue brokers.append((broker_name, cfg_key, False)) priv_key = broker_cfg.get('server_priv', None) if priv_key is not None: brokers.append((broker_name, priv_key, True)) # connect to all known brokers for b in brokers: broker_name, cfgkey, is_priv = b if cfgkey not in CFG.server: raise ExchangeManagerError( "Config key %s (name: %s) (from CFG.container.messaging.server) not in CFG.server" % (cfgkey, broker_name)) total_count += 1 log.debug("Starting connection: %s", broker_name) try: cfg_params = CFG.server[cfgkey] if cfg_params['type'] == 'local': node, ioloop = messaging.make_local_node( 0, self.container.local_router) else: # start it with a zero timeout so it comes right back to us node, ioloop = messaging.make_node(cfg_params, broker_name, 0) # install a finished handler directly on the ioloop just for this startup period fail_handle = lambda _: handle_failure(broker_name, node, is_priv) ioloop.link(fail_handle) # wait for the node ready event, with a large timeout just in case node_ready = node.ready.wait(timeout=15) # remove the finished handler, we don't care about it here ioloop.unlink(fail_handle) # only add to our list if we started successfully if not node.running: ioloop.kill() # make sure ioloop dead else: if is_priv: self._priv_nodes[broker_name] = node self._priv_ioloops[broker_name] = ioloop else: self._nodes[broker_name] = node self._ioloops[broker_name] = ioloop except socket.error as e: log.warn( "Could not start connection %s due to socket error, continuing", broker_name) fail_count = total_count - len(self._nodes) - len(self._priv_nodes) if fail_count > 0 or total_count == 0: if fail_count == total_count: raise ExchangeManagerError( "No node connection was able to start (%d nodes attempted, %d nodes failed)" % (total_count, fail_count)) log.warn("Some nodes could not be started, ignoring for now" ) # @TODO change when ready # load interceptors into each map(lambda x: x.setup_interceptors(CFG.interceptor), self._nodes.itervalues()) map(lambda x: x.setup_interceptors(CFG.interceptor), self._priv_nodes.itervalues()) # prepare privileged transports for name in self._nodes: node = self._priv_nodes.get(name, self._nodes[name]) transport = self.get_transport(node) transport.lock = True # prevent any attempt to close transport.add_on_close_callback( lambda *a, **kw: self._privileged_transport_closed( name, *a, **kw)) self._priv_transports[name] = transport # create default Exchange Space self.default_xs = self._create_root_xs() log.debug("Started %d connections (%s)", len(self._nodes) + len(self._priv_nodes), ",".join(self._nodes.keys() + self._priv_nodes.keys()))
def start(self): log.debug("ExchangeManager.start") total_count = 0 def handle_failure(name, node): log.warn("Node %s could not be started", name) node.ready.set() # let it fall out below # Establish connection(s) to broker for name, cfgkey in CFG.container.messaging.server.iteritems(): if not cfgkey: continue if cfgkey not in CFG.server: raise ExchangeManagerError( "Config key %s (name: %s) (from CFG.container.messaging.server) not in CFG.server" % (cfgkey, name)) total_count += 1 log.debug("Starting connection: %s", name) # start it with a zero timeout so it comes right back to us try: cfg_params = CFG.server[cfgkey] if cfg_params['type'] == 'local': node, ioloop = messaging.make_local_node( 0, self.container.local_router) else: node, ioloop = messaging.make_node(cfg_params, name, 0) # install a finished handler directly on the ioloop just for this startup period fail_handle = lambda _: handle_failure(name, node) ioloop.link(fail_handle) # wait for the node ready event, with a large timeout just in case node_ready = node.ready.wait(timeout=15) # remove the finished handler, we don't care about it here ioloop.unlink(fail_handle) # only add to our list if we started successfully if not node.running: ioloop.kill() # make sure ioloop dead else: self._nodes[name] = node self._ioloops[name] = ioloop except socket.error as e: log.warn( "Could not start connection %s due to socket error, continuing", name) fail_count = total_count - len(self._nodes) if fail_count > 0 or total_count == 0: if fail_count == total_count: raise ExchangeManagerError( "No node connection was able to start (%d nodes attempted, %d nodes failed)" % (total_count, fail_count)) log.warn("Some nodes could not be started, ignoring for now" ) # @TODO change when ready # load interceptors into each map(lambda x: x.setup_interceptors(CFG.interceptor), self._nodes.itervalues()) # prepare priviledged transport self._priviledged_transport = self.get_transport( self._nodes.get('priviledged', self._nodes.get('primary'))) self._priviledged_transport.lock = True # prevent any attempt to close self.default_xs = ExchangeSpace(self, self._priviledged_transport, ION_ROOT_XS) self.xs_by_name[ION_ROOT_XS] = self.default_xs log.debug("Started %d connections (%s)", len(self._nodes), ",".join(self._nodes.iterkeys()))
def start(self): log.debug("ExchangeManager.start") total_count = 0 def handle_failure(name, node, priv): log.warn("Node %s (privileged: %s) could not be started", priv, name) node.ready.set() # let it fall out below # read broker config to get nodes to connect to brokers = [] for broker_name, broker_cfg in CFG.get_safe("exchange.exchange_brokers").iteritems(): cfg_key = broker_cfg.get("server", None) if not cfg_key: continue brokers.append((broker_name, cfg_key, False)) priv_key = broker_cfg.get("server_priv", None) if priv_key is not None: brokers.append((broker_name, priv_key, True)) # connect to all known brokers for b in brokers: broker_name, cfgkey, is_priv = b if cfgkey not in CFG.server: raise ExchangeManagerError( "Config key %s (name: %s) (from CFG.container.messaging.server) not in CFG.server" % (cfgkey, broker_name) ) total_count += 1 log.debug("Starting connection: %s", broker_name) try: cfg_params = CFG.server[cfgkey] if cfg_params["type"] == "local": node, ioloop = messaging.make_local_node(0, self.container.local_router) else: # start it with a zero timeout so it comes right back to us node, ioloop = messaging.make_node(cfg_params, broker_name, 0) # install a finished handler directly on the ioloop just for this startup period fail_handle = lambda _: handle_failure(broker_name, node, is_priv) ioloop.link(fail_handle) # wait for the node ready event, with a large timeout just in case node_ready = node.ready.wait(timeout=15) # remove the finished handler, we don't care about it here ioloop.unlink(fail_handle) # only add to our list if we started successfully if not node.running: ioloop.kill() # make sure ioloop dead else: if is_priv: self._priv_nodes[broker_name] = node self._priv_ioloops[broker_name] = ioloop else: self._nodes[broker_name] = node self._ioloops[broker_name] = ioloop except socket.error as e: log.warn("Could not start connection %s due to socket error, continuing", broker_name) fail_count = total_count - len(self._nodes) - len(self._priv_nodes) if fail_count > 0 or total_count == 0: if fail_count == total_count: raise ExchangeManagerError( "No node connection was able to start (%d nodes attempted, %d nodes failed)" % (total_count, fail_count) ) log.warn("Some nodes could not be started, ignoring for now") # @TODO change when ready # load interceptors into each map(lambda x: x.setup_interceptors(CFG.interceptor), self._nodes.itervalues()) map(lambda x: x.setup_interceptors(CFG.interceptor), self._priv_nodes.itervalues()) # prepare privileged transports for name in self._nodes: node = self._priv_nodes.get(name, self._nodes[name]) transport = self.get_transport(node) transport.lock = True # prevent any attempt to close transport.add_on_close_callback(lambda *a, **kw: self._privileged_transport_closed(name, *a, **kw)) self._priv_transports[name] = transport # create default Exchange Space self.default_xs = self._create_root_xs() log.debug( "Started %d connections (%s)", len(self._nodes) + len(self._priv_nodes), ",".join(self._nodes.keys() + self._priv_nodes.keys()), )