def on_sendable(self, event):
if event.sender == self.sender:
while self.sender.credit > 0 and self.n_tx < self.count:
self.sender.send(Message("Message %d" % self.n_tx))
self.n_tx += 1
def on_sendable(self, event):
msg = Message(body="Hello World")
event.sender.send(msg)
def query_addresses(self):
ap = {'operation': 'QUERY', 'type': 'org.apache.qpid.dispatch.router.address'}
return Message(properties=ap, reply_to=self.reply_addr)
def send(self, response, reply_to):
msg = Message(body=response)
if self.sender:
msg.address = reply_to
self.sender.send(msg)
def recv_msg(delivery):
msg = Message()
msg.decode(delivery.link.recv(delivery.pending))
delivery.link.advance()
return msg
def on_sendable(self, event):
self._sender.send(Message(body="message %d" % self.sent))
self.sent += 1
def test_multiple_log_file(self):
blocking_connection = BlockingConnection(self.address)
TEST_ADDRESS = "test_multiple_log_file"
blocking_receiver = blocking_connection.create_receiver(
address=TEST_ADDRESS)
blocking_sender = blocking_connection.create_sender(
address=TEST_ADDRESS, options=apply_options)
TEST_MSG = "LOGTEST"
msg = Message(body=TEST_MSG)
blocking_sender.send(msg)
received_message = blocking_receiver.receive()
self.assertEqual(TEST_MSG, received_message.body)
server_log_found = True
all_server_logs = True
try:
with open(self.router.outdir + '/test-router-server.log',
'r') as server_log:
for line in server_log:
parts = line.split(" ")
if (parts[3] != "SERVER"):
all_server_logs = False
break
except:
server_log_found = False
self.assertTrue(all_server_logs)
self.assertTrue(server_log_found)
protocol_log_found = True
all_protocol_logs = True
try:
with open(self.router.outdir + '/test-router-protocol.log',
'r') as protocol_log:
for line in protocol_log:
parts = line.split(" ")
if (parts[3] != "PROTOCOL"):
all_protocol_logs = False
break
except:
protocol_log_found = False
self.assertTrue(protocol_log_found)
self.assertTrue(all_protocol_logs)
core_router_log_found = True
all_core_router_logs = True
try:
with open(self.router.outdir + '/test-router-core.log',
'r') as core_log:
for line in core_log:
parts = line.split(" ")
if parts[3] != "ROUTER_CORE" and parts[3] != "ROUTER":
all_core_router_logs = False
break
except:
core_router_log_found = False
self.assertTrue(core_router_log_found)
self.assertTrue(all_core_router_logs)
def on_sendable(self, event):
msg = Message(body=HELLO_WORLD)
event.sender.send(msg)
event.sender.close()
def on_sendable(self, event):
for i in range(10 - self.n_sent):
msg = Message(body=i)
event.sender.send(msg)
self.n_sent += 1
def next_request(self):
if self.receiver.remote_source.address:
req = Message(reply_to=self.receiver.remote_source.address, body=self.requests[0])
self.sender.send(req)
def test_12_semantics_spread(self):
addr = self.address + "/spread.1"
M1 = self.messenger()
M2 = self.messenger()
M3 = self.messenger()
M4 = self.messenger()
M2.timeout = 0.1
M3.timeout = 0.1
M4.timeout = 0.1
M1.start()
M2.start()
M3.start()
M4.start()
M2.subscribe(addr)
M3.subscribe(addr)
M4.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
for i in range(30):
tm.body = {'number': i}
M1.put(tm)
M1.send()
i = 0
rx_set = []
ca = 0
cb = 0
cc = 0
while len(rx_set) < 30:
try:
M2.recv(1)
M2.get(rm)
rx_set.append(rm.body['number'])
ca += 1
except:
pass
try:
M3.recv(1)
M3.get(rm)
rx_set.append(rm.body['number'])
cb += 1
except:
pass
try:
M4.recv(1)
M4.get(rm)
rx_set.append(rm.body['number'])
cc += 1
except:
pass
self.assertEqual(30, len(rx_set))
self.assertTrue(ca > 0)
self.assertTrue(cb > 0)
self.assertTrue(cc > 0)
rx_set.sort()
for i in range(30):
self.assertEqual(i, rx_set[i])
M1.stop()
M2.stop()
M3.stop()
M4.stop()
def on_message(self, event):
self.receivedMessages = self.receivedMessages + 1
print("Received " + str(self.receivedMessages) + " messages")
self.received_message = event
self.sender.send(
Message(address=self.send_destination, body="RECEIVED"))
def on_sendable(self, event):
while event.sender.credit and self.sent < self.total:
msg = Message(id=(self.sent+1), body={'sequence':(self.sent+1)})
event.sender.send(msg)
self.sent += 1
def on_sendable(self, event):
# Send just one message for now
if self.num_msgs < 1:
self.num_msgs += 1
msg = Message(body={'number': 1})
self.sender.send(msg)
parser = optparse.OptionParser(
usage="usage: %prog [options]",
description="Send requests to the supplied address and print responses.")
parser.add_option("-a",
"--address",
default="localhost:5672/examples",
help="address to which messages are sent (default %default)")
parser.add_option("-t",
"--timeout",
type="float",
default=5,
help="Give up after this time out (default %default)")
opts, args = parser.parse_args()
url = Url(opts.address)
client = SyncRequestResponse(BlockingConnection(url, timeout=opts.timeout),
url.path)
try:
REQUESTS = [
"Twas brillig, and the slithy toves",
"Did gire and gymble in the wabe.", "All mimsy were the borogroves,",
"And the mome raths outgrabe."
]
for request in REQUESTS:
response = client.call(Message(body=request))
print "%s => %s" % (request, response.body)
finally:
client.connection.close()
def on_sendable(self, event):
for i in range(self.count - self.n_sent):
msg = Message(body=self.body)
dlv = event.sender.send(msg)
dlv.settle()
self.n_sent += 1
def _send_ctrl(self, descriptor, value):
delivery = self.txn_ctrl.send(
Message(body=Described(descriptor, value)))
delivery.transaction = self
return delivery
def on_sendable(self, event):
for i in range(self.count - self.n_sent):
msg = Message(body="RvM-Test")
event.sender.send(msg)
self.n_sent += 1
def send_client(self):
while self.first_sender.credit > 0 and self.n_sent < self.count:
self.n_sent += 1
m = Message(body="Message %d of %d" % (self.n_sent, self.count))
self.first_sender.send(m)
def send(self):
if self.n_sent < self.count:
msg = Message(body="Appearance-Test")
self.sender.send(msg)
self.n_sent += 1
def do_request(self):
if self.pending and self.reply_address and self.sender.credit:
request, handler = self.pending.pop(0)
self.sent.append((request, handler))
req = Message(reply_to=self.reply_address, body=request)
self.sender.send(req)
def send(self):
if self.n_sent < self.count:
while self.sender.credit > 0:
msg = Message(body="Batch-Test")
self.sender.send(msg)
self.n_sent += 1
def send(self):
while self.sender.credit > 0 and self.n_sent < self.count:
self.n_sent += 1
m = Message(address=self.address,
body="Message %d of %d" % (self.n_sent, self.count))
self.sender.send(m)
def test_08_message_annotations(self):
addr = self.address + "/ma/1"
M1 = self.messenger()
M2 = self.messenger()
M1.start()
M2.start()
M2.subscribe(addr)
tm = Message()
rm = Message()
tm.address = addr
#
# No inbound delivery annotations
#
for i in range(10):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(10):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
ma = rm.annotations
self.assertEqual(ma.__class__, dict)
self.assertEqual(ma['x-opt-qd.ingress'], '0/QDR')
self.assertEqual(ma['x-opt-qd.trace'], ['0/QDR'])
#
# Pre-existing ingress
#
tm.annotations = {'x-opt-qd.ingress': 'ingress-router'}
for i in range(10):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(10):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
ma = rm.annotations
self.assertEqual(ma.__class__, dict)
self.assertEqual(ma['x-opt-qd.ingress'], 'ingress-router')
self.assertEqual(ma['x-opt-qd.trace'], ['0/QDR'])
#
# Invalid trace type
#
tm.annotations = {'x-opt-qd.trace': 45}
for i in range(10):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(10):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
ma = rm.annotations
self.assertEqual(ma.__class__, dict)
self.assertEqual(ma['x-opt-qd.ingress'], '0/QDR')
self.assertEqual(ma['x-opt-qd.trace'], ['0/QDR'])
#
# Empty trace
#
tm.annotations = {'x-opt-qd.trace': []}
for i in range(10):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(10):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
ma = rm.annotations
self.assertEqual(ma.__class__, dict)
self.assertEqual(ma['x-opt-qd.ingress'], '0/QDR')
self.assertEqual(ma['x-opt-qd.trace'], ['0/QDR'])
#
# Non-empty trace
#
tm.annotations = {'x-opt-qd.trace': ['0/first.hop']}
for i in range(10):
tm.body = {'number': i}
M1.put(tm)
M1.send()
for i in range(10):
M2.recv(1)
M2.get(rm)
self.assertEqual(i, rm.body['number'])
ma = rm.annotations
self.assertEqual(ma.__class__, dict)
self.assertEqual(ma['x-opt-qd.ingress'], '0/QDR')
self.assertEqual(ma['x-opt-qd.trace'], ['0/first.hop', '0/QDR'])
M1.stop()
M2.stop()
def create_message(self, test_value):
"""
Creates a single message with the test value translated from its string representation to the appropriate
AMQP value (set in self.amqp_type).
"""
if self.amqp_type == 'null':
return Message(id=(self.sent + 1), body=None)
elif self.amqp_type == 'boolean':
return Message(id=(self.sent + 1),
body=True if test_value == 'True' else False)
elif self.amqp_type == 'ubyte':
return Message(id=(self.sent + 1), body=ubyte(int(test_value, 16)))
elif self.amqp_type == 'ushort':
return Message(id=(self.sent + 1),
body=ushort(int(test_value, 16)))
elif self.amqp_type == 'uint':
return Message(id=(self.sent + 1), body=uint(int(test_value, 16)))
elif self.amqp_type == 'ulong':
return Message(id=(self.sent + 1), body=ulong(int(test_value, 16)))
elif self.amqp_type == 'byte':
return Message(id=(self.sent + 1), body=byte(int(test_value, 16)))
elif self.amqp_type == 'short':
return Message(id=(self.sent + 1), body=short(int(test_value, 16)))
elif self.amqp_type == 'int':
return Message(id=(self.sent + 1), body=int32(int(test_value, 16)))
elif self.amqp_type == 'long':
return Message(id=(self.sent + 1), body=long(int(test_value, 16)))
elif self.amqp_type == 'float':
return Message(id=(self.sent + 1),
body=float32(
unpack('!f', test_value[2:].decode('hex'))[0]))
elif self.amqp_type == 'double':
return Message(id=(self.sent + 1),
body=unpack('!d', test_value[2:].decode('hex'))[0])
elif self.amqp_type == 'decimal32':
return Message(id=(self.sent + 1),
body=decimal32(int(test_value[2:], 16)))
elif self.amqp_type == 'decimal64':
l64 = long(test_value[2:], 16)
return Message(id=(self.sent + 1), body=decimal64(l64))
elif self.amqp_type == 'decimal128':
return Message(id=(self.sent + 1),
body=decimal128(test_value[2:].decode('hex')))
elif self.amqp_type == 'char':
if len(test_value) == 1: # Format 'a'
return Message(id=(self.sent + 1), body=char(test_value))
else:
val = int(test_value, 16)
return Message(id=(self.sent + 1), body=char(unichr(val)))
elif self.amqp_type == 'timestamp':
return Message(id=(self.sent + 1),
body=timestamp(int(test_value, 16)))
elif self.amqp_type == 'uuid':
return Message(id=(self.sent + 1), body=UUID(test_value))
elif self.amqp_type == 'binary':
return Message(id=(self.sent + 1), body=bytes(test_value))
elif self.amqp_type == 'string':
return Message(id=(self.sent + 1), body=unicode(test_value))
elif self.amqp_type == 'symbol':
return Message(id=(self.sent + 1), body=symbol(test_value))
elif self.amqp_type == 'list':
return Message(id=(self.sent + 1), body=test_value)
elif self.amqp_type == 'map':
return Message(id=(self.sent + 1), body=test_value)
else:
print 'send: Unsupported AMQP type "%s"' % self.amqp_type
return None
def test_09_management(self):
addr = "amqp:/$management"
M = self.messenger()
M.start()
M.route("amqp:/*", self.address + "/$1")
sub = M.subscribe("amqp:/#")
reply = sub.address
request = Message()
response = Message()
request.address = addr
request.reply_to = reply
request.correlation_id = "C1"
request.properties = {
u'type': u'org.amqp.management',
u'name': u'self',
u'operation': u'GET-MGMT-NODES'
}
M.put(request)
M.send()
M.recv()
M.get(response)
assert response.properties['statusCode'] == 200, response.properties[
'statusCode']
self.assertEqual(response.correlation_id, "C1")
self.assertEqual(response.body, [])
request.address = addr
request.reply_to = reply
request.correlation_id = 135
request.properties = {
u'type': u'org.amqp.management',
u'name': u'self',
u'operation': u'GET-MGMT-NODES'
}
M.put(request)
M.send()
M.recv()
M.get(response)
self.assertEqual(response.properties['statusCode'], 200)
self.assertEqual(response.correlation_id, 135)
self.assertEqual(response.body, [])
request.address = addr
request.reply_to = reply
request.properties = {
u'type': u'org.amqp.management',
u'name': u'self',
u'operation': u'GET-MGMT-NODES'
}
M.put(request)
M.send()
M.recv()
M.get(response)
self.assertEqual(response.properties['statusCode'], 200)
self.assertEqual(response.body, [])
M.stop()
def read_address(self, name):
ap = {'operation': 'READ', 'type': 'org.apache.qpid.dispatch.router.address', 'name': name}
return Message(properties=ap, reply_to=self.reply_addr)
def on_sendable(self, event):
if self.sent == 0:
msg = Message(body="Hello World")
event.sender.send(msg)
self.sent += 1
def on_sendable(self, event: Event):
event.sender.send(Message(body="Test message"))
event.sender.close()
event.receiver.close()
event.connection.close()
from proton import Message from proton.utils import BlockingConnection from proton.handlers import IncomingMessageHandler QPIDD_HOST = '172.17.0.2:5672' QUEUE = 'testqueue' conn = BlockingConnection(QPIDD_HOST) sender = conn.create_sender(QUEUE) sender.send(Message(body='Hello World!')) conn.close()
