Python Exchange.bind方法代码示例

# 需要导入模块: from kombu import Exchange [as 别名]
# 或者: from kombu.Exchange import bind [as 别名]
    def test_assert_is_bound(self):
        exchange = Exchange('foo', 'direct')
        with self.assertRaises(NotBoundError):
            exchange.declare()
        conn = get_conn()

        chan = conn.channel()
        exchange.bind(chan).declare()
        self.assertIn('exchange_declare', chan)

# 需要导入模块: from kombu import Exchange [as 别名]
# 或者: from kombu.Exchange import bind [as 别名]
    def test_assert_is_bound(self):
        exchange = Exchange('foo', 'direct')
        with pytest.raises(NotBoundError):
            exchange.declare()
        conn = get_conn()

        chan = conn.channel()
        exchange.bind(chan).declare()
        assert 'exchange_declare' in chan

# 需要导入模块: from kombu import Exchange [as 别名]
# 或者: from kombu.Exchange import bind [as 别名]
    def test_bound(self):
        exchange = Exchange('foo', 'direct')
        assert not exchange.is_bound
        assert '<unbound' in repr(exchange)

        chan = get_conn().channel()
        bound = exchange.bind(chan)
        assert bound.is_bound
        assert bound.channel is chan
        assert 'bound to chan:%r' % (chan.channel_id,) in repr(bound)

# 需要导入模块: from kombu import Exchange [as 别名]
# 或者: from kombu.Exchange import bind [as 别名]
    def test_bound(self):
        exchange = Exchange('foo', 'direct')
        self.assertFalse(exchange.is_bound)
        self.assertIn('<unbound', repr(exchange))

        chan = get_conn().channel()
        bound = exchange.bind(chan)
        self.assertTrue(bound.is_bound)
        self.assertIs(bound.channel, chan)
        self.assertIn('bound to chan:%r' % (chan.channel_id, ),
                      repr(bound))

# 需要导入模块: from kombu import Exchange [as 别名]
# 或者: from kombu.Exchange import bind [as 别名]
    def test_revive(self):
        exchange = Exchange('foo', 'direct')
        conn = get_conn()
        chan = conn.channel()

        # reviving unbound channel is a noop.
        exchange.revive(chan)
        self.assertFalse(exchange.is_bound)
        self.assertIsNone(exchange._channel)

        bound = exchange.bind(chan)
        self.assertTrue(bound.is_bound)
        self.assertIs(bound.channel, chan)

        chan2 = conn.channel()
        bound.revive(chan2)
        self.assertTrue(bound.is_bound)
        self.assertIs(bound._channel, chan2)

# 需要导入模块: from kombu import Exchange [as 别名]
# 或者: from kombu.Exchange import bind [as 别名]
    def test_revive(self):
        exchange = Exchange('foo', 'direct')
        conn = get_conn()
        chan = conn.channel()

        # reviving unbound channel is a noop.
        exchange.revive(chan)
        assert not exchange.is_bound
        assert exchange._channel is None

        bound = exchange.bind(chan)
        assert bound.is_bound
        assert bound.channel is chan

        chan2 = conn.channel()
        bound.revive(chan2)
        assert bound.is_bound
        assert bound._channel is chan2

# 需要导入模块: from kombu import Exchange [as 别名]
# 或者: from kombu.Exchange import bind [as 别名]
    print('  properties:\n%s' % (pretty(message.properties), ))
    print('  delivery_info:\n%s' % (pretty(message.delivery_info), ))
    message.ack()

#: Create a connection and a channel.
#: If hostname, userid, password and virtual_host is not specified
#: the values below are the default, but listed here so it can
#: be easily changed.
with Connection('pyamqp://guest:[email protected]:5672//') as connection:
    
    """The configuration of the message flow is as follows:
    gateway_kombu_exchange -> internal_kombu_exchange -> kombu_demo queue 
    """
    gateway_exchange = Exchange('gateway_kombu_demo', type='direct')
    exchange = Exchange('internal_kombu_demo', type='direct')
    binded = exchange.bind(connection.channel())
    binded.exchange_bind(gateway_exchange, routing_key = 'kombu_demo')
    
    queue = Queue('kombu_demo', exchange, routing_key='kombu_demo')
    
    #: Create consumer using our callback and queue.
    #: Second argument can also be a list to consume from
    #: any number of queues.
    with Consumer(connection, queue, callbacks=[handle_message]):

        #: This waits for a single event.  Note that this event may not
        #: be a message, or a message that is to be delivered to the consumers
        #: channel, but any event received on the connection.        
        recv = eventloop(connection)
        while True:
            recv.next()