def test_bug3_loop(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
qname = 'test%s' % (random.random(), )
promise = client.queue_declare(queue=qname)
client.wait(promise)
try:
for i in range(3):
promise = client.basic_publish(exchange='',
routing_key=qname,
body='x')
client.wait(promise)
i = [0]
def cb(_, msg):
client.basic_ack(msg)
self.assertEqual(msg['body'], 'x')
i[0] += 1
if i[0] == 3:
client.loop_break()
consume_promise = client.basic_consume(qname, callback=cb)
client.loop()
client.socket().close()
self._epilogue(qname, 0)
finally:
client = puka.Client(self.amqp_url)
client.wait(client.connect())
client.queue_delete(queue=qname)
def test_bug3_wait(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
qname = 'test%s' % (random.random(), )
promise = client.queue_declare(queue=qname)
client.wait(promise)
try:
for i in range(3):
promise = client.basic_publish(exchange='',
routing_key=qname,
body='x')
client.wait(promise)
consume_promise = client.basic_consume(qname)
for i in range(3):
msg = client.wait(consume_promise)
client.basic_ack(msg)
self.assertEqual(msg['body'], 'x')
client.socket().close()
self._epilogue(qname, 1)
finally:
client = puka.Client(self.amqp_url)
client.wait(client.connect())
client.queue_delete(queue=qname)
def setup_connections(self, amqp_url):
LOG.debug('Setting up graylog API...')
attempts = 20
log_server = GraylogAPI(self.logserver_url, self.logserver_port,
self.logserver_user, self.logserver_pass)
client = puka.Client(amqp_url)
try:
time.sleep(15) # let the system settle :-)
LOG.debug('AMQP connection to: ' + amqp_url)
promise = client.connect()
client.wait(promise)
except:
LOG.error('Cannot connect to the RCB message bus.')
while attempts > 0:
LOG.debug('Sleeping for 10 secs')
time.sleep(10)
LOG.debug('AMQP connection to: ' + amqp_url)
promise = client.connect()
client.wait(promise)
attempts = attempts - 1
else:
client.close()
LOG.error(
'Giving up attempting to connect to the AMQP bus after number of attempts: '
+ str(attempts))
raise RuntimeError(
'Giving up attempting to connect to the AMQP bus after number of attempts: '
+ str(attempts))
self.setup_amqp(amqp_url, client)
return client, log_server
def main():
client = puka.Client(AMQP_URL, pubacks=PUBACKS)
promise = client.connect()
client.wait(promise)
def inc(value=1):
global counter
counter += value
def avg(td):
global average, average_count
average += td
average_count += 1
for q in ['q%04i' % i for i in range(QUEUE_CNT)]:
worker(client, q, QUEUE_SIZE, 'a' * BODY_SIZE, PREFETCH_CNT, inc, avg)
global counter, average, average_count
print ' [*] loop'
while True:
t0 = time.time()
client.loop(timeout=1.0)
td = time.time() - t0
average_count = max(average_count, 1.0)
print "send: %i avg: %.3fms " % (counter / td,
(average / average_count) * 1000.0)
counter = average = average_count = 0
def _connect_rbt_server(self):
''' connnect to rabbitmq server
params string server_url amqp的url
return 1表示成功
'''
server_url = self.rbt_server_list[self.current_node_index]
try:
self.client = puka.Client(server_url)
promise = self.client.connect()
res = self.client.wait(promise)
if res and res.has_key('server_properties'):
logging.info('connect to rabbitmq-server [%s] success',server_url)
else:
logging.error('fail to connect or init rabbitmq-server ,amqp url is [%s] error is [%s]',server_url, traceback.format_exc())
return -1
if not self.declare_my_exchange():
#declare exchange
return -4
if not self.declare_my_queue(self.my_q_name):
#declare myself queue error
return -2
if not self.declare_group_queue(self.my_grp_qname):
#declare my group queue error
return -3
if self.type == 'read':
self.get_consume_promise( [self.my_q_name, self.my_grp_qname])
logging.info('success init to rabbitmq-server [%s] success',server_url)
return 1
except:
logging.error('fail to connect or init rabbitmq-server ,amqp url is [%s] error is [%s]',server_url, traceback.format_exc())
time.sleep(0.3)
return -1
def test_simple_roundtrip(self):
client = puka.Client(self.amqp_url)
def on_connect(t, result):
client.queue_declare(queue=self.name,
callback=on_queue_declare)
self.cleanup_promise(client.queue_delete, queue=self.name)
def on_queue_declare(t, result):
client.basic_publish(exchange='', routing_key=self.name,
body=self.msg,
callback=on_basic_publish)
def on_basic_publish(t, result):
client.basic_get(queue=self.name,
callback=on_basic_get)
def on_basic_get(t, result):
self.assertEqual(result['body'], self.msg)
client.basic_ack(result)
client.queue_delete(queue=self.name,
callback=on_queue_delete)
def on_queue_delete(t, result):
client.loop_break()
try:
client.connect(callback=on_connect)
client.loop()
finally:
self.run_cleanup_promises(client)
promise = client.close()
client.wait(promise)
def test_basic_ack_fail(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(queue=self.name)
client.wait(promise)
promise = client.basic_publish(exchange='',
routing_key=self.name,
body='a')
client.wait(promise)
promise = client.basic_consume(queue=self.name)
result = client.wait(promise)
with self.assertRaises(puka.PreconditionFailed):
r2 = result.copy()
r2['delivery_tag'] = 999
client.basic_ack(r2)
client.wait(promise)
promise = client.basic_consume(queue=self.name)
result = client.wait(promise)
client.basic_ack(result)
with self.assertRaises(AssertionError):
client.basic_ack(result)
promise = client.queue_delete(queue=self.name)
client.wait(promise)
def plugin(srv, item):
srv.logging.debug("*** MODULE=%s: service=%s, target=%s", __file__,
item.service, item.target)
uri = item.config['uri']
exchange, routing_key = item.addrs
try:
srv.logging.debug("AMQP publish to %s [%s/%s]..." %
(item.target, exchange, routing_key))
client = puka.Client(uri)
promise = client.connect()
client.wait(promise)
headers = {
'content_type': 'text/plain',
'x-agent': 'mqttwarn',
'delivery_mode': 1,
}
promise = client.basic_publish(exchange=exchange,
routing_key=routing_key,
headers=headers,
body=item.message)
client.wait(promise)
client.close()
srv.logging.debug("Successfully published AMQP notification")
except Exception as e:
srv.logging.warn("Error on AMQP publish to %s [%s/%s]: %s" %
(item.target, exchange, routing_key, e))
return False
return True
def test_basic_reject_no_requeue(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(queue=self.name)
client.wait(promise)
promise = client.basic_publish(exchange='',
routing_key=self.name,
body='a')
client.wait(promise)
t = client.basic_get(queue=self.name)
r = client.wait(t)
self.assertEqual(r['body'], 'a')
self.assertTrue(not r['redelivered'])
client.basic_reject(r, requeue=False)
t = client.basic_get(queue=self.name)
r = client.wait(t)
self.assertTrue(r['empty'])
self.assertFalse('redelivered' in r)
self.assertFalse('body' in r)
promise = client.queue_delete(queue=self.name)
client.wait(promise)
def test_basic_get_ack(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(queue=self.name)
client.wait(promise)
for i in range(4):
promise = client.basic_publish(exchange='',
routing_key=self.name,
body=self.msg + str(i))
client.wait(promise)
msgs = []
for i in range(4):
promise = client.basic_get(queue=self.name)
result = client.wait(promise)
self.assertEqual(result['body'], self.msg + str(i))
self.assertEqual(result['redelivered'], False)
msgs.append(result)
promise = client.basic_get(queue=self.name)
result = client.wait(promise)
self.assertEqual('body' in result, False)
self.assertEqual(len(client.channels.free_channels), 1)
self.assertEqual(client.channels.free_channel_numbers[-1], 7)
for msg in msgs:
client.basic_ack(msg)
self.assertEqual(len(client.channels.free_channels), 5)
self.assertEqual(client.channels.free_channel_numbers[-1], 7)
promise = client.queue_delete(queue=self.name)
client.wait(promise)
def test_basic_return(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.basic_publish(exchange='',
routing_key=self.name,
mandatory=True,
body='')
with self.assertRaises(puka.NoRoute):
client.wait(promise)
promise = client.queue_declare(queue=self.name)
client.wait(promise)
promise = client.basic_publish(exchange='',
routing_key=self.name,
mandatory=True,
body='')
client.wait(promise) # no error
promise = client.basic_publish(exchange='',
routing_key=self.name,
immediate=True,
body='')
with self.assertRaises(puka.NoConsumers):
r = client.wait(promise)
print r
promise = client.queue_delete(queue=self.name)
client.wait(promise)
def test_close(self):
def on_connection(promise, result):
client.queue_declare(queue=self.name, callback=on_queue_declare)
self.cleanup_promise(client.queue_delete, queue=self.name)
def on_queue_declare(promise, result):
client.basic_publish(exchange='', routing_key=self.name,
body="Hello world!",
callback=on_basic_publish)
def on_basic_publish(promise, result):
client.queue_delete(queue=self.name,
callback=on_queue_delete)
def on_queue_delete(promise, result):
client.loop_break()
client = puka.Client(self.amqp_url)
try:
client.connect(callback=on_connection)
client.loop()
finally:
self.run_cleanup_promises(client)
promise = client.close()
client.wait(promise)
def test_simple_roundtrip(self):
client = puka.Client(self.amqp_url, pubacks=self.pubacks)
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(queue=self.name)
client.wait(promise)
promise = client.basic_publish(exchange='',
routing_key=self.name,
body=self.msg)
client.wait(promise)
consume_promise = client.basic_consume(queue=self.name, no_ack=False)
msg = client.wait(consume_promise)
self.assertEqual(msg['body'], self.msg)
client.basic_ack(msg)
result = client.wait(consume_promise, timeout=0.1)
self.assertEqual(result, None)
promise = client.queue_delete(queue=self.name)
client.wait(promise)
def test_basic_cancel(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(queue=self.name)
client.wait(promise)
for i in range(2):
promise = client.basic_publish(exchange='',
routing_key=self.name,
body='a')
client.wait(promise)
consume_promise = client.basic_consume(queue=self.name)
msg1 = client.wait(consume_promise)
self.assertEqual(msg1['body'], 'a')
client.basic_ack(msg1)
promise = client.basic_cancel(consume_promise)
result = client.wait(promise)
self.assertTrue('consumer_tag' in result)
promise = client.basic_publish(exchange='',
routing_key=self.name,
body='b')
client.wait(promise)
promise = client.queue_delete(queue=self.name)
client.wait(promise)
def test_pubacks(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
r = client.wait(promise)
self.assertEqual(client.pubacks, None)
self.assertTrue(r['server_properties']['capabilities']\
['publisher_confirms'])
self.assertTrue(client.x_pubacks)
def wrapper(self, *args, **kwargs):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
r = method(self, client, *args, **kwargs)
promise = client.close()
client.wait(promise)
return r
def _epilogue(self, qname, expected):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(queue=qname)
q = client.wait(promise)
client.wait(client.queue_delete(queue=qname))
self.assertEqual(q['message_count'], expected)
def test_wrong_user(self):
(username, password, vhost, host, port, use_ssl) = \
puka.connection.parse_amqp_url(AMQP_URL)
client = puka.Client('amqp%s://%s:%s@%s:%s%s' % \
('s' if use_ssl else '', username, 'wrongpass', host, port, vhost))
promise = client.connect()
with self.assertRaises(puka.ConnectionBroken):
client.wait(promise)
def test_queue_delete_not_found(self):
client = puka.Client(AMQP_URL)
promise = client.connect()
client.wait(promise)
promise = client.queue_delete(queue='not_existing_queue')
with self.assertRaises(puka.NotFound):
client.wait(promise)
def test_return(self):
client = puka.Client(self.amqp_url, pubacks=self.pubacks)
promise = client.connect()
client.wait(promise)
promise = client.basic_publish(exchange='', routing_key='',
body=self.msg, immediate=True)
with self.assertRaises(puka.NoConsumers):
client.wait(promise)
def test_queue_declare(self):
qname = 'test%s-this-queue-should-be-autodeleted' % (random.random(), )
client = puka.Client(AMQP_URL)
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(queue=qname, auto_delete=True)
client.wait(promise)
def test_wrong_user(self):
(username, password, vhost, host, port) = \
puka.connection.parse_amqp_url(AMQP_URL)
client = puka.Client('amqp://%s:%s@%s:%s%s' % \
(username, 'wrongpass', host, port, vhost))
promise = client.connect()
with self.assertRaises(socket.error):
client.wait(promise)
def test_bind(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.exchange_declare(exchange=self.name1, type='fanout')
client.wait(promise)
promise = client.exchange_declare(exchange=self.name2, type='fanout')
client.wait(promise)
promise = client.queue_declare()
qname = client.wait(promise)['queue']
promise = client.queue_bind(queue=qname, exchange=self.name2)
client.wait(promise)
promise = client.basic_publish(exchange=self.name1,
routing_key='',
body='a')
client.wait(promise)
promise = client.exchange_bind(source=self.name1,
destination=self.name2)
client.wait(promise)
promise = client.basic_publish(exchange=self.name1,
routing_key='',
body='b')
client.wait(promise)
promise = client.exchange_unbind(source=self.name1,
destination=self.name2)
client.wait(promise)
promise = client.basic_publish(exchange=self.name1,
routing_key='',
body='c')
client.wait(promise)
promise = client.basic_get(queue=qname, no_ack=True)
r = client.wait(promise)
self.assertEquals(r['body'], 'b')
promise = client.basic_get(queue=qname)
r = client.wait(promise)
self.assertTrue('empty' in r)
promise = client.exchange_delete(exchange=self.name1)
client.wait(promise)
promise = client.exchange_delete(exchange=self.name2)
client.wait(promise)
promise = client.queue_delete(queue=qname)
client.wait(promise)
promise = client.close()
client.wait(promise)
def test_exchange_delete_not_found(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
promise = client.exchange_delete(exchange='not_existing_exchange')
with self.assertRaises(puka.NotFound):
client.wait(promise)
def __init__(self):
self.client = client = puka.Client("amqp://localhost/")
promise = client.connect()
client.wait(promise)
promise = client.queue_declare(exclusive=True)
self.callback_queue = client.wait(promise)['queue']
self.consume_promise = client.basic_consume(queue=self.callback_queue,
no_ack=True)
def main():
sc = connect_slack()
consumer = puka.Client(rabbitmq)
receive_promise = consumer.connect()
consumer.wait(receive_promise)
receive_promise = consumer.basic_consume(queue=rabbit_queue, no_ack=True)
while True:
received_message = consumer.wait(receive_promise)
value = json.loads(received_message['body'])
send_menssage(sc, str(value["channel"]), str(value["msg"]))
def test_return(self):
self.client = client = puka.Client(self.amqp_url, pubacks=self.pubacks)
promise = client.connect()
client.wait(promise)
promise = client.basic_publish(exchange='',
routing_key='',
body=self.msg,
mandatory=True)
with self.assertRaises(puka.NoRoute):
client.wait(promise)
def test_bug21(self):
# Following the testcase: https://github.com/majek/puka/issues/21
client = puka.Client(self.amqp_url, pubacks=self.pubacks)
promise = client.connect()
client.wait(promise)
promises = []
for i in range(0, 42):
promise = client.basic_publish('', 'test_key', 'test_body')
self.assertTrue(len(client.send_buf) > 0)
promises.append(promise)
def test_basic_consume_fail(self):
client = puka.Client(self.amqp_url)
promise = client.connect()
client.wait(promise)
consume_promise = client.basic_consume(queue='bad_q_name')
with self.assertRaises(puka.NotFound):
msg_result = client.wait(consume_promise)
promise = client.close()
client.wait(promise)
def send_queue(queue, payload):
producer = puka.Client(rabbitmq)
send_promise = producer.connect()
producer.wait(send_promise)
send_promise = producer.queue_declare(queue=queue)
producer.wait(send_promise)
# send message to the queue named rabbit
send_promise = producer.basic_publish(exchange='',
routing_key=rabbit_queue_push,
body=json.dumps(payload))
producer.wait(send_promise)
return True
