def _check_connection(pid, process_list, timeout): LOG.debug("start check_connection") msg = messaging.Messaging() msg_list = msg.receive_all_msg(timeout_limit=timeout, msg_limit_count=len(process_list)) pid_list = [] for message in msg_list: if message.get('pid'): pid_list.append(message.get('pid')) actives = [] inactives = [] for process in process_list: if pid_list and process.pid in pid_list: rackpipe.Pipe.share(pid, process.pid) msg.send_msg(target=process.pid, message="start") actives.append(process) pid_list.remove(process.pid) else: RACK_CTX.client.processes.delete(RACK_CTX.gid, process.pid) inactives.append(process) LOG.debug("_check_connection active processes count: %s", len(actives)) LOG.debug("_check_connection inactive processes count: %s", len(inactives)) if not actives: msg = "No child process is active." raise Exception(msg) return actives, inactives
def test_send_msg_no_message(self): msg = rack_ipc.Messaging() target = 'test_pid' msg.send_msg(target) routing_key = self.mock_RACK_CTX.gid + '.' + target send_dict = {'pid': self.mock_RACK_CTX.pid} send_msg = cPickle.dumps(send_dict) self.mock_channel.\ basic_publish.assert_called_with(exchange=self.mock_RACK_CTX.gid, routing_key=routing_key, body=send_msg)
def test_declare_queue(self): queue_name = 'test_queue_name' msg = rack_ipc.Messaging() msg.declare_queue(queue_name) self.mock_channel.\ exchange_declare.assert_called_with(exchange=self.mock_RACK_CTX.gid, type='topic') self.mock_channel.queue_declare.assert_called_with(queue=queue_name) r_key = self.mock_RACK_CTX.gid + '.' + queue_name self.mock_channel.queue_bind.assert_called_with(exchange=self.mock_RACK_CTX.gid, queue=queue_name, routing_key=r_key)
def test_receive_msg(self, mock_receive): timeout_limit = 123 msg = rack_ipc.Messaging() message = msg.receive_msg(timeout_limit=timeout_limit) self.mock_connection.add_timeout.\ assert_called_with(deadline=timeout_limit, callback_method=mock_receive().time_out) self.mock_channel.\ basic_consume.assert_called_with(mock_receive().get_msg, queue=self.mock_RACK_CTX.pid, no_ack=False) self.mock_channel.start_consuming.assert_called_with() self.assertEqual(message, mock_receive().message)
def test_receive_get_all_msg(self): ch = Mock() method = Mock() properties = Mock() receive_msg = 'receive_msg' body = cPickle.dumps(receive_msg) ch_object = {'delivery_tag': 'delivery_tag'} method.configure_mock(**ch_object) msg = rack_ipc.Messaging() receive = msg.Receive() receive.get_all_msg(ch, method, properties, body) ch.basic_ack.assert_called_with(delivery_tag=ch_object['delivery_tag']) self.assertEqual(receive.message_list[0], receive_msg)
def test_receive_get_all_msg_count_limit(self): ch = Mock() method = Mock() properties = Mock() message_list = [{'pid': 'child_pid1'}, {'pid': 'child_pid2'}] expected_message_list = copy.deepcopy(message_list) receive_msg = {'pid': 'child_pid3'} expected_message_list.append(receive_msg) body = cPickle.dumps(receive_msg) ch_object = {'delivery_tag': 'delivery_tag'} method.configure_mock(**ch_object) msg = rack_ipc.Messaging() receive = msg.Receive() receive.message_list = message_list receive.msg_count_limit = 3 receive.get_all_msg(ch, method, properties, body) ch.basic_ack.assert_called_with(delivery_tag=ch_object['delivery_tag']) ch.stop_consuming.assert_called_with() self.assertEqual(receive.message_list, expected_message_list)
def test_create_connection_ipc_endpoint(self, mock_pika_connection_param): ipc_ip = 'ipc_ip' self.mock_RACK_CTX.ipc_endpoint = ipc_ip rack_ipc.Messaging() mock_pika_connection_param.assert_called_with(ipc_ip)
def test_create_connection(self): p = patch('pika.ConnectionParameters', autospec=True) self.addCleanup(p.stop) mock_pika_connection_param = p.start() rack_ipc.Messaging() mock_pika_connection_param.assert_called_with(self.mock_RACK_CTX.proxy_ip)
def test_receive_timeout(self): msg = rack_ipc.Messaging() receive = msg.Receive() receive.channel = self.mock_channel receive.time_out() self.mock_channel.stop_consuming.assert_called_with()