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 _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')
class UdpService(os_service.Service): """Listener for the udpservice service.""" def start(self): """Bind the UDP socket and handle incoming data.""" # ensure dispatcher is configured before starting other services super(UdpService, self).start() if cfg.CONF.udpservice.udp_address: self.tg.add_thread(self.start_udp) def convert_sample_to_event_data(self,msg): event_data = {'event_type': 'infra','message_id':six.text_type(uuid.uuid4()),'publisher_id': 'cpe_publisher_id','timestamp':datetime.datetime.now().isoformat(),'priority':'INFO','payload':msg} return event_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 start_udp(self): address_family = socket.AF_INET if netutils.is_valid_ipv6(cfg.CONF.udpservice.udp_address): address_family = socket.AF_INET6 udp = socket.socket(address_family, socket.SOCK_DGRAM) udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) udp.bind((cfg.CONF.udpservice.udp_address, cfg.CONF.udpservice.udp_port)) self.setup_rabbit_mq_channel() self.udp_run = True while self.udp_run: # NOTE(jd) Arbitrary limit of 64K because that ought to be # enough for anybody. data, source = udp.recvfrom(64 * units.Ki) try: sample = msgpack.loads(data, encoding='utf-8') except Exception: LOG.warn(_("UDP: Cannot decode data sent by %s"), source) else: try: if sample.has_key("event_type"): LOG.debug(_("recevied event :%s"),sample) self.producer.publish(sample) else: LOG.debug(_("recevied Sample :%s"),sample) msg = self.convert_sample_to_event_data(sample) self.producer.publish(msg) except Exception: LOG.exception(_("UDP: Unable to store meter")) def stop(self): self.udp_run = False super(UdpService, self).stop()
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.assertTrue(channel._poller._can_start()) try: connection.drain_events(timeout=1) self.assertTrue(_received) self.assertFalse(channel._poller._can_start()) self.assertRaises(socket.timeout, connection.drain_events, timeout=0.01) finally: channel.close()
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 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 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 _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')
class QueuePush(object): def __init__(self,Queue_Server,Queue_Port,Queue_User,Queue_PassWord,Queue_Path): self.usr=Queue_User self.psw=Queue_PassWord self.server=Queue_Server self.port=Queue_Port self.path=Queue_Path self.connection=None self.smsExchange=None 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 Push(self,queueid,connectid,body): self.rawPush(queueid,{'connid':connectid},body) def Close(self,queueid,connectid): self.rawPush(queueid,{'connid':connectid,'close_connect':'1'},'close') def rawPush(self,routing_key,headers,body): self._InitConnect() self.producer.publish(body=body,delivery_mode=2,headers=headers, routing_key=routing_key,retry=True,compression='gzip') def sendCode(self,phone,code): self._InitConnect() json_str=json.dumps({'phone':str(phone),"content":u"您的莱信验证码为:%s,请在5分钟内输入完成验证。【莱福思】"%str(code)},ensure_ascii=False) self.smsCodeProduce.publish(body=json_str,retry=True,compression='gzip')
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 _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 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_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')
class QueuePush(object): def __init__(self, Queue_Server, Queue_Port, Queue_User, Queue_PassWord, Queue_Path): self.usr = Queue_User self.psw = Queue_PassWord self.server = Queue_Server self.port = Queue_Port self.path = Queue_Path self.connection = None self.smsExchange = None 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 Push(self, queueid, connectid, body): self.rawPush(queueid, {'connid': connectid}, body) def Close(self, queueid, connectid): self.rawPush(queueid, { 'connid': connectid, 'close_connect': '1' }, 'close') def rawPush(self, routing_key, headers, body): self._InitConnect() self.producer.publish(body=body, delivery_mode=2, headers=headers, routing_key=routing_key, retry=True, compression='gzip') def sendCode(self, phone, code): self._InitConnect() json_str = json.dumps( { 'phone': str(phone), "content": u"您的莱信验证码为:%s,请在5分钟内输入完成验证。【莱福思】" % str(code) }, ensure_ascii=False) self.smsCodeProduce.publish(body=json_str, retry=True, compression='gzip')
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 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_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) producer.publish(reply, routing_key=routing_key) finally: channel or chan.close()
def _publish(self, type, arguments, destination=None, reply_ticket=None, channel=None): message = {"method": type, "arguments": arguments, "destination": destination} if reply_ticket: message["reply_to"] = {"exchange": self.reply_exchange.name, "routing_key": reply_ticket} chan = channel or self.connection.channel() producer = Producer(chan, exchange=self.exchange) try: producer.publish(message) 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_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 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") self.assertEqual(simplejson.loads(m.decode("zlib")), message)
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 _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_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')
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 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 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")
def producer(self): self.connection = BrokerConnection(hostname=AMQP_IP, port=AMQP_PORT, userid=AMQP_USER, password=AMQP_PASSWORD, virtual_host="/", transport=AMQP_TRANSPORT) self.channel = self.connection.channel() # produce self.media_exchange = Exchange("media", "direct", durable=True) producer = Producer(self.channel, exchange=self.media_exchange, serializer="json") producer.publish({"name": "/tmp/lolcat1.avi", "size": 1301013}) print self.connection.get_transport_cls()
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 _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 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 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 test_publish(self): channel = self.connection.channel() p = Producer(channel, self.exchange, serializer='json') message = {u'the quick brown fox': u'jumps over the lazy dog'} ret = p.publish(message, routing_key='process') self.assertIn('prepare_message', channel) self.assertIn('basic_publish', channel) m, exc, rkey = ret self.assertDictEqual(message, anyjson.loads(m['body'])) self.assertDictContainsSubset({'content_type': 'application/json', 'content_encoding': 'utf-8', 'priority': 0}, m) self.assertDictContainsSubset({'delivery_mode': 2}, m['properties']) self.assertEqual(exc, p.exchange.name) self.assertEqual(rkey, 'process')
def test_publish(self): channel = self.connection.channel() p = Producer(channel, self.exchange, serializer="json") message = {u"the quick brown fox": u"jumps over the lazy dog"} ret = p.publish(message, routing_key="process") self.assertIn("prepare_message", channel) self.assertIn("basic_publish", channel) m, exc, rkey = ret self.assertDictEqual(message, anyjson.loads(m["body"])) self.assertDictContainsSubset({"content_type": "application/json", "content_encoding": "utf-8", "priority": 0}, m) self.assertDictContainsSubset({"delivery_mode": 2}, m["properties"]) self.assertEqual(exc, p.exchange.name) self.assertEqual(rkey, "process")
def enable(self): self.publisher = Producer(self.channel or self.connection, exchange=self.get_exchange(), serializer=self.serializer) self.enabled = True for callback in self.on_enabled: callback()
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 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')
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_produce_consume_noack(self): channel = self.c.channel() producer = Producer(channel, self.e) consumer = Consumer(channel, self.q, no_ack=True) for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_memory") _received = [] def callback(message_data, message): _received.append(message) consumer.register_callback(callback) consumer.consume() while 1: if len(_received) == 10: break self.c.drain_events() self.assertEqual(len(_received), 10)
def run(self): amqhost = self.config_parser.get(self.section,'amqhost') amqport = int(self.config_parser.get(self.section,'amqport')) amquser = self.config_parser.get(self.section,'amquser') amqpass = self.config_parser.get(self.section,'amqpass') amqvhost = self.config_parser.get(self.section,'amqvhost') amqexchange = self.config_parser.get(self.section,'amqexchange') routing_key = self.config_parser.get(self.section,'routing_key') connection = BrokerConnection(hostname=amqhost, port=amqport, userid=amquser, password=amqpass, virtual_host=amqvhost) channel = connection.channel() exchange = Exchange(amqexchange,'topic',turable=True) producer = Producer(channel,exchange=exchange, routing_key=routing_key) global entire_history entire_history = self.config_parser.get(self.section,'entire_history') for job in jobs(): if job['type']=='start': job['completion_time']+=job['walltime'] producer.revive(channel) producer.publish(job) logging.debug(`job`)
def test_publish__consume(self): connection = Connection(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) with self.assertRaises(socket.timeout): connection.drain_events(timeout=0.01) finally: channel.close()
def handle(self, *args, **options): routing_key = options["routing_key"] connection_url = options["connection_url"] userid = urlparse(connection_url).username payload_file = options["payload_file"] exchange_name = "exchange/{}/jobs".format(userid) connection = Connection(connection_url) exchange = Exchange(exchange_name, type="topic") producer = Producer(connection, exchange, routing_key=routing_key, auto_declare=True) self.stdout.write("Published to exchange: {}".format(exchange_name)) with open(payload_file) as f: body = f.read() try: producer.publish(body) finally: connection.release()
class EventDispatcher(object): """Send events as messages. :param connection: Connection to the broker. :keyword hostname: Hostname to identify ourselves as, by default uses the hostname returned by :func:`socket.gethostname`. :keyword enabled: Set to :const:`False` to not actually publish any events, making :meth:`send` a noop operation. :keyword channel: Can be used instead of `connection` to specify an exact channel to use when sending events. :keyword buffer_while_offline: If enabled events will be buffered while the connection is down. :meth:`flush` must be called as soon as the connection is re-established. You need to :meth:`close` this after use. """ def __init__(self, connection=None, hostname=None, enabled=True, channel=None, buffer_while_offline=True, app=None, serializer=None): self.app = app_or_default(app) self.connection = connection self.channel = channel self.hostname = hostname or socket.gethostname() self.buffer_while_offline = buffer_while_offline self.mutex = threading.Lock() self.publisher = None self._outbound_buffer = deque() self.serializer = serializer or self.app.conf.CELERY_EVENT_SERIALIZER self.on_enabled = set() self.on_disabled = set() self.enabled = enabled if not connection and channel: self.connection = channel.connection.client if self.enabled: self.enable() def __enter__(self): return self def __exit__(self, *exc_info): self.close() def get_exchange(self): if self.connection: return get_exchange(self.connection) else: return get_exchange(self.channel.connection.client) def enable(self): self.publisher = Producer(self.channel or self.connection, exchange=self.get_exchange(), serializer=self.serializer) self.enabled = True for callback in self.on_enabled: callback() def disable(self): if self.enabled: self.enabled = False self.close() for callback in self.on_disabled: callback() def send(self, type, **fields): """Send event. :param type: Kind of event. :keyword \*\*fields: Event arguments. """ if self.enabled: with self.mutex: event = Event(type, hostname=self.hostname, clock=self.app.clock.forward(), **fields) try: self.publisher.publish(event, routing_key=type.replace("-", ".")) except Exception, exc: if not self.buffer_while_offline: raise self._outbound_buffer.append((type, fields, exc))