Python Connection.channel方法代码示例

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
    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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
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()

# 需要导入模块: from amqpstorm import Connection [as 别名]
# 或者: from amqpstorm.Connection import channel [as 别名]
    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)