def _handler_thread(self, on_heartbeat_error):
self.logger.debug("Starting")
connection = RabbitMQClient(address=self._rabbit_mq_address,
credentials=self._rabbit_mq_credentials,
exchange=self._exchange_name,
exchange_type='fanout')
def heartbeat_missed():
self.logger.debug("({}) {}".format(self._session_id,
self._missed_heartbeats))
self._missed_heartbeats += 1
limit_exceeded = self._missed_heartbeats >= self._missed_heartbeat_limit
if limit_exceeded:
on_heartbeat_error()
def handle_message(channel, message):
method, properties, body = message
response = json.loads(body)
if response['messageType'] == 'heartbeat':
channel.basic_ack(method.delivery_tag)
self._missed_heartbeats = 0
else:
assert ("Received unexpected message: {}".format(response))
connection.consume(self._heartbeat_interval, handle_message,
heartbeat_missed)
def __init__(self, rabbit_mq_address, rabbit_mq_credentials, session_id):
super(ReadyHandler, self).__init__()
self._connection = RabbitMQClient(
address=rabbit_mq_address,
credentials=rabbit_mq_credentials,
exchange='seahorse_ready_{}'.format(session_id),
exchange_type='fanout')
def __init__(self, gateway_address, r_backend_address,
rabbit_mq_address, rabbit_mq_credentials,
session_id, workflow_id, kernels_source_dir,
py_executing_kernel_source_dir,
r_executing_kernel_source_dir):
super(ExecutingKernelManager, self).__init__()
signal.signal(signal.SIGINT, self.exit_gracefully)
signal.signal(signal.SIGTERM, self.exit_gracefully)
self.executing_kernel_clients = {}
self._kernels_source_dir = kernels_source_dir
self._py_executing_kernel_source_dir = py_executing_kernel_source_dir
self._r_executing_kernel_source_dir = r_executing_kernel_source_dir
self._gateway_address = gateway_address
self._r_backend_address = r_backend_address
self._rabbit_mq_address = rabbit_mq_address
self._rabbit_mq_credentials = rabbit_mq_credentials
self._session_id = session_id
self._workflow_id = workflow_id
self._shutdown_event = Event()
self._multi_kernel_manager = self._init_kernel_manager()
self._rabbit_listener = self._init_rabbit_client()
self._sx_sender = RabbitMQJsonSender(
rabbit_mq_client=RabbitMQClient(address=self._rabbit_mq_address,
credentials=self._rabbit_mq_credentials,
exchange=self.SX_EXCHANGE),
topic=self.SX_PUBLISHING_TOPIC.format(session_id=self._session_id,
workflow_id=self._workflow_id))
def _init_rabbit_clients(self, rabbit_mq_address, rabbit_mq_credentials):
rabbit_client_sender = RabbitMQClient(
address=rabbit_mq_address,
credentials=rabbit_mq_credentials,
exchange=self.EXCHANGE)
rabbit_client_listener = RabbitMQClient(
address=rabbit_mq_address,
credentials=rabbit_mq_credentials,
exchange=self.EXCHANGE)
execution_sender = RabbitMQJsonSender(
rabbit_mq_client=rabbit_client_sender,
topic=self.EXECUTION_PUBLISHING_TOPIC.format(
kernel_id=self._kernel_id))
management_sender = RabbitMQJsonSender(
rabbit_mq_client=rabbit_client_sender,
topic=self.MANAGEMENT_PUBLICATION_TOPIC.format(
session_id=self._session_id, kernel_id=self._kernel_id))
listener = RabbitMQJsonReceiver(rabbit_client_listener)
return execution_sender, management_sender, listener
def _init_rabbit_clients(self):
rabbit_client = RabbitMQClient(
address=self.client_settings.rabbit_mq_address,
credentials=self.client_settings.rabbit_mq_credentials,
exchange=self.EXCHANGE)
sender = RabbitMQJsonSender(
rabbit_mq_client=rabbit_client,
topic=self.EXECUTION_PUBLISHING_TOPIC.format(
kernel_id=self.kernel_id))
listener = RabbitMQJsonReceiver(rabbit_client)
return sender, listener
class ReadyHandler(Logging):
def __init__(self, rabbit_mq_address, rabbit_mq_credentials, session_id):
super(ReadyHandler, self).__init__()
self._connection = RabbitMQClient(
address=rabbit_mq_address,
credentials=rabbit_mq_credentials,
exchange='seahorse_ready_{}'.format(session_id),
exchange_type='fanout')
def handle_ready(self, on_ready):
# noinspection PyUnusedLocal
def handle_message(ch, method, properties, body):
response = json.loads(body)
if response['messageType'] == 'ready':
self.logger.debug(
"Received 'ready'. Calling on_ready callback")
ch.basic_ack(method.delivery_tag)
on_ready()
thread = Thread(target=lambda: self._connection.subscribe(
topic=None, handler=handle_message))
thread.daemon = True
thread.start()
def _init_rabbit_client(self):
rabbit_client = RabbitMQClient(address=self._rabbit_mq_address,
credentials=self._rabbit_mq_credentials,
exchange=self.EXCHANGE)
return RabbitMQJsonReceiver(rabbit_client)