def test_queue_delete(self):
"""
Test that messages in a queue being deleted are delivered to the alternate-exchange if specified
"""
session = self.session
#set up a 'dead letter queue':
dlq = self.setup_dlq()
#create a queue using the dlq as its alternate exchange:
session.queue_declare(queue="delete-me", alternate_exchange="dlq")
#send it some messages:
dp = self.session.delivery_properties(routing_key="delete-me")
session.message_transfer(message=Message(dp, "One"))
session.message_transfer(message=Message(dp, "Two"))
session.message_transfer(message=Message(dp, "Three"))
#delete it:
session.queue_delete(queue="delete-me")
#delete the dlq exchange:
session.exchange_delete(exchange="dlq")
#check the messages were delivered to the dlq:
self.assertEqual("One", dlq.get(timeout=1).body)
self.assertEqual("Two", dlq.get(timeout=1).body)
self.assertEqual("Three", dlq.get(timeout=1).body)
self.assertEmpty(dlq)
def test_ack_and_no_ack(self):
"""
First, this test tries to receive a message with a no-ack
consumer. Second, this test tries to explicitly receive and
acknowledge a message with an acknowledging consumer.
"""
session = self.session
session.queue_declare(queue = "myqueue", exclusive=True, auto_delete=True)
# No ack consumer
ctag = "tag1"
session.message_subscribe(queue = "myqueue", destination = ctag)
session.message_flow(destination=ctag, unit=session.credit_unit.message, value=0xFFFFFFFFL)
session.message_flow(destination=ctag, unit=session.credit_unit.byte, value=0xFFFFFFFFL)
body = "test no-ack"
session.message_transfer(message=Message(session.delivery_properties(routing_key="myqueue"), body))
msg = session.incoming(ctag).get(timeout = 5)
self.assert_(msg.body == body)
# Acknowledging consumer
session.queue_declare(queue = "otherqueue", exclusive=True, auto_delete=True)
ctag = "tag2"
session.message_subscribe(queue = "otherqueue", destination = ctag, accept_mode = 1)
session.message_flow(destination=ctag, unit=session.credit_unit.message, value=0xFFFFFFFFL)
session.message_flow(destination=ctag, unit=session.credit_unit.byte, value=0xFFFFFFFFL)
body = "test ack"
session.message_transfer(message=Message(session.delivery_properties(routing_key="otherqueue"), body))
msg = session.incoming(ctag).get(timeout = 5)
session.message_accept(RangedSet(msg.id))
self.assert_(msg.body == body)
def test_unroutable(self):
"""
Test that unroutable messages are delivered to the alternate-exchange if specified
"""
session = self.session
#create an exchange with an alternate defined
session.exchange_declare(exchange="secondary", type="fanout")
session.exchange_declare(exchange="primary",
type="direct",
alternate_exchange="secondary")
#declare, bind (to the alternate exchange) and consume from a queue for 'returned' messages
session.queue_declare(queue="returns",
exclusive=True,
auto_delete=True)
session.exchange_bind(queue="returns", exchange="secondary")
session.message_subscribe(destination="a", queue="returns")
session.message_flow(destination="a",
unit=session.credit_unit.message,
value=0xFFFFFFFFL)
session.message_flow(destination="a",
unit=session.credit_unit.byte,
value=0xFFFFFFFFL)
returned = session.incoming("a")
#declare, bind (to the primary exchange) and consume from a queue for 'processed' messages
session.queue_declare(queue="processed",
exclusive=True,
auto_delete=True)
session.exchange_bind(queue="processed",
exchange="primary",
binding_key="my-key")
session.message_subscribe(destination="b", queue="processed")
session.message_flow(destination="b",
unit=session.credit_unit.message,
value=0xFFFFFFFFL)
session.message_flow(destination="b",
unit=session.credit_unit.byte,
value=0xFFFFFFFFL)
processed = session.incoming("b")
#publish to the primary exchange
#...one message that makes it to the 'processed' queue:
dp = self.session.delivery_properties(routing_key="my-key")
session.message_transfer(destination="primary",
message=Message(dp, "Good"))
#...and one that does not:
dp = self.session.delivery_properties(routing_key="unused-key")
session.message_transfer(destination="primary",
message=Message(dp, "Bad"))
#delete the exchanges
session.exchange_delete(exchange="primary")
session.exchange_delete(exchange="secondary")
#verify behaviour
self.assertEqual("Good", processed.get(timeout=1).body)
self.assertEqual("Bad", returned.get(timeout=1).body)
self.assertEmpty(processed)
self.assertEmpty(returned)
def test_purge(self):
"""
Test that the purge method removes messages from the queue
"""
session = self.session
#setup, declare a queue and add some messages to it:
session.queue_declare(queue="test-queue", exclusive=True, auto_delete=True)
session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "one"))
session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "two"))
session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "three"))
#check that the queue now reports 3 messages:
session.queue_declare(queue="test-queue")
reply = session.queue_query(queue="test-queue")
self.assertEqual(3, reply.message_count)
#now do the purge, then test that three messages are purged and the count drops to 0
session.queue_purge(queue="test-queue");
reply = session.queue_query(queue="test-queue")
self.assertEqual(0, reply.message_count)
#send a further message and consume it, ensuring that the other messages are really gone
session.message_transfer(message=Message(session.delivery_properties(routing_key="test-queue"), "four"))
session.message_subscribe(queue="test-queue", destination="tag")
session.message_flow(destination="tag", unit=session.credit_unit.message, value=0xFFFFFFFFL)
session.message_flow(destination="tag", unit=session.credit_unit.byte, value=0xFFFFFFFFL)
queue = session.incoming("tag")
msg = queue.get(timeout=1)
self.assertEqual("four", msg.body)
def testDurableBindings(self):
try:
self.ssn.exchange_unbind(queue="DB_Q1",
exchange="DB_E1",
binding_key="K1")
except:
self.start_session()
try:
self.ssn.exchange_delete(exchange="DB_E1")
except:
self.start_session()
try:
self.ssn.queue_delete(queue="DB_Q1")
except:
self.start_session()
self.ssn.queue_declare(queue="DB_Q1", durable=True)
self.ssn.exchange_declare(exchange="DB_E1",
type="direct",
durable=True)
self.ssn.exchange_bind(exchange="DB_E1",
queue="DB_Q1",
binding_key="K1")
# Queue up 2 messages, one with non-zero body, one with zero-length.
# 2 = delivery_mode.persistent
dp = self.ssn.delivery_properties(routing_key="DB_Q1", delivery_mode=2)
self.ssn.message_transfer(message=Message(dp, "normal message"))
self.ssn.message_transfer(message=Message(dp, ""))
# Cycle the broker and make sure the binding recovers
self.cycle_broker()
response = self.ssn.exchange_bound(exchange="DB_E1",
queue="DB_Q1",
binding_key="K1")
self.assert_(not response.exchange_not_found)
self.assert_(not response.queue_not_found)
self.assert_(not response.queue_not_matched)
self.assert_(not response.key_not_matched)
# Are the messages still there?
self.ssn.message_subscribe(destination="msgs",
queue="DB_Q1",
accept_mode=1,
acquire_mode=0)
self.ssn.message_flow(unit=1, value=0xFFFFFFFFL, destination="msgs")
self.ssn.message_flow(unit=0, value=10, destination="msgs")
message_arrivals = self.ssn.incoming("msgs")
try:
message_arrivals.get(timeout=1)
message_arrivals.get(timeout=1)
except Empty:
assert False, 'Durable message(s) not recovered'
self.ssn.exchange_unbind(queue="DB_Q1",
exchange="DB_E1",
binding_key="K1")
self.ssn.exchange_delete(exchange="DB_E1")
self.ssn.queue_delete(queue="DB_Q1")
def test_queue_autodelete(self):
"""
Test that messages in a queue being auto-deleted are delivered
to the alternate-exchange if specified, including messages
that are acquired but not accepted
"""
session = self.session
#set up a 'dead letter queue':
session.exchange_declare(exchange="dlq", type="fanout")
session.queue_declare(queue="deleted",
exclusive=True,
auto_delete=True)
session.exchange_bind(exchange="dlq", queue="deleted")
session.message_subscribe(destination="dlq", queue="deleted")
session.message_flow(destination="dlq",
unit=session.credit_unit.message,
value=0xFFFFFFFFL)
session.message_flow(destination="dlq",
unit=session.credit_unit.byte,
value=0xFFFFFFFFL)
dlq = session.incoming("dlq")
#on a separate session, create an auto-deleted queue using the
#dlq as its alternate exchange (handling of auto-delete is
#different for exclusive and non-exclusive queues, so test
#both modes):
for mode in [True, False]:
session2 = self.conn.session("another-session")
session2.queue_declare(queue="my-queue",
alternate_exchange="dlq",
exclusive=mode,
auto_delete=True)
#send it some messages:
dp = session2.delivery_properties(routing_key="my-queue")
session2.message_transfer(message=Message(dp, "One"))
session2.message_transfer(message=Message(dp, "Two"))
session2.message_transfer(message=Message(dp, "Three"))
session2.message_subscribe(destination="incoming",
queue="my-queue")
session2.message_flow(destination="incoming",
unit=session.credit_unit.message,
value=1)
session2.message_flow(destination="incoming",
unit=session.credit_unit.byte,
value=0xFFFFFFFFL)
self.assertEqual("One",
session2.incoming("incoming").get(timeout=1).body)
session2.close()
#check the messages were delivered to the dlq:
self.assertEqual("One", dlq.get(timeout=1).body)
self.assertEqual("Two", dlq.get(timeout=1).body)
self.assertEqual("Three", dlq.get(timeout=1).body)
self.assertEmpty(dlq)
def message_transfer(self, cmd):
if cmd.destination == "echo":
m = Message(cmd.payload)
m.headers = cmd.headers
self.session.message_transfer(cmd.destination, cmd.accept_mode,
cmd.acquire_mode, m)
elif cmd.destination == "abort":
self.session.channel.connection.sock.close()
elif cmd.destination == "heartbeat":
self.session.channel.connection_heartbeat()
else:
self.queue.put(cmd)
def message_transfer(self, cmd):
if cmd.destination == "echo":
m = Message(cmd.payload)
m.headers = cmd.headers
self.session.message_transfer(cmd.destination, cmd.accept_mode,
cmd.acquire_mode, m)
elif cmd.destination == "abort":
self.session.channel.connection.sock.close()
elif cmd.destination == "heartbeat":
self.session.channel.connection_heartbeat()
else:
self.queue.put(cmd)
def unbind_test(self, exchange, routing_key="", args=None, headers=None):
#bind two queues and consume from them
session = self.session
session.queue_declare(queue="queue-1", exclusive=True, auto_delete=True)
session.queue_declare(queue="queue-2", exclusive=True, auto_delete=True)
session.message_subscribe(queue="queue-1", destination="queue-1")
session.message_flow(destination="queue-1", unit=session.credit_unit.message, value=0xFFFFFFFFL)
session.message_flow(destination="queue-1", unit=session.credit_unit.byte, value=0xFFFFFFFFL)
session.message_subscribe(queue="queue-2", destination="queue-2")
session.message_flow(destination="queue-2", unit=session.credit_unit.message, value=0xFFFFFFFFL)
session.message_flow(destination="queue-2", unit=session.credit_unit.byte, value=0xFFFFFFFFL)
queue1 = session.incoming("queue-1")
queue2 = session.incoming("queue-2")
session.exchange_bind(exchange=exchange, queue="queue-1", binding_key=routing_key, arguments=args)
session.exchange_bind(exchange=exchange, queue="queue-2", binding_key=routing_key, arguments=args)
dp = session.delivery_properties(routing_key=routing_key)
if (headers):
mp = session.message_properties(application_headers=headers)
msg1 = Message(dp, mp, "one")
msg2 = Message(dp, mp, "two")
else:
msg1 = Message(dp, "one")
msg2 = Message(dp, "two")
#send a message that will match both bindings
session.message_transfer(destination=exchange, message=msg1)
#unbind first queue
session.exchange_unbind(exchange=exchange, queue="queue-1", binding_key=routing_key)
#send another message
session.message_transfer(destination=exchange, message=msg2)
#check one queue has both messages and the other has only one
self.assertEquals("one", queue1.get(timeout=1).body)
try:
msg = queue1.get(timeout=1)
self.fail("Got extra message: %s" % msg.body)
except Empty: pass
self.assertEquals("one", queue2.get(timeout=1).body)
self.assertEquals("two", queue2.get(timeout=1).body)
try:
msg = queue2.get(timeout=1)
self.fail("Got extra message: " + msg)
except Empty: pass
def test_reroute_priority_queue(self):
self.startQmf()
session = self.session
#setup test queue supporting multiple priority levels
session.queue_declare(queue="test-queue", exclusive=True, auto_delete=True, arguments={'x-qpid-priorities':10})
#send some messages of varying priority to that queue:
for i in range(0, 5):
deliveryProps = session.delivery_properties(routing_key="test-queue", priority=i+5)
session.message_transfer(message=Message(deliveryProps, "Message %d" % (i+1)))
#declare and bind a queue to amq.fanout through which rerouted
#messages can be verified:
session.queue_declare(queue="rerouted", exclusive=True, auto_delete=True, arguments={'x-qpid-priorities':10})
session.exchange_bind(queue="rerouted", exchange="amq.fanout")
#reroute messages from test queue to amq.fanout (and hence to
#rerouted queue):
pq = self.qmf.getObjects(_class="queue", name="test-queue")[0]
result = pq.reroute(0, False, "amq.fanout", {})
self.assertEqual(result.status, 0)
#verify messages are all rerouted:
self.subscribe(destination="incoming", queue="rerouted")
incoming = session.incoming("incoming")
for i in range(0, 5):
msg = incoming.get(timeout=1)
self.assertEqual("Message %d" % (5-i), msg.body)
def test_reroute_alternate_exchange(self):
"""
Test that when rerouting, the alternate-exchange is considered if relevant
"""
self.startQmf()
session = self.session
# 1. Create 2 exchanges A and B (fanout) where B is the
# alternate exchange for A
session.exchange_declare(exchange="B", type="fanout")
session.exchange_declare(exchange="A", type="fanout", alternate_exchange="B")
# 2. Bind queue X to B
session.queue_declare(queue="X", exclusive=True, auto_delete=True)
session.exchange_bind(queue="X", exchange="B")
# 3. Send 1 message to queue Y
session.queue_declare(queue="Y", exclusive=True, auto_delete=True)
props = session.delivery_properties(routing_key="Y")
session.message_transfer(message=Message(props, "reroute me!"))
# 4. Call reroute on queue Y and specify that messages should
# be sent to exchange A
y = self.qmf.getObjects(_class="queue", name="Y")[0]
result = y.reroute(1, False, "A", {})
self.assertEqual(result.status, 0)
# 5. verify that the message is rerouted through B (as A has
# no matching bindings) to X
self.subscribe(destination="x", queue="X")
self.assertEqual("reroute me!", session.incoming("x").get(timeout=1).body)
# Cleanup
for e in ["A", "B"]: session.exchange_delete(exchange=e)
def test_queue_deletion(self):
session = self.session
session.queue_declare(queue = "durable-subscriber-queue", exclusive=True, durable=True)
session.exchange_bind(exchange="amq.topic", queue="durable-subscriber-queue", binding_key="xyz")
dp = session.delivery_properties(routing_key="xyz", delivery_mode=2)
session.message_transfer(destination="amq.topic", message=Message(dp, "my-message"))
session.queue_delete(queue = "durable-subscriber-queue")
def test_connection_stats(self):
"""
Test message in/out stats for connection
"""
agent = self.setup_access()
conn = self.connect()
session = conn.session("stats-session")
#using qmf find named session and the corresponding connection:
conn_qmf = None
sessions = agent.getAllSessions()
for s in sessions:
if s.name == "stats-session":
conn_qmf = agent.getConnection(s.connectionRef)
assert(conn_qmf)
#send a message to a queue
session.queue_declare(queue="stats-q", exclusive=True, auto_delete=True)
session.message_transfer(message=Message(session.delivery_properties(routing_key="stats-q"), "abc"))
#check the 'msgs sent from' stat for this connection
conn_qmf.update()
self.assertEqual(conn_qmf.msgsFromClient, 1)
#receive message from queue
session.message_subscribe(destination="d", queue="stats-q")
incoming = session.incoming("d")
incoming.start()
self.assertEqual("abc", incoming.get(timeout=1).body)
#check the 'msgs sent to' stat for this connection
conn_qmf.update()
self.assertEqual(conn_qmf.msgsToClient, 1)
def test_queue_delete_loop(self):
"""
Test that if a queue is bound to its own alternate exchange,
then on deletion there is no infinite looping
"""
session = self.session
dlq = self.setup_dlq()
#create a queue using the dlq as its alternate exchange:
session.queue_declare(queue="delete-me", alternate_exchange="dlq")
#bind that queue to the dlq as well:
session.exchange_bind(exchange="dlq", queue="delete-me")
#send it some messages:
dp = self.session.delivery_properties(routing_key="delete-me")
for m in ["One", "Two", "Three"]:
session.message_transfer(message=Message(dp, m))
#delete it:
session.queue_delete(queue="delete-me")
#cleanup:
session.exchange_delete(exchange="dlq")
#check the messages were delivered to the dlq:
for m in ["One", "Two", "Three"]:
self.assertEqual(m, dlq.get(timeout=1).body)
self.assertEmpty(dlq)
def testSync(self):
c = self.connect()
c.start(10)
s = c.session("test")
s.auto_sync = False
s.message_transfer("echo", message=Message("test"))
s.sync(10)
def test_delete_simple(self):
"""
Test core queue deletion behaviour
"""
session = self.session
#straight-forward case:
session.queue_declare(queue="delete-me")
session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me"), "a"))
session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me"), "b"))
session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me"), "c"))
session.queue_delete(queue="delete-me")
#check that it has gone by declaring passively
try:
session.queue_declare(queue="delete-me", passive=True)
self.fail("Queue has not been deleted")
except SessionException, e:
self.assertEquals(404, e.args[0].error_code)
def send_message(self, topic, message, **headers):
headers['routing_key'] = headers.get('routing_key', topic)
props = self.session.delivery_properties(**headers)
msg = Message(props, message)
self.session.message_transfer(destination=headers.get(
'exchange', 'amq.topic'),
message=msg)
super(QpidAMQPHubExtension, self).send_message(topic, message,
**headers)
def send(self, routing_key, msg_text):
propDelivery = self.__session.delivery_properties(
routing_key = routing_key.__str__(),
exchange = self.__exchange )
contentType = 'application/x-protobuf'
propMessage = self.__session.message_properties(
content_type = contentType)
self.__session.message_transfer(destination = self.__exchange,
message = Message(propDelivery, propMessage, msg_text))
def sendmessage(self, filepath, header):
'''
This function sends a message to the external.dropbox queue providing the path
to the file to be ingested and a header to determine the plugin to be used to
decode the file.
@param filepath: string full path to file to be ingested
@param header: string header used to determine plugin decoder to use
'''
props = self.session.delivery_properties(routing_key='external.dropbox')
head = self.session.message_properties(application_headers={'header':header},
user_id=QPID_USERNAME) # For issue QPID-5569. Fixed in Qpid 0.27
self.session.message_transfer(destination='amq.direct', message=Message(props, head, filepath))
def assertPublishGet(self, queue, exchange="", routing_key="", properties=None):
"""
Publish to exchange and assert queue.get() returns the same message.
"""
body = self.uniqueString()
dp=self.session.delivery_properties(routing_key=routing_key)
mp=self.session.message_properties(application_headers=properties)
self.session.message_transfer(destination=exchange, message=Message(dp, mp, body))
msg = queue.get(timeout=1)
self.assertEqual(body, msg.body)
if (properties):
self.assertEqual(properties, self.getApplicationHeaders(msg))
def test(self):
c = self.connect()
c.start(10)
ssn1 = c.session("test1", timeout=10)
ssn2 = c.session("test2", timeout=10)
assert ssn1 == c.sessions["test1"]
assert ssn2 == c.sessions["test2"]
assert ssn1.channel != None
assert ssn2.channel != None
assert ssn1 in c.attached.values()
assert ssn2 in c.attached.values()
ssn1.close(5)
assert ssn1.channel == None
assert ssn1 not in c.attached.values()
assert ssn2 in c.sessions.values()
ssn2.close(5)
assert ssn2.channel == None
assert ssn2 not in c.attached.values()
assert ssn2 not in c.sessions.values()
ssn = c.session("session", timeout=10)
assert ssn.channel != None
assert ssn in c.sessions.values()
destinations = ("one", "two", "three")
for d in destinations:
ssn.message_transfer(d)
for d in destinations:
cmd = self.queue.get(10)
assert cmd.destination == d
assert cmd.headers == None
assert cmd.payload == None
msg = Message("this is a test")
ssn.message_transfer("four", message=msg)
cmd = self.queue.get(10)
assert cmd.destination == "four"
assert cmd.headers == None
assert cmd.payload == msg.body
qq = ssn.queue_query("asdf")
assert qq.queue == "asdf"
c.close(5)
def send_message(connection, notif):
session = connection.session(str(uuid4()))
props = session.delivery_properties(routing_key=TOPIC_NAME)
head = session.message_properties(
application_headers={
'sender': notif.sender,
'response': notif.response
},
user_id=QPID_USERNAME) # For issue QPID-5569. Fixed in Qpid 0.27
session.message_transfer(destination=DESTINATION,
message=Message(props, head, notif.messageId))
session.close(timeout=10)
connection.close()
def test_delete_queue_after_publish(self):
session = self.session
session.auto_sync = False
#create queue
session.queue_declare(queue = "q", auto_delete=True, durable=True)
#send message
for i in range(1, 10):
dp = session.delivery_properties(routing_key="q", delivery_mode=2)
session.message_transfer(message=Message(dp, "my-message"))
session.auto_sync = True
#explicitly delete queue
session.queue_delete(queue = "q")
def test_reject_no_match(self):
"""
Test that on rejecting a message, if the queues own alternate
exchange cannot find a match for the message, the
alternate-exchange of that exchange will be tried. Note:
though the spec rules out going to the alternate-exchanges
alternate exchange when sending to an exchange, it does not
cover this case.
"""
session = self.session
dlq = self.setup_dlq()
#setu up an 'intermediary' exchange
session.exchange_declare(exchange="my-exchange",
type="direct",
alternate_exchange="dlq")
#create a queue using the intermediary as its alternate exchange:
session.queue_declare(queue="delivery-queue",
alternate_exchange="my-exchange",
auto_delete=True)
#send it some messages:
dp = self.session.delivery_properties(routing_key="delivery-queue")
for m in ["One", "Two", "Three"]:
session.message_transfer(message=Message(dp, m))
#get and reject those messages:
session.message_subscribe(destination="a", queue="delivery-queue")
session.message_flow(destination="a",
unit=session.credit_unit.message,
value=0xFFFFFFFFL)
session.message_flow(destination="a",
unit=session.credit_unit.byte,
value=0xFFFFFFFFL)
incoming = session.incoming("a")
for m in ["One", "Two", "Three"]:
msg = incoming.get(timeout=1)
self.assertEqual(m, msg.body)
session.message_reject(RangedSet(msg.id))
session.message_cancel(destination="a")
#check the messages were delivered to the dlq:
for m in ["One", "Two", "Three"]:
self.assertEqual(m, dlq.get(timeout=1).body)
self.assertEmpty(dlq)
#cleanup:
session.exchange_delete(exchange="my-exchange")
session.exchange_delete(exchange="dlq")
def test_delete_ifempty(self):
"""
Test that if_empty field of queue_delete is honoured
"""
session = self.session
#create a queue and add a message to it (use default binding):
session.queue_declare(queue="delete-me-2")
session.queue_declare(queue="delete-me-2", passive=True)
session.message_transfer(message=Message(session.delivery_properties(routing_key="delete-me-2"), "message"))
#try to delete, but only if empty:
try:
session.queue_delete(queue="delete-me-2", if_empty=True)
self.fail("Expected delete if_empty to fail for non-empty queue")
except SessionException, e:
self.assertEquals(406, e.args[0].error_code)
def test_simple_delivery_immediate(self):
"""
Test simple message delivery where consume is issued before publish
"""
session = self.session
session.queue_declare(queue="test-queue", exclusive=True, auto_delete=True)
session.exchange_bind(queue="test-queue", exchange="amq.fanout")
consumer_tag = "tag1"
session.message_subscribe(queue="test-queue", destination=consumer_tag)
session.message_flow(unit = session.credit_unit.message, value = 0xFFFFFFFFL, destination = consumer_tag)
session.message_flow(unit = session.credit_unit.byte, value = 0xFFFFFFFFL, destination = consumer_tag)
queue = session.incoming(consumer_tag)
body = "Immediate Delivery"
session.message_transfer("amq.fanout", None, None, Message(body))
msg = queue.get(timeout=5)
self.assert_(msg.body == body)
def swap(self, session, src, dest):
#consume from src:
session.message_subscribe(destination="temp-swap", queue=src)
session.message_flow(destination="temp-swap",
unit=session.credit_unit.message,
value=1)
session.message_flow(destination="temp-swap",
unit=session.credit_unit.byte,
value=0xFFFFFFFFL)
msg = session.incoming("temp-swap").get(timeout=1)
session.message_cancel(destination="temp-swap")
session.message_accept(RangedSet(msg.id))
#todo: also complete at this point?
#re-publish to dest:
dp = session.delivery_properties(routing_key=dest)
mp = session.message_properties(
correlation_id=self.getMessageProperty(msg, 'correlation_id'))
session.message_transfer(message=Message(dp, mp, msg.body))
def txswap(self, tx, id):
session = self.session
#declare two queues:
session.queue_declare(queue="queue-a", auto_delete=True)
session.queue_declare(queue="queue-b", auto_delete=True)
#put message with specified id on one queue:
dp = session.delivery_properties(routing_key="queue-a")
mp = session.message_properties(correlation_id=id)
session.message_transfer(message=Message(dp, mp, "DtxMessage"))
#start the transaction:
session.dtx_select()
self.assertEqual(self.XA_OK, self.session.dtx_start(xid=tx).status)
#'swap' the message from one queue to the other, under that transaction:
self.swap(self.session, "queue-a", "queue-b")
#mark the end of the transactional work:
self.assertEqual(self.XA_OK, self.session.dtx_end(xid=tx).status)
def test_purge_queue(self):
"""
Test ability to purge messages from the head of a queue.
Need to test moveing all, 1 (top message) and N messages.
"""
self.startQmf()
session = self.session
"Set up purge queue"
session.queue_declare(queue="purge-queue",
exclusive=True,
auto_delete=True)
session.exchange_bind(queue="purge-queue",
exchange="amq.direct",
binding_key="routing_key")
twenty = range(1, 21)
props = session.delivery_properties(routing_key="routing_key")
for count in twenty:
body = "Purge Message %d" % count
msg = Message(props, body)
session.message_transfer(destination="amq.direct", message=msg)
pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0]
"Purge top message from purge-queue"
result = pq.purge(1, {})
self.assertEqual(result.status, 0)
pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0]
self.assertEqual(pq.msgDepth, 19)
"Purge top 9 messages from purge-queue"
result = pq.purge(9, {})
self.assertEqual(result.status, 0)
pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0]
self.assertEqual(pq.msgDepth, 10)
"Purge all messages from purge-queue"
result = pq.purge(0, {})
self.assertEqual(result.status, 0)
pq = self.qmf.getObjects(_class="queue", name="purge-queue")[0]
self.assertEqual(pq.msgDepth, 0)
def testCloseGet(self):
c = self.connect()
c.start(10)
ssn = c.session("test", timeout=10)
echos = ssn.incoming("echo")
for i in range(10):
ssn.message_transfer("echo", message=Message("test%d" % i))
ssn.auto_sync = False
ssn.message_transfer("abort")
for i in range(10):
m = echos.get(timeout=10)
assert m.body == "test%d" % i
try:
m = echos.get(timeout=10)
assert False
except Closed, e:
pass
def test_ack_message_from_deleted_queue(self):
session = self.session
session.auto_sync = False
#create queue
session.queue_declare(queue = "q", auto_delete=True, durable=True)
#send message
dp = session.delivery_properties(routing_key="q", delivery_mode=2)
session.message_transfer(message=Message(dp, "my-message"))
#create consumer
session.message_subscribe(queue = "q", destination = "a", accept_mode = 1, acquire_mode=0)
session.message_flow(unit = session.credit_unit.byte, value = 0xFFFFFFFFL, destination = "a")
session.message_flow(unit = session.credit_unit.message, value = 10, destination = "a")
queue = session.incoming("a")
#consume the message, cancel subscription (triggering auto-delete), then ack it
msg = queue.get(timeout = 5)
session.message_cancel(destination = "a")
session.message_accept(RangedSet(msg.id))
