def get_producers(self): """ One producer only for all messages, since we have only one exchange. """ return { 'psms': Producer(self.channel, exchange=self.exchanges['psms']) }
def _send_dhcp_notification(self, context, data, methodname): #self._dhcp_agent_notifier.notify(context, data, methodname) task_exchange = Exchange('nspagent', type='topic') create_result = {"oslo.message" :{ #'message_id': '5c329c20-d435-444c-8fa2-e1b54592219c', #'publisher_id': 'compute.host1', 'method': 'network_create_end', #'_context_user_id': None, #'_context_project_id': None, #'_context_is_admin': True, "args" : {"payload": {"network": network #{"id": "24783e1a-63fe-43d5-9989-e1515c24eecd"} } } }, "oslo.version":'2.0', } create_result["oslo.message" ] = json.dumps(create_result["oslo.message"]) connection = Connection('amqp://*****:*****@192.168.49.22:5672//') channel = connection.channel() message=Message(channel,body= 'subenet_create_end') # produce producer = Producer(channel,serializer='json') print message.body, task_exchange producer.publish(create_result, routing_key='dhcp_agent')
def test_revive(self): chan = self.connection.channel() p = Producer(chan) chan2 = self.connection.channel() p.revive(chan2) self.assertIs(p.channel, chan2) self.assertIs(p.exchange.channel, chan2)
def _process_attacks_queue(self) -> None: conn = Connection(config.get_broker_url()) with conn.channel() as channel: producer = Producer(channel) by_label = defaultdict(list) while not self._q.empty(): try: ar: models.AttackResult = self._q.get_nowait() except Empty: continue else: by_label[ar.get_label_key()].append(ar) for ar_list in by_label.values(): if not ar_list: continue monitor_message = { 'type': 'flag_submit', 'data': ar_list[0].get_label_values(), 'value': len(ar_list), } producer.publish( monitor_message, exchange='', routing_key='forcad-monitoring', )
def enable(self): conf = self.app.conf self.enabled = True channel = self.channel or self.connection.channel() self.publisher = Producer(channel, exchange=event_exchange, serializer=conf.CELERY_EVENT_SERIALIZER)
def enable(self): conf = self.app.conf self.enabled = True channel = self.channel or self.connection.channel() self.publisher = Producer(channel, exchange=event_exchange, serializer=self.serializer)
def Connect(self): self.connection = Connection( hostname=self.host, port=self.port, userid=self.usr, password=self.psw, virtual_host=self.virtual_host, transport='kombu.transport.pyamqp:Transport') self.channel = self.connection.channel() self.producer = Producer(self.channel) self.task_count = 0 if self.needresult: self.back_queue = Queue(name=self.result_queuename, auto_delete=True, exclusive=True, durable=False) self.consumer = Consumer(self.channel, self.back_queue, no_ack=True) self.consumer.qos(prefetch_count=1) self.consumer.register_callback(self.on_response) self.callback_queue = self.consumer.queues[0].name self.consumer.consume() else: self.callback_queue = None
def enable(self): self.publisher = Producer(self.channel or self.connection.channel(), exchange=event_exchange, serializer=self.serializer) self.enabled = True for callback in self.on_enabled: callback()
def test_publish__consume(self): connection = BrokerConnection(transport=Transport) channel = connection.channel() producer = Producer(channel, self.exchange, routing_key="test_Redis") consumer = Consumer(channel, self.queue) producer.publish({"hello2": "world2"}) _received = [] def callback(message_data, message): _received.append(message_data) message.ack() consumer.register_callback(callback) consumer.consume() self.assertIn(channel, channel.connection.cycle._channels) try: connection.drain_events(timeout=1) self.assertTrue(_received) self.assertRaises(socket.timeout, connection.drain_events, timeout=0.01) finally: channel.close()
def _send(self, connection, request): """ :param request: JSON serializable dict """ dbutils.exit_if_in_transaction(log) log.debug("send %s" % request["request_id"]) request["response_routing_key"] = self._response_routing_key def errback(exc, _): log.info( "RabbitMQ rpc got a temporary error. May retry. Error: %r", exc, exc_info=1) retry_policy = {"max_retries": 10, "errback": errback} with Producer(connection) as producer: maybe_declare(_amqp_exchange(), producer.channel, True, **retry_policy) producer.publish( request, serializer="json", routing_key=self._request_routing_key, delivery_mode=TRANSIENT_DELIVERY_MODE, retry=True, retry_policy=retry_policy, )
def test_prepare(self): message = {u'the quick brown fox': u'jumps over the lazy dog'} channel = self.connection.channel() p = Producer(channel, self.exchange, serializer='json') m, ctype, cencoding = p._prepare(message, headers={}) self.assertDictEqual(message, anyjson.loads(m)) self.assertEqual(ctype, 'application/json') self.assertEqual(cencoding, 'utf-8')
def test_auto_declare(self): channel = self.connection.channel() p = Producer(channel, self.exchange, auto_declare=True) self.assertIsNot(p.exchange, self.exchange, "creates Exchange clone at bind") self.assertTrue(p.exchange.is_bound) self.assertIn("exchange_declare", channel, "auto_declare declares exchange")
def test_prepare(self): message = {u"the quick brown fox": u"jumps over the lazy dog"} channel = self.connection.channel() p = Producer(channel, self.exchange, serializer="json") m, ctype, cencoding = p._prepare(message, headers={}) self.assertDictEqual(message, anyjson.loads(m)) self.assertEqual(ctype, "application/json") self.assertEqual(cencoding, "utf-8")
def _InitConnect(self): if self.connection is None or self.connection.connected == False: self.connection = Connection(hostname=self.server, port=self.port, userid=self.usr, password=self.psw, virtual_host=self.path) self.channel = self.connection.channel() self.producer = Producer(self.channel) self.smsExchange = Exchange("sys.sms", type='topic', channel=self.channel, durable=True, delivery_mode=2) self.smsCodeProduce = Producer(self.channel, self.smsExchange, routing_key='sms.code')
def test_produce_consume(self): channel = self.c.channel() producer = Producer(channel, self.e) consumer1 = Consumer(channel, self.q) consumer2 = Consumer(channel, self.q2) self.q2(channel).declare() for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_memory") for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_memory2") _received1 = [] _received2 = [] def callback1(message_data, message): _received1.append(message) message.ack() def callback2(message_data, message): _received2.append(message) message.ack() consumer1.register_callback(callback1) consumer2.register_callback(callback2) consumer1.consume() consumer2.consume() while 1: if len(_received1) + len(_received2) == 20: break self.c.drain_events() self.assertEqual(len(_received1) + len(_received2), 20) # compression producer.publish({"compressed": True}, routing_key="test_transport_memory", compression="zlib") m = self.q(channel).get() self.assertDictEqual(m.payload, {"compressed": True}) # queue.delete for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_memory") self.assertTrue(self.q(channel).get()) self.q(channel).delete() self.q(channel).declare() self.assertIsNone(self.q(channel).get()) # queue.purge for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_memory2") self.assertTrue(self.q2(channel).get()) self.q2(channel).purge() self.assertIsNone(self.q2(channel).get())
def test_manual_declare(self): channel = self.connection.channel() p = Producer(channel, self.exchange, auto_declare=False) self.assertTrue(p.exchange.is_bound) self.assertNotIn("exchange_declare", channel, "auto_declare=False does not declare exchange") p.declare() self.assertIn("exchange_declare", channel, "p.declare() declares exchange")
def test_on_return(self): chan = self.connection.channel() def on_return(exception, exchange, routing_key, message): pass p = Producer(chan, on_return=on_return) self.assertTrue(on_return in chan.events["basic_return"]) self.assertTrue(p.on_return)
def setup_rabbit_mq_channel(self): service_exchange = Exchange(self.acord_control_exchange, "topic", durable=False) # connections/channels connection = BrokerConnection(self.rabbit_host, self.rabbit_user, self.rabbit_password) logging.info("Connection to RabbitMQ server successful") channel = connection.channel() # produce self.producer = Producer(channel, exchange=service_exchange, routing_key='notifications.info') self.publish = connection.ensure(self.producer, self.producer.publish, errback=self.errback, max_retries=3)
def run(self): try: result = { "result": self.rpc._local_call(self.body["method"], *self.body["args"], **self.body["kwargs"]), "request_id": self.body["request_id"], "exception": None, } except Exception as e: import sys import traceback exc_info = sys.exc_info() backtrace = "\n".join(traceback.format_exception(*(exc_info or sys.exc_info()))) # Utility to generate human readable errors def translate_error(err): from socket import error as socket_error if type(err) == socket_error: return "Cannot reach server" return str(err) result = { "request_id": self.body["request_id"], "result": None, "exception": translate_error(e), "exception_type": type(e).__name__, "traceback": backtrace, } log.error("RunOneRpc: exception calling %s: %s" % (self.body["method"], backtrace)) finally: django.db.connection.close() with self._response_conn_pool[_amqp_connection()].acquire(block=True) as connection: def errback(exc, _): log.info("RabbitMQ rpc got a temporary error. May retry. Error: %r", exc, exc_info=1) retry_policy = {"max_retries": 10, "errback": errback} connection.ensure_connection(**retry_policy) with Producer(connection) as producer: maybe_declare(_amqp_exchange(), producer.channel, True, **retry_policy) producer.publish( result, serializer="json", routing_key=self.body["response_routing_key"], delivery_mode=TRANSIENT_DELIVERY_MODE, retry=True, retry_policy=retry_policy, immedate=True, mandatory=True, )
def main(): connection = Connection('amqp://*****:*****@localhost:5672//') _channel = connection.channel() _exchange = Exchange('neutron', type='topic') pro = Producer(channel=_channel, exchange=_exchange, routing_key='q-plugin') pro.publish(MSG)
def publish(self, data, timeout=None): p = Producer(channel=self.channel, exchange=Exchange(self.target.exchange_name, type=self.EXCHANGE_TYPE, durable=self.options['durable'], auto_delete=self.options['auto_delete']), routing_key=self.target.routing_key) if timeout: p.publish(data, headers={'ttl': (timeout * 1000)}) else: p.publish(data)
def setup_rabbit_mq_channel(self): service_exchange = Exchange(cfg.CONF.udpservice.acord_control_exchange, "topic", durable=False) rabbit_host = cfg.CONF.udpservice.rabbit_hosts rabbit_user = cfg.CONF.udpservice.rabbit_userid rabbit_password = cfg.CONF.udpservice.rabbit_password # connections/channels connection = BrokerConnection(rabbit_host, rabbit_user, rabbit_password) print 'Connection to RabbitMQ server successful' channel = connection.channel() # produce self.producer = Producer(channel, exchange=service_exchange, routing_key='notifications.info')
def test_purge(self): channel = self.connection.channel() producer = Producer(channel, self.exchange, routing_key="test_Redis") self.queue(channel).declare() for i in range(10): producer.publish({"hello": "world-%s" % (i, )}) self.assertEqual(channel._size("test_Redis"), 10) self.assertEqual(self.queue(channel).purge(), 10) channel.close()
def _publish_reply(self, reply, exchange, routing_key, channel=None): chan = channel or self.connection.channel() try: exchange = Exchange(exchange, exchange_type="direct", delivery_mode="transient", durable=False, auto_delete=True) producer = Producer(chan, exchange=exchange, auto_declare=True) producer.publish(reply, routing_key=routing_key) finally: channel or chan.close()
def test_publish__get(self): channel = self.connection.channel() producer = Producer(channel, self.exchange, routing_key="test_Redis") self.queue(channel).declare() producer.publish({"hello": "world"}) self.assertDictEqual( self.queue(channel).get().payload, {"hello": "world"}) self.assertIsNone(self.queue(channel).get()) self.assertIsNone(self.queue(channel).get()) self.assertIsNone(self.queue(channel).get())
def test_prepare_compression(self): message = {u'the quick brown fox': u'jumps over the lazy dog'} channel = self.connection.channel() p = Producer(channel, self.exchange, serializer='json') headers = {} m, ctype, cencoding = p._prepare(message, compression='zlib', headers=headers) self.assertEqual(ctype, 'application/json') self.assertEqual(cencoding, 'utf-8') self.assertEqual(headers['compression'], 'application/x-gzip') import zlib self.assertEqual(anyjson.loads( zlib.decompress(m).decode('utf-8')), message)
def test_prepare_is_already_unicode(self): message = u'the quick brown fox' channel = self.connection.channel() p = Producer(channel, self.exchange, serializer='json') m, ctype, cencoding = p._prepare(message, content_type='text/plain') self.assertEqual(m, message.encode('utf-8')) self.assertEqual(ctype, 'text/plain') self.assertEqual(cencoding, 'utf-8') m, ctype, cencoding = p._prepare(message, content_type='text/plain', content_encoding='utf-8') self.assertEqual(m, message.encode('utf-8')) self.assertEqual(ctype, 'text/plain') self.assertEqual(cencoding, 'utf-8')
def init(host, port, virtual_host, usr, psw, queue_name): global connection, channel, producer, task_queue, consumer connection = Connection(hostname=host, port=port, userid=usr, password=psw, virtual_host=virtual_host) channel = connection.channel() producer = Producer(channel) task_queue = Queue(queue_name, durable=True) consumer = Consumer(channel, task_queue, no_ack=False) consumer.qos(prefetch_count=1) consumer.register_callback(RequestCallBack)
def _send(self, connection, request): """ :param request: JSON serializable dict """ log.debug("send %s" % request['request_id']) request['response_routing_key'] = self._response_routing_key with Producer(connection) as producer: maybe_declare(_amqp_exchange(), producer.channel) producer.publish(request, serializer="json", routing_key=self._request_routing_key, delivery_mode=1)
def test_prepare_custom_content_type(self): message = 'the quick brown fox'.encode('utf-8') channel = self.connection.channel() p = Producer(channel, self.exchange, serializer='json') m, ctype, cencoding = p._prepare(message, content_type='custom') self.assertEqual(m, message) self.assertEqual(ctype, 'custom') self.assertEqual(cencoding, 'binary') m, ctype, cencoding = p._prepare(message, content_type='custom', content_encoding='alien') self.assertEqual(m, message) self.assertEqual(ctype, 'custom') self.assertEqual(cencoding, 'alien')