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