def test_connection_open_new_channel(self): connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True) connection.set_state(connection.OPEN) def on_open_ok(_, frame_out): self.assertIsInstance(frame_out, specification.Channel.Open) connection._channels[1].on_frame(specification.Channel.OpenOk()) connection.write_frame = on_open_ok connection.channel()
class PublisherConfirmsTest(unittest.TestCase): connection = None channel = None queue_name = 'test.basic.confirm' def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare(self.queue_name) self.channel.queue.purge(self.queue_name) self.channel.confirm_deliveries() def test_functional_publish_and_confirm(self): self.channel.basic.publish(body=str(uuid.uuid4()), routing_key=self.queue_name) # Sleep for 0.1s to make sure RabbitMQ has time to catch up. time.sleep(0.1) payload = self.channel.queue.declare(self.queue_name, passive=True) self.assertEqual(payload['message_count'], 1) def tearDown(self): self.channel.queue.delete(self.queue_name) self.channel.close() self.connection.close()
class PublishAndGetEmptyMessagesTest(unittest.TestCase): connection = None channel = None queue_name = 'test.basic.get_empty' def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare(self.queue_name) self.channel.queue.purge(self.queue_name) def test_functional_publish_and_get_five_empty_messages(self): # Publish 5 Messages. for _ in range(5): self.channel.basic.publish(body=b'', routing_key=self.queue_name) # Sleep for 0.1s to make sure RabbitMQ has time to catch up. time.sleep(0.1) # Get 5 messages. inbound_messages = [] for _ in range(5): payload = self.channel.basic.get(self.queue_name, to_dict=False) self.assertIsInstance(payload, Message) self.assertEqual(payload.body, b'') inbound_messages.append(payload) self.assertEqual(len(inbound_messages), 5) def tearDown(self): self.channel.queue.delete(self.queue_name) self.channel.close() self.connection.close()
class Publish50kTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.50k') self.channel.queue.purge('test.basic.50k') def test_publish_50k_messages(self): body = str(uuid.uuid4()) # Publish 50k Messages. start_time = time.time() for _ in range(50000): self.channel.basic.publish(body=body, routing_key='test.basic.50k') end_time = time.time() - start_time # Sleep for 2.5s to make sure RabbitMQ has time to catch up. time.sleep(2.5) result = self.channel.queue.declare(queue='test.basic.50k', passive=True) LOGGER.info('Published 50k messages in %d', round(end_time, 3)) self.assertEqual(result['message_count'], 50000) def tearDown(self): self.channel.queue.delete('test.basic.50k') self.channel.close() self.connection.close()
def init(Rendering): global rendering rendering = Rendering # Save the queue global queue queue = queue.Queue() # Create a local messaging connection Config = configparser.ConfigParser() Config.read('./config/mirror_config.ini') connection = Connection(Config.get('General', 'messaging_ip'), 'guest', 'guest') global __channel __channel = connection.channel() # Create an exchange for the mirror-messages - type is direct so we can distinguish the different messages __channel.exchange.declare(exchange='from-mirror', exchange_type='direct') __channel.exchange.declare(exchange='from-server', exchange_type='direct') # Declare a queue to be used (random name will be used) result = __channel.queue.declare(exclusive=True) queue_name = result['queue'] # Listen to server messages for msg_keys in MSG_TO_MIRROR_KEYS: __channel.queue.bind(exchange='from-server', queue=queue_name, routing_key=msg_keys.name) __channel.basic.consume(consume_server_message, queue=queue_name, no_ack=True)
class PublishAndGetLargeMessageTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.confirm_deliveries() self.channel.queue.declare('test.basic.get_large') self.channel.queue.purge('test.basic.get_large') def test_publish_and_get_large_message(self): try: body = str(uuid.uuid4()) * 65536 # Publish a single large message self.channel.basic.publish(body=body, routing_key='test.basic.get_large') payload = self.channel.basic.get('test.basic.get_large', to_dict=False) self.assertEqual(body, payload.body) finally: self.channel.queue.purge('test.basic.get_large') def tearDown(self): self.channel.queue.delete('test.basic.get_large') self.channel.close() self.connection.close()
class GetAndRedeliverTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.get.redeliver') self.channel.queue.purge('test.get.redeliver') self.channel.confirm_deliveries() self.message = str(uuid.uuid4()) self.channel.basic.publish(body=self.message, routing_key='test.get.redeliver') message = self.channel.basic.get('test.get.redeliver', no_ack=False, to_dict=False) message.reject() # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) def test_get_and_redeliver(self): message = self.channel.basic.get('test.get.redeliver', no_ack=False, to_dict=False) self.assertEqual(message.body, self.message) def tearDown(self): self.channel.queue.delete('test.get.redeliver') self.channel.close() self.connection.close()
class PublishLargeMessagesAndGetTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.confirm_deliveries() self.channel.queue.declare('test.basic.large_messages') self.channel.queue.purge('test.basic.large_messages') def test_publish_5_large_messages(self): body = str(uuid.uuid4()) * 8192 messages_to_publish = 5 # Publish 5 Messages. for _ in range(messages_to_publish): self.channel.basic.publish(body=body, routing_key='test.basic.large_messages') inbound_messages = [] for _ in range(messages_to_publish): message = self.channel.basic.get('test.basic.large_messages', no_ack=True, to_dict=False) self.assertEqual(message.body, body) inbound_messages.append(message) self.assertEqual(len(inbound_messages), messages_to_publish) def tearDown(self): self.channel.queue.delete('test.basic.large_messages') self.channel.close() self.connection.close()
class PublishAndGetMessagesTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.get') self.channel.queue.purge('test.basic.get') def test_publish_and_get_five_messages(self): # Publish 5 Messages. for _ in range(5): self.channel.basic.publish(body=str(uuid.uuid4()), routing_key='test.basic.get') # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) # Get 5 messages. for _ in range(5): payload = self.channel.basic.get('test.basic.get', to_dict=False) self.assertIsInstance(payload, Message) def tearDown(self): self.channel.queue.delete('test.basic.get') self.channel.close() self.connection.close()
class PublishEmptyMessagesAndConsumeTest(unittest.TestCase): connection = None channel = None queue_name = 'test.basic.empty_messages' def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.confirm_deliveries() self.channel.queue.declare(self.queue_name) self.channel.queue.purge(self.queue_name) def test_functional_publish_5_empty_messages(self): body = b'' messages_to_publish = 5 self.channel.basic.consume(queue=self.queue_name, no_ack=True) # Publish 5 Messages. for _ in range(messages_to_publish): self.channel.basic.publish(body=body, routing_key=self.queue_name) inbound_messages = [] for message in self.channel.build_inbound_messages(break_on_empty=True): self.assertEqual(message.body, body) inbound_messages.append(message) self.assertEqual(len(inbound_messages), messages_to_publish) def tearDown(self): self.channel.queue.delete(self.queue_name) self.channel.close() self.connection.close()
def consumer(): connection = Connection(HOST, USERNAME, PASSWORD) channel = connection.channel() # Declare a queue. channel.queue.declare(QUEUE_NAME) # Publish something we can get. channel.basic.publish(body='Hello World!', routing_key=QUEUE_NAME, properties={'content_type': 'text/plain'}) # Retrieve a single message. result = channel.basic.get(queue=QUEUE_NAME, no_ack=False) if result: # If we got a message, handle it. print('Message:', result['body']) # Mark the message as handle. channel.basic.ack(delivery_tag=result['method']['delivery_tag']) else: # The queue was empty. print("Queue '{0}' Empty.".format(QUEUE_NAME)) channel.close() connection.close()
class GeneratorConsumeMessagesTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.generator') self.channel.queue.purge('test.basic.generator') self.channel.confirm_deliveries() for _ in range(5): self.channel.basic.publish(body=str(uuid.uuid4()), routing_key='test.basic.generator') self.channel.basic.consume(queue='test.basic.generator', no_ack=True) # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) def test_generator_consume(self): # Store and inbound messages. inbound_messages = [] for message in \ self.channel.build_inbound_messages(break_on_empty=True): self.assertIsInstance(message, Message) inbound_messages.append(message) # Make sure all five messages were downloaded. self.assertEqual(len(inbound_messages), 5) def tearDown(self): self.channel.queue.delete('test.basic.generator') self.channel.close() self.connection.close()
class Publish50kTest(unittest.TestCase): connection = None channel = None messages_to_send = 50000 queue_name = 'test.basic.50k' def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare(self.queue_name) self.channel.queue.purge(self.queue_name) def test_functional_publish_50k_messages(self): body = str(uuid.uuid4()) # Publish 50k Messages. for _ in range(self.messages_to_send): self.channel.basic.publish(body=body, routing_key=self.queue_name) result = {} # Let's give RabbitMQ a few seconds to catch up. for _ in range(5): time.sleep(0.5) result = self.channel.queue.declare(queue=self.queue_name, passive=True) if self.messages_to_send == result['message_count']: break self.assertEqual(result['message_count'], self.messages_to_send) def tearDown(self): self.channel.queue.delete(self.queue_name) self.channel.close() self.connection.close()
class OpenMultipleChannelTest(unittest.TestCase): connection = None channel = None def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD, lazy=True) def test_functional_open_multiple_channels(self): self.connection.open() self.assertIsNotNone(self.connection._io.socket) self.assertIsNotNone(self.connection._io.poller) self.assertTrue(self.connection.is_open) for index in range(255): channel = self.connection.channel() # Verify that the Channel has been opened properly. self.assertTrue(channel.is_open) self.assertEqual(int(channel), index + 1) self.connection.close() time.sleep(0.1) self.assertTrue(self.connection.is_closed) self.assertIsNone(self.connection._io.socket) self.assertIsNone(self.connection._io.poller) self.assertEqual(threading.activeCount(), 1, msg='Current Active threads: %s' % threading._active) def tearDown(self): self.connection.close()
class PublishFailAndFix(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.confirm_deliveries() def test_publish_and_confirm(self): try: self.channel.basic.publish(body=str(uuid.uuid4()), routing_key='test.publish.fail.and.fix', mandatory=True) except AMQPChannelError as why: self.assertTrue(self.channel.is_open) self.assertEqual(why.error_code, 312) if why.error_code == 312: self.channel.queue.declare('test.publish.fail.and.fix') result = \ self.channel.basic.publish(body=str(uuid.uuid4()), routing_key='test.publish.fail.and.fix', mandatory=True) self.assertTrue(result) payload = self.channel.queue.declare('test.publish.fail.and.fix', passive=True) self.assertEqual(payload['message_count'], 1) def tearDown(self): self.channel.queue.delete('test.publish.fail.and.fix') self.channel.close() self.connection.close()
class ExchangeFunctionalTests(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() def test_functional_exchange_declare(self): self.channel.exchange.declare('test_functional_exchange_declare', passive=False, durable=True, auto_delete=True) self.channel.exchange.declare('test_functional_exchange_declare', passive=True) def test_functional_exchange_delete(self): self.channel.exchange.declare('test_functional_exchange_delete') self.channel.exchange.delete('test_functional_exchange_delete', if_unused=True) self.assertRaises(amqpstorm.AMQPChannelError, self.channel.exchange.declare, 'test_functional_exchange_delete', passive=True) def tearDown(self): self.channel.close() self.connection.close()
class PublishMessageAndResend(unittest.TestCase): connection = None channel = None queue_name = 'test.basic.resend' def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare(self.queue_name) self.channel.queue.purge(self.queue_name) self.channel.confirm_deliveries() message = Message.create(self.channel, body=str(uuid.uuid4())) message.app_id = 'travis-ci' message.publish(self.queue_name) def test_functional_publish_with_properties_and_get(self): message = self.channel.basic.get(self.queue_name, to_dict=False, no_ack=True) # Check original app_id self.assertEqual(message.app_id, 'travis-ci') # Assign Property app_id app_id = 'travis-ci-2'.encode('utf-8') message.app_id = app_id # Check that it was set correctly. self.assertEqual(message.properties['app_id'], app_id) # Get Property Correlation Id correlation_id = message.correlation_id # Publish Message message.publish(routing_key=self.queue_name) # Sleep for 0.1s to make sure RabbitMQ has time to catch up. time.sleep(0.1) # New way payload = self.channel.basic.get(self.queue_name, to_dict=False, no_ack=True) self.assertEqual(payload.app_id, app_id.decode('utf-8')) self.assertEqual(payload.correlation_id, correlation_id) self.assertIsInstance(payload.properties['app_id'], str) self.assertIsInstance(payload.properties['correlation_id'], str) # Old way result = payload.to_dict() self.assertIsInstance(result['properties']['app_id'], bytes) self.assertIsInstance(result['properties']['correlation_id'], bytes) self.assertEqual(result['properties']['app_id'], app_id) self.assertEqual(result['properties']['correlation_id'], correlation_id.encode('utf-8')) def tearDown(self): self.channel.queue.delete(self.queue_name) self.channel.close() self.connection.close()
class PublishWithPropertiesAndGetTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.properties') self.channel.queue.purge('test.basic.properties') self.channel.confirm_deliveries() def test_publish_with_properties_and_get(self): app_id = 'travis-ci'.encode('utf-8') properties = { 'headers': { 'key': 1234567890, 'alpha': 'omega' } } message = Message.create(self.channel, body=str(uuid.uuid4()), properties=properties) # Assign Property app_id message.app_id = app_id # Check that it was set correctly. self.assertEqual(message.properties['app_id'], app_id) # Get Property Correlation Id correlation_id = message.correlation_id # Publish Message message.publish(routing_key='test.basic.properties') # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) # New way payload = self.channel.basic.get('test.basic.properties', to_dict=False) self.assertEqual(payload.properties['headers']['key'], 1234567890) self.assertEqual(payload.properties['headers']['alpha'], 'omega') self.assertEqual(payload.app_id, app_id.decode('utf-8')) self.assertEqual(payload.correlation_id, correlation_id) self.assertIsInstance(payload.properties['app_id'], str) self.assertIsInstance(payload.properties['correlation_id'], str) # Old way result = payload.to_dict() self.assertEqual(result['properties']['headers'][b'key'], 1234567890) self.assertEqual(result['properties']['headers'][b'alpha'], b'omega') self.assertIsInstance(result['properties']['app_id'], bytes) self.assertIsInstance(result['properties']['correlation_id'], bytes) self.assertEqual(result['properties']['app_id'], app_id) self.assertEqual(result['properties']['correlation_id'], correlation_id.encode('utf-8')) def tearDown(self): self.channel.queue.delete('test.basic.properties') self.channel.close() self.connection.close()
def _open_channel(connection: Connection) -> Channel: """ returns the current opened channel of the amqp connection """ LOGGER.debug('opening new BlockingChannel on opened connection') channel = connection.channel() LOGGER.debug('opened new BlockingChannel on opened connection') return channel
def __init__(self): # Queue to save all incoming messages self.incoming_msgs_queue = queue.Queue() # Create a messaging connection Config = configparser.ConfigParser() Config.read('./config/mirror_config.ini') connection = Connection(Config.get('General', 'messaging_ip'), 'guest', 'guest') global __channel_consuming global __channel_sending __channel_consuming = connection.channel() __channel_sending = connection.channel() self._initiate_messaging_to_mirror() self._initiate_message_consuming()
def consumer(): connection = Connection('127.0.0.1', 'guest', 'guest', ssl=True, port=5671) channel = connection.channel() channel.queue.declare('simple_queue') channel.basic.publish(body='Hello World!', routing_key='simple_queue') channel.close() connection.close()
def test_connection_avoid_conflicts_with_channel_ids(self): connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True) connection.set_state(connection.OPEN) for index in compatibility.RANGE(1, 301): connection._channels[index] = None for index in compatibility.RANGE(302, 65535): connection._channels[index] = None last_channel_id = int(connection.channel(lazy=True)) self.assertEqual(last_channel_id, 301) self.assertEqual(connection._last_channel_id, 301) last_channel_id = int(connection.channel(lazy=True)) self.assertEqual(last_channel_id, 65535) self.assertEqual(connection._last_channel_id, 65535)
class PublishAndFail(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.publish.and.fail') self.channel.confirm_deliveries() def test_publish_and_confirm(self): message = Message.create(self.channel, 'hello world') self.assertRaises(AMQPChannelError, message.publish, 'hello_world', exchange='fake_exchange', mandatory=True) self.assertFalse(self.channel.is_open) def tearDown(self): self.channel = self.connection.channel() self.channel.queue.delete('test.publish.and.fail') self.channel.close() self.connection.close()
def test_connection_open_many_channels(self): connection = Connection('127.0.0.1', 'guest', 'guest', timeout=0.1, lazy=True) connection.set_state(connection.OPEN) for index in range(MAX_CHANNELS - 1): self.assertEqual(int(connection.channel(lazy=True)), index + 1)
class OpenCloseChannelLoopTest(unittest.TestCase): connection = None channel = None queue_name = 'test.open.close' def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD, lazy=True) def test_functional_open_close_channel_loop(self): for _ in range(100): self.connection.open() self.channel = self.connection.channel() # Verify that the Connection/Channel has been opened properly. self.assertIsNotNone(self.connection._io.socket) self.assertIsNotNone(self.connection._io.poller) self.assertTrue(self.channel.is_open) self.assertTrue(self.connection.is_open) self.channel.queue.declare(self.queue_name) self.channel.basic.publish(body=str(uuid.uuid4()), routing_key=self.queue_name) self.channel.close() self.connection.close() # Verify that the Connection/Channel has been closed properly. self.assertTrue(self.channel.is_closed) self.assertTrue(self.connection.is_closed) self.assertIsNone(self.connection._io.socket) self.assertIsNone(self.connection._io.poller) time.sleep(0.1) self.assertEqual(threading.activeCount(), 1, msg='Current Active threads: %s' % threading._active) def tearDown(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.delete(self.queue_name) self.channel.close() self.connection.close()
class PublishMessageAndResend(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.resend') self.channel.queue.purge('test.basic.resend') self.channel.confirm_deliveries() message = Message.create(self.channel, body=str(uuid.uuid4())) message.app_id = 'travis-ci' message.publish('test.basic.resend') def test_publish_with_properties_and_get(self): message = self.channel.basic.get('test.basic.resend', to_dict=False, no_ack=True) # Check original app_id self.assertEqual(message.app_id, 'travis-ci') # Assign Property app_id app_id = 'travis-ci-2'.encode('utf-8') message.app_id = app_id # Check that it was set correctly. self.assertEqual(message.properties['app_id'], app_id) # Get Property Correlation Id correlation_id = message.correlation_id # Publish Message message.publish(routing_key='test.basic.resend') # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) # New way payload = self.channel.basic.get('test.basic.resend', to_dict=False, no_ack=True) self.assertEqual(payload.app_id, app_id.decode('utf-8')) self.assertEqual(payload.correlation_id, correlation_id) self.assertIsInstance(payload.properties['app_id'], str) self.assertIsInstance(payload.properties['correlation_id'], str) # Old way result = payload.to_dict() self.assertIsInstance(result['properties']['app_id'], bytes) self.assertIsInstance(result['properties']['correlation_id'], bytes) self.assertEqual(result['properties']['app_id'], app_id) self.assertEqual(result['properties']['correlation_id'], correlation_id.encode('utf-8')) def tearDown(self): self.channel.queue.delete('test.basic.resend') self.channel.close() self.connection.close()
def consumer(): connection = Connection(HOST, USERNAME, PASSWORD, ssl=True, port=5671, ssl_options={ 'ssl_version': ssl.PROTOCOL_TLSv1, 'cert_reqs': ssl.CERT_NONE }) channel = connection.channel() channel.queue.declare('simple_queue') channel.basic.publish(body='Hello World!', routing_key='simple_queue') channel.close() connection.close()
class QueueFunctionalTests(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() def test_functional_queue_declare(self): self.channel.queue.declare('test_functional_queue_declare', passive=False, durable=True, auto_delete=True) self.channel.queue.declare('test_functional_queue_declare', passive=True) def test_functional_queue_delete(self): self.channel.queue.declare('test_functional_queue_delete') self.channel.queue.delete('test_functional_queue_delete', if_unused=True) self.assertRaises(amqpstorm.AMQPChannelError, self.channel.queue.declare, 'test_functional_queue_delete', passive=True) def test_functional_queue_purge(self): payload = 'hello world' queue = 'test_functional_functional_queue_purge' messages_to_send = 10 self.channel.queue.declare(queue, auto_delete=True) for _ in range(messages_to_send): self.channel.basic.publish(payload, queue) result = self.channel.queue.purge(queue) self.assertEqual(result['message_count'], messages_to_send) def test_functional_queue_bind(self): queue = 'test_functional_queue_bind' self.channel.queue.declare(queue, passive=False, durable=True, auto_delete=True) self.assertEqual( self.channel.queue.bind(queue=queue, exchange='amq.direct'), {}) def test_functional_queue_unbind(self): queue = 'test_functional_queue_unbind' self.channel.queue.declare(queue, passive=False, durable=True, auto_delete=True) self.channel.queue.bind(queue=queue, exchange='amq.direct') self.assertEqual( self.channel.queue.unbind(queue=queue, exchange='amq.direct'), {}) def tearDown(self): self.channel.close() self.connection.close()
class PublishWithPropertiesAndGetTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.properties') self.channel.queue.purge('test.basic.properties') self.channel.confirm_deliveries() def test_publish_with_properties_and_get(self): app_id = 'travis-ci'.encode('utf-8') properties = {'headers': {'key': 1234567890, 'alpha': 'omega'}} message = Message.create(self.channel, body=str(uuid.uuid4()), properties=properties) # Assign Property app_id message.app_id = app_id # Check that it was set correctly. self.assertEqual(message.properties['app_id'], app_id) # Get Property Correlation Id correlation_id = message.correlation_id # Publish Message message.publish(routing_key='test.basic.properties') # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) # New way payload = self.channel.basic.get('test.basic.properties', to_dict=False) self.assertEqual(payload.properties['headers']['key'], 1234567890) self.assertEqual(payload.properties['headers']['alpha'], 'omega') self.assertEqual(payload.app_id, app_id.decode('utf-8')) self.assertEqual(payload.correlation_id, correlation_id) self.assertIsInstance(payload.properties['app_id'], str) self.assertIsInstance(payload.properties['correlation_id'], str) # Old way result = payload.to_dict() self.assertEqual(result['properties']['headers'][b'key'], 1234567890) self.assertEqual(result['properties']['headers'][b'alpha'], b'omega') self.assertIsInstance(result['properties']['app_id'], bytes) self.assertIsInstance(result['properties']['correlation_id'], bytes) self.assertEqual(result['properties']['app_id'], app_id) self.assertEqual(result['properties']['correlation_id'], correlation_id.encode('utf-8')) def tearDown(self): self.channel.queue.delete('test.basic.properties') self.channel.close() self.connection.close()
def test_connection_close_old_ids_with_channel(self): max_channels = 1024 connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True) connection._channel0.max_allowed_channels = max_channels connection.set_state(connection.OPEN) for _ in compatibility.RANGE(max_channels): connection.channel(lazy=True) ids_to_close = [2, 8, 16, 32, 64, 128, 256, 512, 768, 1024] for _ in range(100): for index in ids_to_close: del connection._channels[index] self.assertEqual(len(connection._channels), max_channels - len(ids_to_close)) for _ in ids_to_close: self.assertIn(int(connection.channel(lazy=True)), ids_to_close) self.assertEqual(len(connection._channels), max_channels)
def test_connection_avoid_conflicts_with_channel_ids(self): connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True) connection.set_state(connection.OPEN) for index in compatibility.RANGE(1, 301): connection._channels[index] = None for index in compatibility.RANGE(302, 65535): connection._channels[index] = None last_channel_id = int(connection.channel(lazy=True)) self.assertEqual( last_channel_id, 301 ) self.assertEqual(connection._last_channel_id, 301) last_channel_id = int(connection.channel(lazy=True)) self.assertEqual( last_channel_id, 65535 ) self.assertEqual(connection._last_channel_id, 65535)
class OpenCloseOpenCloseTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD, lazy=True) def test_open_close_loop(self): for _ in range(100): self.connection.open() self.channel = self.connection.channel() # Verify that the Connection/Channel has been opened properly. self.assertIsNotNone(self.connection._io.socket) self.assertIsNotNone(self.connection._io.poller) self.assertTrue(self.channel.is_open) self.assertTrue(self.connection.is_open) self.channel.queue.declare('test.open.close') self.channel.basic.publish(body=str(uuid.uuid4()), routing_key='test.open.close') self.channel.close() self.connection.close() # Verify that the Connection/Channel has been closed properly. self.assertTrue(self.channel.is_closed) self.assertTrue(self.connection.is_closed) self.assertIsNone(self.connection._io.socket) self.assertIsNone(self.connection._io.poller) time.sleep(0.1) self.assertEqual(threading.activeCount(), 1, msg='Current Active threads: %s' % threading._active) def tearDown(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.delete('test.open.close') self.channel.close() self.connection.close()
class AmqpClient: def __init__(self, source_queue, sink_queue, host="localhost", user="******", password="******"): self.source_queue = source_queue self.sink_queue = sink_queue self.connection = Connection(host, user, password) self.channel = self.connection.channel() self.channel.queue.declare(source_queue) self.channel.queue.declare(sink_queue) self.process_func = None def set_process_func(self, func): self.process_func = func def _on_message(self, message): try: if self.process_func: passed, result = self.process_func(message.body) if passed: logger.debug("Sending result: {}".format(result)) message = Message.create(self.channel, body=result) message.content_type = 'application/json' message.publish(routing_key=self.sink_queue) else: logger.debug("Received message:", message.body) except Exception as e: logger.error("Exception thrown when calling UDF!") def _amqp_thread(self): self.channel.basic.consume(self._on_message, self.source_queue) try: self.channel.start_consuming() except BaseException: self.channel.close() def run(self): self.thread = threading.Thread(target=self._amqp_thread) self.thread.setDaemon(True) self.thread.start() def stop(self): if self.channel: self.channel.close()
class QueueFunctionalTests(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() def test_functional_queue_declare(self): self.channel.queue.declare('test_functional_queue_declare', passive=False, durable=True, auto_delete=True) self.channel.queue.declare('test_functional_queue_declare', passive=True) def test_functional_queue_delete(self): self.channel.queue.declare('test_functional_queue_delete') self.channel.queue.delete('test_functional_queue_delete', if_unused=True) self.assertRaises(amqpstorm.AMQPChannelError, self.channel.queue.declare, 'test_functional_queue_delete', passive=True) def test_functional_queue_purge(self): payload = 'hello world' queue = 'test_functional_functional_queue_purge' messages_to_send = 10 self.channel.queue.declare(queue, auto_delete=True) for _ in range(messages_to_send): self.channel.basic.publish(payload, queue) result = self.channel.queue.purge(queue) self.assertEqual(result['message_count'], messages_to_send) def test_functional_queue_bind(self): queue = 'test_functional_queue_bind' self.channel.queue.declare(queue, passive=False, durable=True, auto_delete=True) self.assertEqual(self.channel.queue.bind(queue=queue, exchange='amq.direct'), {}) def test_functional_queue_unbind(self): queue = 'test_functional_queue_unbind' self.channel.queue.declare(queue, passive=False, durable=True, auto_delete=True) self.channel.queue.bind(queue=queue, exchange='amq.direct') self.assertEqual(self.channel.queue.unbind(queue=queue, exchange='amq.direct'), {}) def tearDown(self): self.channel.close() self.connection.close()
class Consumer(object): def __init__(self, max_retries=None): self.max_retries = max_retries self.connection = None def create_connection(self): """Create a connection. :return: """ attempts = 0 while True: attempts += 1 try: self.connection = Connection('127.0.0.1', 'guest', 'guest') break except amqpstorm.AMQPError as why: LOGGER.exception(why) if self.max_retries and attempts > self.max_retries: break time.sleep(min(attempts * 2, 30)) except KeyboardInterrupt: break def start(self): """Start the Consumers. :return: """ if not self.connection: self.create_connection() while True: try: channel = self.connection.channel() channel.queue.declare('simple_queue') channel.basic.consume(self, 'simple_queue', no_ack=False) channel.start_consuming() if not channel.consumer_tags: channel.close() except amqpstorm.AMQPError as why: LOGGER.exception(why) self.create_connection() except KeyboardInterrupt: self.connection.close() break def __call__(self, message): print("Message:", message.body) message.ack()
def test_connection_close_old_ids_with_channel(self): max_channels = 1024 connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True) connection._channel0.max_allowed_channels = max_channels connection.set_state(connection.OPEN) for _ in compatibility.RANGE(max_channels): connection.channel(lazy=True) ids_to_close = [2, 8, 16, 32, 64, 128, 256, 512, 768, 1024] for _ in range(100): for index in ids_to_close: del connection._channels[index] self.assertEqual(len(connection._channels), max_channels - len(ids_to_close)) for _ in ids_to_close: self.assertIn( int(connection.channel(lazy=True)), ids_to_close ) self.assertEqual(len(connection._channels), max_channels)
def test_connection_maximum_channels_reached(self): connection = Connection('127.0.0.1', 'guest', 'guest', timeout=0.1, lazy=True) connection.set_state(connection.OPEN) for index in range(MAX_CHANNELS - 1): self.assertEqual(int(connection.channel(lazy=True)), index + 1) self.assertRaisesRegexp(AMQPConnectionError, 'reached the maximum number of channels %d' % MAX_CHANNELS, connection.channel, lazy=True)
class ExchangeCreateTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() def test_exchange_create(self): # Create the Exchange. self.channel.exchange.declare('test.exchange.create') # Confirm that the Exchange was declared. self.channel.exchange.declare('test.exchange.create', passive=True) def tearDown(self): self.channel.exchange.delete('test.exchange.create') self.channel.close() self.connection.close()
class ExchangeFunctionalTests(unittest.TestCase): def setUp(self): self.logging_handler = MockLoggingHandler() logging.root.addHandler(self.logging_handler) self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() def test_functional_exchange_declare(self): self.channel.exchange.declare('test_functional_exchange_declare', passive=False, durable=True, auto_delete=True) self.channel.exchange.declare('test_functional_exchange_declare', passive=True) def test_functional_exchange_delete(self): self.channel.exchange.declare('test_functional_exchange_delete') self.channel.exchange.delete('test_functional_exchange_delete', if_unused=True) self.assertRaises(amqpstorm.AMQPChannelError, self.channel.exchange.declare, 'test_functional_exchange_delete', passive=True) def test_functional_exchange_bind(self): self.channel.exchange.declare('exchange1') self.channel.exchange.declare('exchange2') self.assertEqual( self.channel.exchange.bind('exchange1', 'exchange2', 'routing_key'), {}) def test_functional_exchange_unbind(self): self.channel.exchange.declare('exchange1') self.channel.exchange.declare('exchange2') self.channel.exchange.bind('exchange1', 'exchange2', 'routing_key') self.assertEqual( self.channel.exchange.unbind('exchange1', 'exchange2', 'routing_key'), {}) def tearDown(self): self.channel.close() self.connection.close() self.assertFalse(self.logging_handler.messages['warning']) self.assertFalse(self.logging_handler.messages['error']) self.assertFalse(self.logging_handler.messages['critical'])
class PublisherConfirmFailsTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.confirm_deliveries() def test_publish_confirm_to_invalid_queue(self): self.assertRaises(AMQPMessageError, self.channel.basic.publish, body=str(uuid.uuid4()), exchange='amq.direct', mandatory=True, routing_key='test.basic.confirm.fails') def tearDown(self): self.channel.close() self.connection.close()
class ExchangeDeleteTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.exchange.declare('test.exchange.delete') def test_exchange_delete(self): # Delete the Exchange. self.channel.exchange.delete('test.exchange.delete') # Confirm that the Exchange was deleted. self.assertRaises(AMQPChannelError, self.channel.exchange.declare, 'test.exchange.delete', passive=True) def tearDown(self): self.channel.close() self.connection.close()
def publisher(): connection = Connection(HOST, USERNAME, PASSWORD) channel = connection.channel() channel.queue.declare('simple_queue') channel.confirm_deliveries() try: success = channel.basic.publish(body='Hello World!', routing_key='simple_queue', mandatory=True) # RabbitMQ could not publish the message. if not success: print('Unable to send message.') return # Internal error handling the message. except AMQPMessageError as why: print('Unable to send message: {0}'.format(why)) return print('Message successfully sent.')
class ConsumeAndRedeliverTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.consume.redeliver') self.channel.queue.purge('test.consume.redeliver') self.message = str(uuid.uuid4()) self.channel.confirm_deliveries() self.channel.basic.publish(body=self.message, routing_key='test.consume.redeliver') def on_message(message): message.reject() self.channel.basic.consume(callback=on_message, queue='test.consume.redeliver', no_ack=False) self.channel.process_data_events(to_tuple=False) # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) def test_consume_and_redeliver(self): # Store and inbound messages. inbound_messages = [] def on_message(message): inbound_messages.append(message) self.assertEqual(message.body, self.message) message.ack() self.channel.basic.consume(callback=on_message, queue='test.consume.redeliver', no_ack=False) self.channel.process_data_events(to_tuple=False) self.assertEqual(len(inbound_messages), 1) def tearDown(self): self.channel.queue.delete('test.consume.redeliver') self.channel.close() self.connection.close()
class Publisher(object): def __init__(self, host, username, password): self.channel = None self.connection = None self.host = host self.username = username self.password = password self.connect() def connect(self): self.connection = Connection(self.host, self.username, self.password) self.channel = self.connection.channel() def close_connection(self): self.channel.close() self.connection.close() def send_message(self, queue, message): if self.connection.is_closed: self.reconnect() try: self.channel.basic.publish(body=message, routing_key=queue) except AMQPError as why: # When handling AMQPError's here, be careful as you may # need to re-send the payload. print(why) self.reconnect() def reconnect(self): """ Re-connect. :return: """ try: if self.connection.is_closed: self.connection.open() if self.channel.is_closed: self.channel.open() except AMQPError: raise
class PublishAndConsumeMessagesTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.consume') self.channel.queue.purge('test.basic.consume') self.channel.confirm_deliveries() def test_publish_and_consume_five_messages(self): for _ in range(5): self.channel.basic.publish(body=str(uuid.uuid4()), routing_key='test.basic.consume') # Store and inbound messages. inbound_messages = [] def on_message(message): self.assertIsInstance(message.body, (bytes, str)) self.assertIsInstance(message.channel, Channel) self.assertIsInstance(message.properties, dict) self.assertIsInstance(message.method, dict) inbound_messages.append(message) self.channel.basic.consume(callback=on_message, queue='test.basic.consume', no_ack=True) # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) self.channel.process_data_events(to_tuple=False) # Make sure all five messages were downloaded. self.assertEqual(len(inbound_messages), 5) def tearDown(self): self.channel.queue.delete('test.basic.consume') self.channel.close() self.connection.close()
class PublishWithPropertiesAndGetTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.properties') self.channel.queue.purge('test.basic.properties') self.channel.confirm_deliveries() def test_publish_with_properties_and_get(self): message = str(uuid.uuid4()) properties = { 'headers': { 'key': 1234567890, 'alpha': 'omega' } } self.channel.basic.publish(body=message, routing_key='test.basic.properties', properties=properties) # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) # New way payload = self.channel.basic.get('test.basic.properties', to_dict=False) self.assertEqual(payload.properties['headers']['key'], 1234567890) self.assertEqual(payload.properties['headers']['alpha'], 'omega') # Old way result = payload.to_dict() self.assertEqual(result['properties']['headers'][b'key'], 1234567890) self.assertEqual(result['properties']['headers'][b'alpha'], b'omega') def tearDown(self): self.channel.queue.delete('test.basic.properties') self.channel.close() self.connection.close()
class PublisherConfirmsTest(unittest.TestCase): def setUp(self): self.connection = Connection(HOST, USERNAME, PASSWORD) self.channel = self.connection.channel() self.channel.queue.declare('test.basic.confirm') self.channel.queue.purge('test.basic.confirm') self.channel.confirm_deliveries() def test_publish_and_confirm(self): self.channel.basic.publish(body=str(uuid.uuid4()), routing_key='test.basic.confirm') # Sleep for 0.5s to make sure RabbitMQ has time to catch up. time.sleep(0.5) payload = self.channel.queue.declare('test.basic.confirm', passive=True) self.assertEqual(payload['message_count'], 1) def tearDown(self): self.channel.queue.delete('test.basic.confirm') self.channel.close() self.connection.close()
def test_connection_open_many_channels(self): connection = Connection('127.0.0.1', 'guest', 'guest', lazy=True) connection.set_state(connection.OPEN) for index in compatibility.RANGE(MAX_CHANNELS - 1): self.assertEqual(int(connection.channel(lazy=True)), index + 1)