def send(self, msg_str, callback):
try:
msg = simplejson.loads(msg_str)
if len(msg.keys()) != 1:
raise CloudBusError(
'message must be dictionary which has single entry where key is message name'
)
msg_name = msg.keys()[0]
if msg_name not in api_names:
raise CloudBusError('unknown api message[%s]' % msg_name)
msg_body = msg.values()[0]
mid = msg_body['id'] = utils.uuid4()
msg_body['serviceId'] = "api.portal"
headers = {
self.CORRELATION_ID: mid,
self.REPLY_TO: self.conn.reply_queue_name,
self.NO_NEED_REPLY_MSG: 'false'
}
msg_body['headers'] = headers
req = self.Request()
req.callback = callback
req.request = msg
log.debug('add request[id:%s]' % mid)
self.requests[mid] = req
self.conn.send(msg)
log.debug('sent message: %s' % simplejson.dumps(msg))
except simplejson.JSONDecodeError:
raise CloudBusError("invalid JSON format: %s" % msg_str)
def send(self, msg_str, callback):
try:
msg = simplejson.loads(msg_str)
if len(msg.keys()) != 1:
raise CloudBusError('message must be dictionary which has single entry where key is message name')
msg_name = msg.keys()[0]
if msg_name not in api_names:
raise CloudBusError('unknown api message[%s]' % msg_name)
msg_body = msg.values()[0]
mid = msg_body['id'] = utils.uuid4()
msg_body['serviceId'] = "api.portal"
headers = {
self.CORRELATION_ID: mid,
self.REPLY_TO: self.conn.reply_queue_name,
self.NO_NEED_REPLY_MSG: 'false'
}
msg_body['headers'] = headers
req = self.Request()
req.callback = callback
req.request = msg
log.debug('add request[id:%s]' % mid)
self.requests[mid] = req
self.conn.send(msg)
log.debug('sent message: %s' % simplejson.dumps(msg))
except simplejson.JSONDecodeError:
raise CloudBusError("invalid JSON format: %s" % msg_str)
def send(self, msg_str, callback):
try:
msg = simplejson.loads(msg_str)
if len(msg.keys()) != 1:
raise CloudBusError('message must be dictionary which has single entry where key is message name')
msg_name = msg.keys()[0]
if msg_name not in api_names:
raise CloudBusError('unknown api message[%s]' % msg_name)
msg_body = msg.values()[0]
mid = msg_body['id'] = utils.uuid4()
msg_body['serviceId'] = "api.portal"
headers = {
self.CORRELATION_ID: mid,
self.REPLY_TO: self.reply_queue_name,
self.NO_NEED_REPLY_MSG: 'false'
}
msg_body['headers'] = headers
req = self.Request()
req.callback = callback
req.request = msg
log.debug('add request[id:%s]' % mid)
self.requests[mid] = req
with kombu.producers[self.producer_connection].acquire(block=True) as producer:
producer.publish(msg, exchange=self.P2P_EXCHANGE, routing_key=self.API_SERVICE_ID)
log.debug('sent message: %s' % simplejson.dumps(msg))
except simplejson.JSONDecodeError:
raise CloudBusError("invalid JSON format: %s" % msg_str)
def send(self, msg_str, callback):
try:
msg = simplejson.loads(msg_str)
if len(msg.keys()) != 1:
raise CloudBusError(
'message must be dictionary which has single entry where key is message name'
)
msg_name = msg.keys()[0]
if msg_name not in api_names:
raise CloudBusError('unknown api message[%s]' % msg_name)
msg_body = msg.values()[0]
mid = msg_body['id'] = utils.uuid4()
msg_body['serviceId'] = "api.portal"
headers = {
self.CORRELATION_ID: mid,
self.REPLY_TO: self.reply_queue_name,
self.NO_NEED_REPLY_MSG: 'false'
}
msg_body['headers'] = headers
req = self.Request()
req.callback = callback
req.request = msg
log.debug('add request[id:%s]' % mid)
self.requests[mid] = req
with kombu.producers[self.producer_connection].acquire(
block=True) as producer:
producer.publish(msg,
exchange=self.P2P_EXCHANGE,
routing_key=self.API_SERVICE_ID)
log.debug('sent message: %s' % simplejson.dumps(msg))
except simplejson.JSONDecodeError:
raise CloudBusError("invalid JSON format: %s" % msg_str)
def __init__(self):
self.id = utils.uuid4()
self.rsp = None
self.status = self.PROCESSING
def _initalize(self):
if self._status == self.STATUS_INIT:
log.debug('connection is in initializing, ignore this call')
return
self._status = self.STATUS_INIT
if self._current_url:
self._cleanup_current_connection()
def find_usable_url():
while True:
for url in self.urls:
conn = kombu.Connection(url)
try:
conn.connect()
log.debug("find a live connection[%s]" % url)
return url, conn
except Exception as e:
log.warn('cannot connect to %s, %s; try next one ...' % (url, str(e)))
log.warn('failed to connect all urls, sleep 5s and re-try')
time.sleep(5)
self._current_url, self.conn = find_usable_url()
self.should_stop = False
self.uuid = utils.uuid4()
self.p2p_exchange = kombu.Exchange(self.P2P_EXCHANGE, type='topic', passive=True)
self.broadcast_exchange = kombu.Exchange(self.BROADCAST_EXCHANGE, type='topic', passive=True)
self.reply_queue_name = self.QUEUE_PREFIX % self.uuid
self.reply_queue = kombu.Queue(self.reply_queue_name, exchange=self.p2p_exchange, routing_key=self.reply_queue_name, auto_delete=True)
self.api_event_queue_name = self.API_EVENT_QUEUE_PREFIX % self.uuid
self.api_event_queue = kombu.Queue(self.api_event_queue_name, exchange=self.broadcast_exchange, routing_key=self.API_EVENT_QUEUE_BINDING_KEY, auto_delete=True)
self.canonical_event_queue_name = self.CANONICAL_EVENT_QUEUE_PREFIX % self.uuid
self.canonical_event_queue = kombu.Queue(self.canonical_event_queue_name, exchange=self.broadcast_exchange, routing_key=self.CANONICAL_EVENT_BINDING_KEY, auto_delete=True)
def consumer_thread():
try:
log.debug('consumer thread starts')
self._reply_consumer = self.conn.Consumer([self.reply_queue], callbacks=[self.reply_callback])
self._api_event_consumer = self.conn.Consumer([self.api_event_queue], callbacks=[self.api_event_callback])
self._canonical_event_consumer = self.conn.Consumer([self.canonical_event_queue], callbacks=[self.canonical_event_callback])
with kombu.utils.nested(self._reply_consumer, self._api_event_consumer, self._canonical_event_consumer):
while not self.should_stop:
self.conn.drain_events()
except Exception as ce:
if 'exchange.declare' in str(ce):
log.info('cannot declare RabbitMQ exchange(P2P), you need to start ZStack management server before starting dashboard')
os._exit(1)
else:
self.should_stop = True
if self._is_connection_error(ce):
log.warn('lost connection to %s, %s' % (self._current_url, str(ce)))
self._do_initalize_in_thread()
return
raise
self._consumer_thread = threading.Thread(target=consumer_thread)
self._consumer_thread.start()
self._status = self.STATUS_READY
log.debug("connection to %s is ready" % self._current_url)
def __init__(self):
self.id = utils.uuid4()
self.rsp = None
self.status = self.PROCESSING
def __init__(self, options):
self.options = options
self.uuid = utils.uuid4()
self.amqp_url = 'amqp://localhost'
self.requests = {}
self.p2p_exchange = kombu.Exchange(self.P2P_EXCHANGE,
type='topic',
passive=True)
self.broadcast_exchange = kombu.Exchange(self.BROADCAST_EXCHANGE,
type='topic',
passive=True)
self.reply_queue_name = self.QUEUE_PREFIX % self.uuid
self.reply_queue = kombu.Queue(self.reply_queue_name,
exchange=self.p2p_exchange,
routing_key=self.reply_queue_name,
auto_delete=True)
self.api_event_queue_name = self.API_EVENT_QUEUE_PREFIX % self.uuid
self.api_event_queue = kombu.Queue(
self.api_event_queue_name,
exchange=self.broadcast_exchange,
routing_key=self.API_EVENT_QUEUE_BINDING_KEY,
auto_delete=True)
self.should_stop = False
self.reply_connection = None
self.reply_consumer = None
def start_reply_consuming():
try:
log.debug('reply consumer thread starts')
with kombu.Connection(self.amqp_url) as conn:
self.reply_connection = conn
with conn.Consumer([self.reply_queue],
callbacks=[self._message_handler
]) as consumer:
self.reply_consumer = consumer
while not self.should_stop:
conn.drain_events()
except Exception as ce:
if 'exchange.declare' in str(ce):
log.info(
'cannot declare RabbitMQ exchange(P2P), you need to start ZStack management server before starting dashboard'
)
os._exit(1)
else:
raise ce
self.api_tasks = {}
self.reply_consumer_thread = threading.Thread(
target=start_reply_consuming)
self.reply_consumer_thread.start()
self.api_event_connection = None
self.api_event_consumer = None
def start_api_event_consuming():
try:
log.debug('api event consumer thread starts')
with kombu.Connection(self.amqp_url) as conn:
self.api_event_connection = conn
with conn.Consumer([self.api_event_queue],
callbacks=[self._api_event_handler
]) as consumer:
self.api_event_consumer = consumer
while not self.should_stop:
conn.drain_events()
except Exception as ce:
if 'exchange.declare' in str(ce):
log.info(
'cannot declare RabbitMQ exchange(BROADCAST), you need to start ZStack management server before starting dashboard'
)
os._exit(1)
else:
raise ce
self.api_event_consumer_thread = threading.Thread(
target=start_api_event_consuming)
self.api_event_consumer_thread.start()
self.producer_connection = kombu.Connection(self.amqp_url)
def _initalize(self):
if self._status == self.STATUS_INIT:
log.debug('connection is in initializing, ignore this call')
return
self._status = self.STATUS_INIT
if self._current_url:
self._cleanup_current_connection()
def find_usable_url():
while True:
for url in self.urls:
conn = kombu.Connection(url)
try:
conn.connect()
log.debug("find a live connection[%s]" % url)
return url, conn
except Exception as e:
log.warn('cannot connect to %s, %s; try next one ...' %
(url, str(e)))
log.warn('failed to connect all urls, sleep 5s and re-try')
time.sleep(5)
self._current_url, self.conn = find_usable_url()
self.should_stop = False
self.uuid = utils.uuid4()
self.p2p_exchange = kombu.Exchange(self.P2P_EXCHANGE,
type='topic',
passive=True)
self.broadcast_exchange = kombu.Exchange(self.BROADCAST_EXCHANGE,
type='topic',
passive=True)
self.reply_queue_name = self.QUEUE_PREFIX % self.uuid
self.reply_queue = kombu.Queue(self.reply_queue_name,
exchange=self.p2p_exchange,
routing_key=self.reply_queue_name,
auto_delete=True)
self.api_event_queue_name = self.API_EVENT_QUEUE_PREFIX % self.uuid
self.api_event_queue = kombu.Queue(
self.api_event_queue_name,
exchange=self.broadcast_exchange,
routing_key=self.API_EVENT_QUEUE_BINDING_KEY,
auto_delete=True)
self.canonical_event_queue_name = self.CANONICAL_EVENT_QUEUE_PREFIX % self.uuid
self.canonical_event_queue = kombu.Queue(
self.canonical_event_queue_name,
exchange=self.broadcast_exchange,
routing_key=self.CANONICAL_EVENT_BINDING_KEY,
auto_delete=True)
def consumer_thread():
try:
log.debug('consumer thread starts')
self._reply_consumer = self.conn.Consumer(
[self.reply_queue], callbacks=[self.reply_callback])
self._api_event_consumer = self.conn.Consumer(
[self.api_event_queue],
callbacks=[self.api_event_callback])
self._canonical_event_consumer = self.conn.Consumer(
[self.canonical_event_queue],
callbacks=[self.canonical_event_callback])
with kombu.utils.nested(self._reply_consumer,
self._api_event_consumer,
self._canonical_event_consumer):
while not self.should_stop:
self.conn.drain_events()
except Exception as ce:
if 'exchange.declare' in str(ce):
log.info(
'cannot declare RabbitMQ exchange(P2P), you need to start ZStack management server before starting dashboard'
)
os._exit(1)
else:
self.should_stop = True
if self._is_connection_error(ce):
log.warn('lost connection to %s, %s' %
(self._current_url, str(ce)))
self._do_initalize_in_thread()
return
raise
self._consumer_thread = threading.Thread(target=consumer_thread)
self._consumer_thread.start()
self._status = self.STATUS_READY
log.debug("connection to %s is ready" % self._current_url)
def __init__(self, options):
self.options = options
self.uuid = utils.uuid4()
self.canonical_event_handlers = {}
rabbitmq_list = self.options.rabbitmq.split(',')
rabbitmq_list = ["amqp://%s" % r for r in rabbitmq_list]
self.amqp_url = ';'.join(rabbitmq_list)
self.requests = {}
self.p2p_exchange = kombu.Exchange(self.P2P_EXCHANGE, type='topic', passive=True)
self.broadcast_exchange = kombu.Exchange(self.BROADCAST_EXCHANGE, type='topic', passive=True)
self.reply_queue_name = self.QUEUE_PREFIX % self.uuid
self.reply_queue = kombu.Queue(self.reply_queue_name, exchange=self.p2p_exchange, routing_key=self.reply_queue_name, auto_delete=True)
self.api_event_queue_name = self.API_EVENT_QUEUE_PREFIX % self.uuid
self.api_event_queue = kombu.Queue(self.api_event_queue_name, exchange=self.broadcast_exchange, routing_key=self.API_EVENT_QUEUE_BINDING_KEY, auto_delete=True)
self.canonical_event_queue_name = self.CANONICAL_EVENT_QUEUE_PREFIX % self.uuid
self.canonical_event_queue = kombu.Queue(self.canonical_event_queue_name, exchange=self.broadcast_exchange, routing_key=self.CANONICAL_EVENT_BINDING_KEY, auto_delete=True)
self.should_stop = False
self.reply_connection = None
self.reply_consumer = None
def start_reply_consuming():
try:
log.debug('reply consumer thread starts')
with kombu.Connection(self.amqp_url) as conn:
self.reply_connection = conn
with conn.Consumer([self.reply_queue], callbacks=[self._message_handler]) as consumer:
self.reply_consumer = consumer
while not self.should_stop:
conn.drain_events()
except Exception as ce:
if 'exchange.declare' in str(ce):
log.info('cannot declare RabbitMQ exchange(P2P), you need to start ZStack management server before starting dashboard')
os._exit(1)
else:
raise ce
self.api_tasks = {}
self.reply_consumer_thread = threading.Thread(target=start_reply_consuming)
self.reply_consumer_thread.start()
self.api_event_connection = None
self.api_event_consumer = None
def start_api_event_consuming():
try:
log.debug('api event consumer thread starts')
with kombu.Connection(self.amqp_url) as conn:
self.api_event_connection = conn
with conn.Consumer([self.api_event_queue], callbacks=[self._api_event_handler]) as consumer:
self.api_event_consumer = consumer
while not self.should_stop:
conn.drain_events()
except Exception as ce:
if 'exchange.declare' in str(ce):
log.info('cannot declare RabbitMQ exchange(BROADCAST), you need to start ZStack management server before starting dashboard')
os._exit(1)
else:
raise ce
self.api_event_consumer_thread = threading.Thread(target=start_api_event_consuming)
self.api_event_consumer_thread.start()
self.canonical_event_connection = None
self.canonical_event_consumer = None
def start_canonical_event_consumer():
try:
log.debug('canonical event consumer thread starts')
with kombu.Connection(self.amqp_url) as conn:
self.canonical_event_connection = conn
with conn.Consumer([self.canonical_event_queue], callbacks=[self._canonical_event_handler]) as consumer:
self.canonical_event_consumer = consumer
while not self.should_stop:
conn.drain_events()
except Exception as ce:
if 'exchange.declare' in str(ce):
log.info('cannot declare RabbitMQ exchange(BROADCAST), you need to start ZStack management server before starting dashboard')
os._exit(1)
else:
raise ce
self.canonical_event_consumer_thread = threading.Thread(target=start_canonical_event_consumer)
self.canonical_event_consumer_thread.start()
self.producer_connection = kombu.Connection(self.amqp_url)
