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()),
)
