def test_drain_nowait(self): c = Connection(transport=Mock) c.drain_events = Mock() c.drain_events.side_effect = socket.timeout() c.more_to_read = True self.assertFalse(c.drain_nowait()) self.assertFalse(c.more_to_read) c.drain_events.side_effect = socket.error() c.drain_events.side_effect.errno = errno.EAGAIN c.more_to_read = True self.assertFalse(c.drain_nowait()) self.assertFalse(c.more_to_read) c.drain_events.side_effect = socket.error() c.drain_events.side_effect.errno = errno.EPERM with self.assertRaises(socket.error): c.drain_nowait() c.more_to_read = False c.drain_events = Mock() self.assertTrue(c.drain_nowait()) c.drain_events.assert_called_with(timeout=0) self.assertTrue(c.more_to_read)
class KombuConsumer( AbstractConsumer, ): """ 使用kombu作为中间件,这个能直接一次性支持很多种小众中间件,但性能很差,除非是分布式函数调度框架没实现的中间件种类用户才可以用这种,用户也可以自己对比性能。 """ BROKER_KIND = 15 def custom_init(self): self._middware_name = frame_config.KOMBU_URL.split(":")[0] logger_name = f'{self._logger_prefix}{self.__class__.__name__}--{self._middware_name}--{self._queue_name}' self.logger = LogManager(logger_name).get_logger_and_add_handlers( self._log_level, log_filename=f'{logger_name}.log' if self._create_logger_file else None, formatter_template=frame_config. NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER, ) # patch_kombu_redis() # noinspection DuplicatedCode def _shedual_task(self): # 这个倍while 1 启动的,会自动重连。 def callback(body: dict, message: kombu.transport.virtual.base.Message): # print(type(body),body,type(message),message) self._print_message_get_from_broker('kombu', body) # self.logger.debug(f""" 从 kombu {self._middware_name} 中取出的消息是 {body}""") kw = { 'body': body, 'message': message, } self._submit_task(kw) self.exchange = Exchange('distributed_framework_exchange', 'direct', durable=True) self.queue = Queue(self._queue_name, exchange=self.exchange, routing_key=self._queue_name, auto_delete=False) self.conn = Connection(frame_config.KOMBU_URL, transport_options={"visibility_timeout": 600}) # 默认3600秒unacked重回队列 self.queue(self.conn).declare() with self.conn.Consumer(self.queue, callbacks=[callback], no_ack=False, prefetch_count=100) as consumer: # Process messages and handle events on all channels channel = consumer.channel # type:Channel channel.body_encoding = 'no_encode' # 这里改了编码,存到中间件的参数默认把消息base64了,我觉得没必要不方便查看消息明文。 while True: self.conn.drain_events() def _confirm_consume(self, kw): pass # redis没有确认消费的功能。 kw['message'].ack() def _requeue(self, kw): kw['message'].requeue()
def run_pulse_listener(username, password, timeout, no_send): """Run a Pulse message queue listener.""" connection = Connection( hostname='pulse.mozilla.org', port=5671, ssl=True, userid=username, password=password, ) # Connect and pass in our own low value for retries so the connection # fails fast if there is a problem. connection.ensure_connection( max_retries=1 ) # Retries must be >=1 or it will retry forever. with closing(connection): hgpush_exchange = Exchange(config.PULSE_EXCHANGE, 'topic', channel=connection) # Pulse queue names need to be prefixed with the username queue_name = f'queue/{username}/{config.PULSE_QUEUE_NAME}' queue = Queue( queue_name, exchange=hgpush_exchange, routing_key=config.PULSE_QUEUE_ROUTING_KEY, durable=True, exclusive=False, auto_delete=False, channel=connection, ) # Passing passive=True will assert that the exchange exists but won't # try to declare it. The Pulse server forbids declaring exchanges. hgpush_exchange.declare(passive=True) # Queue.declare() also declares the exchange, which isn't allowed by # the Pulse server. Use the low-level Queue API to only declare the # queue itself. queue.queue_declare() queue.queue_bind() callback = partial(process_push_message, no_send=no_send) # Pass auto_declare=False so that Consumer does not try to declare the # exchange. Declaring exchanges is not allowed by the Pulse server. with connection.Consumer( queue, callbacks=[callback], auto_declare=False ) as consumer: if no_send: log.info('transmission of ping data has been disabled') log.info('message acks has been disabled') log.info('reading messages') try: connection.drain_events(timeout=timeout) except socket.timeout: log.info('message queue is empty, nothing to do') log.info('done')
def run(self): connection = Connection(**connection_params) channel = connection.channel() channel.basic_qos(prefetch_size=0, prefetch_count=1, a_global=True) while True: with Consumer(channel, queues, callbacks=[self.on_message]): connection.drain_events()
def consumer(): rabbit_url = "amqp://localhost:5672/" conn = Connection(rabbit_url) exchange = Exchange("scrapy", type="direct") queue = Queue(name="quotation", exchange=exchange, routing_key="quotes") with Consumer(conn, queues=queue, callbacks=[process_message], accept=["json"]): conn.drain_events(timeout=2) return "consumed successfully"
class _AMQPServerWrapper(object): def __init__(self, amqp_url, logs): self.__logs = logs self.__amqp_url = amqp_url self.__monitors = {} self.__connection = Connection(self.__amqp_url) self.__connection.connect() self.__running = True self.__consumer_gl = gevent.spawn(self.__consumer_greenlet_main) self.__consumer_gl.greenlet_name = 'amqp-consumer-gl' # allowing flogging to print a nice name gevent.sleep(0.0) def __consumer_greenlet_main(self): gevent.sleep(0) while self.__running: try: self.__connection.drain_events(timeout=0.5) except Exception as ex: # NOQA: assigned but not used (left in for super-duper-low-level-debug) # print("was woken because {}".format(ex)) pass gevent.sleep(0.1) # make -sure- to yield cpu... # print("---loop") def stop_greenlet(self): self.__running = False @property def connected(self): return self.__connection.connected def create_add_tracker(self, exchange, routing_key, event_cb, queue_name=None): self.__logs.irl.debug("AMQPServerWrapper: create_add_tracker ex=%s, rk=%s, event_cb=%s", exchange, routing_key, event_cb) mon = _KeyedConsumerHandler.get_keyed_consumer( self.__logs, self.__connection, exchange, routing_key, queue_name, event_cb) return mon.exchange def inject(self, exchange, routing_key, payload): self.__logs.irl.debug("Injecting a test AMQP message: ex=%s, rk=%s, payload=%s", exchange, routing_key, payload) if not isinstance(exchange, Exchange): exchange = Exchange(exchange, 'topic') prod = Producer(self.__connection, exchange=exchange, routing_key=routing_key) prod.publish(payload) def test_helper_sync_send_msg(self, exchange, ex_rk, send_rk, payload): ex = Exchange(exchange, 'topic') queue = Queue(exchange=ex, routing_key=ex_rk + '.*', exclusive=True, channel=self.__connection) queue.declare() prod = Producer(self.__connection, exchange=ex, routing_key=send_rk) prod.publish(payload) return queue def test_helper_sync_recv_msg(self, queue): for tick in range(10): msg = queue.get() if msg is not None: break return msg
def worker(mq_url): connection = Connection(mq_url) channel = connection.channel() consumer_json = Consumer(channel, task_json_queue, callbacks=[process_json], accept=["json"]) consumer_json.consume() consumer_pickle = Consumer(channel, task_pickle_queue, callbacks=[process_pickle], accept=["pickle"]) consumer_pickle.consume() while True: connection.drain_events()
class ClientMQ(object): connection = None nodeName = None callback = None def __init__(self, host, vhost, username, password, nodeName, callback): self.init_connect(host, vhost, username, password) self.nodeName = nodeName self.callback = callback self.queue = ThreadQueue() self.produder = ClientProducer(self.connection, 'HOST') self.initRecv() self.startThread() def init_connect(self, host, vhost, username, password): self.connection = Connection(hostname=host, virtual_host=vhost, userid=username, password=password) def initRecv(self): self.consumer = ClientConsumer(self.connection, self.nodeName, self.callback) while not self.consumer.init(): time.sleep(1) def start_consume(): while True: self.connection.drain_events() t = Thread(target=start_consume) t.start() def startThread(self): def start_produce(): while True: try: msg = self.queue.get() while not self.produder.publish(message=msg): time.sleep(1) except Exception as e: logger.exception(e) t = Thread(target=start_produce) t.start() def is_open(self): if self.connection: return self.connection.connected else: return False def update_bean(self, cls_name, content): msg = '1' + to_unicode(cls_name) + ':' + to_unicode(content) self.queue.put(msg) def delete_bean(self, cls_name, ids): msg = '0' + to_unicode(cls_name) + ':' + to_unicode(ids) self.queue.put(msg)
class DBwriter: def __init__(self, broker_cloud, host_influxdb): self.clientDB = InfluxDBClient(host_influxdb, 8086, 'root', 'root', 'Collector_DB') self.clientDB.create_database('Collector_DB') self.consumer_connection = Connection(broker_cloud) self.exchange = Exchange("IoT", type="direct") def write_db(self, data_points): print(len(data_points)) for point in data_points: record = [{ 'measurement': point['MetricId'], 'tags': { 'DataType': point['DataType'], }, 'fields': { 'Value': point['Value'], }, 'time': point['TimeCollect'] }] try: self.clientDB.write_points(record) print(datetime.now().strftime('%Y-%m-%d %H:%M:%S') + ': Updated Database') except: print("Can't write to database : {}".format(point['MetricId'])) print("Delete mesurement....") self.clientDB.drop_measurement(measurement=point['MetricId']) def api_write_db(self, body, message): data_points = json.loads(body)['body']['data_points'] self.write_db(data_points) def run(self): queue_write_db = Queue(name='dbwriter.request.api_write_db', exchange=self.exchange, routing_key='dbwriter.request.api_write_db', message_ttl=20) while 1: try: self.consumer_connection.ensure_connection(max_retries=1) with Consumer(self.consumer_connection, queues=queue_write_db, callbacks=[self.api_write_db], no_ack=True): while True: self.consumer_connection.drain_events() except (ConnectionRefusedError, exceptions.OperationalError): print('Connection lost') except self.consumer_connection.connection_errors: print('Connection error')
def listen(self): logger.debug('AutophonePulseMonitor: start shared_lock.acquire') connection = None restart = True while restart: restart = False self.shared_lock.acquire() try: # connection does not connect to the server until # either the connection.connect() method is called # explicitly or until kombu calls it implicitly as # needed. connection = Connection(hostname=self.hostname, userid=self.userid, password=self.password, virtual_host=self.virtual_host, port=DEFAULT_SSL_PORT, ssl=True) consumer = connection.Consumer(self.queues, callbacks=[self.handle_message], accept=['json'], auto_declare=False) for queue in self.queues: queue(connection).queue_declare(passive=False) queue(connection).queue_bind() with consumer: while not self._stopping.is_set(): try: logger.debug('AutophonePulseMonitor shared_lock.release') self.shared_lock.release() connection.drain_events(timeout=self.timeout) except socket.timeout: pass except KeyboardInterrupt: raise finally: logger.debug('AutophonePulseMonitor shared_lock.acquire') self.shared_lock.acquire() logger.debug('AutophonePulseMonitor.listen: stopping') except: logger.exception('AutophonePulseMonitor Exception') if connection: connection.release() restart = True time.sleep(1) finally: logger.debug('AutophonePulseMonitor exit shared_lock.release') if connection and not restart: connection.release() self.shared_lock.release()
def test_accept__content_disallowed(self): conn = Connection('memory://') q = Queue('foo', exchange=self.exchange) p = conn.Producer() p.publish( {'complex': object()}, declare=[q], exchange=self.exchange, serializer='pickle', ) callback = Mock(name='callback') with conn.Consumer(queues=[q], callbacks=[callback]) as consumer: with self.assertRaises(consumer.ContentDisallowed): conn.drain_events(timeout=1) self.assertFalse(callback.called)
def test_accept__content_disallowed(self): conn = Connection('memory://') q = Queue('foo', exchange=self.exchange) p = conn.Producer() p.publish( {'complex': object()}, declare=[q], exchange=self.exchange, serializer='pickle', ) callback = Mock(name='callback') with conn.Consumer(queues=[q], callbacks=[callback]) as consumer: with self.assertRaises(consumer.ContentDisallowed): conn.drain_events(timeout=1) callback.assert_not_called()
def worker(mq_url): connection = Connection(mq_url) channel = connection.channel() consumer_json = Consumer(channel, task_json_queue, callbacks=[process_json], accept=['json']) consumer_json.consume() consumer_pickle = Consumer(channel, task_pickle_queue, callbacks=[process_pickle], accept=['pickle']) consumer_pickle.consume() while True: connection.drain_events()
def run(self): try: connection = Connection(hostname=self.host,port=self.port,userid=self.usr,password=self.psw,virtual_host=self.virtual_host) channel = connection.channel() self.producer=Producer(channel) task_queue = Queue(self.queue_name,durable=True) consumer = Consumer(channel,task_queue,no_ack=False) consumer.qos(prefetch_count=1) consumer.register_callback(self.RequestCallBack) consumer.consume() while True: connection.drain_events() connection.close() except BaseException,e: print e
def test_accept__content_allowed(self): conn = Connection('memory://') q = Queue('foo', exchange=self.exchange) p = conn.Producer() p.publish( {'complex': object()}, declare=[q], exchange=self.exchange, serializer='pickle', ) callback = Mock(name='callback') with conn.Consumer(queues=[q], accept=['pickle'], callbacks=[callback]): conn.drain_events(timeout=1) callback.assert_called() body, message = callback.call_args[0] self.assertTrue(body['complex'])
def test_accept__content_allowed(self): conn = Connection('memory://') q = Queue('foo', exchange=self.exchange) p = conn.Producer() p.publish( {'complex': object()}, declare=[q], exchange=self.exchange, serializer='pickle', ) callback = Mock(name='callback') with conn.Consumer(queues=[q], accept=['pickle'], callbacks=[callback]): conn.drain_events(timeout=1) self.assertTrue(callback.called) body, message = callback.call_args[0] self.assertTrue(body['complex'])
class Consumer: def __init__(self, queue): self.conn = Connection('amqp://*****:*****@rabbit:5672//') self.task_queue = Queue(queue, routing_key=queue) def start_consumer(self): consumer = Consumer(self.conn, [self.task_queue], callbacks=[self.process_message]) consumer.consume() self.conn.drain_events() @staticmethod def process_message(body, message): print(body['message']['Value'], flush=True) message.ack()
def consumer(): rabbit_host = "amqp://{host}:5672/".format(host=sys.argv[1]) print("Connection to {host}".format(host=rabbit_host)) # Create the connection conn = Connection(rabbit_host) # Create the exchange test_exchange = Exchange("test_exchange", type="direct") # Create the queue queue = Queue(name="queue", exchange=test_exchange, routing_key="test") # Create the consumer with Consumer(conn, queues=queue, callbacks=[process_message], accept=["text/plain"]): conn.drain_events()
def start(self): log.info("Listening for Pulse messages") self.running = True connection = Connection( hostname=self.pulse_host, userid=self.pulse_user, password=self.pulse_password, ssl=True, # Kombu doesn't support the port correctly for amqp with ssl... port=5671, ) consumers = [] for event in self.events: log.debug("Setting up queue on exchange: %s with routing_key: %s", event.exchange, event.routing_key) # Passive exchanges must be used, otherwise kombu will try to # create the exchange (which we don't want, we're consuming # an existing one!) e = Exchange(name=event.exchange, type="topic", passive=True) q = Queue( name=event.queue_name, exchange=e, routing_key=event.routing_key, durable=True, exclusive=False, auto_delete=False ) c = connection.Consumer( queues=[q], callbacks=[event.callback] ) c.consume() consumers.append(c) try: # XXX: drain_events only returns after receiving a message. Is # there a way we can have it return regularly to be non-blocking? # Its timeout parameter seems to break receiving of messages. # Maybe it doesn't matter if we can't shut down gracefully since # messages will be reprocessed next time. while self.running: connection.drain_events() finally: for c in consumers: c.close() connection.close()
class Amqp(object): def __init__(self, url, exchange, queue, routing_key): self.conn = Connection(url) self.exchange = Exchange(exchange, 'direct') self.routing_key = routing_key self.queue = Queue(queue, self.exchange, self.routing_key) self.producer = None self.consumer = None def send(self, obj): if not self.producer: self.producer = self.conn.Producer() self.producer.publish(obj, exchange=self.exchange, routing_key=self.routing_key, declare=[self.queue], serializer='json', compression='zlib') def poll(self, cb_func): if not self.consumer: self.consumer = self.conn.Consumer(self.queue, callbacks=[cb_func]) self.consumer.qos(prefetch_count=1) self.consumer.consume() while True: self.conn.drain_events() def _release(self): if self.consumer: self.consumer.close() self.consumer = None if self.producer: self.producer.close() self.producer = None if self.conn: self.conn.release() self.conn = None def __enter__(self): return self def __exit__(self, exec_type, exc_value, traceback): self._release()
class Actor_1(Actor_Base): def __init__(self, actor_name, actor_id): Actor_Base.__init__(self, actor_name, actor_id) BROKER_CLOUD = "localhost" self.producer_connection = Connection(BROKER_CLOUD) self.consumer_connection = Connection(BROKER_CLOUD) self.exchange = Exchange("IoT", type="direct") self.queue_get_states = Queue(name='event_generator.to.' + str(self.actor_id), exchange=self.exchange, routing_key='event_generator.to.' + str(self.actor_id)) #, message_ttl=20) self.db = MySQLdb.connect(host="0.0.0.0", user="******", passwd="root") self.cursor = self.db.cursor() def execute(self, action_type, action_id): pass def receiveCallToAction(self): def handle_notification(body, message): print("Receive Event!") action_id = json.loads(body)["action_id"] action_name = json.loads(body)["action_name"] action_type = json.loads(body)["action_type"] self.execute(action_type, action_id) print("Executed action: ", action_id) # End handle_notification try: self.consumer_connection.ensure_connection(max_retries=1) with nested( Consumer(self.consumer_connection, queues=self.queue_get_states, callbacks=[handle_notification], no_ack=True)): while True: self.consumer_connection.drain_events() except (ConnectionRefusedError, exceptions.OperationalError): print('Connection lost') except self.consumer_connection.connection_errors: print('Connection error')
def run(self): connection = Connection(hostname=self.host,port=self.port,userid=self.usr,password=self.psw,virtual_host=self.virtual_host) channel = connection.channel() self.producer=Producer(channel) queueargs={} if self.msg_timeout: queueargs['x-message-ttl']=self.msg_timeout task_queue = Queue(self.queue_name,durable=True,queue_arguments=queueargs if queueargs else None) consumer = Consumer(channel,task_queue,no_ack=False) consumer.qos(prefetch_count=1) consumer.register_callback(self.RequestCallBack) consumer.consume() while self.task_count: connection.drain_events() self.task_count-=1 connection.close()
def run(self): try: connection = Connection(hostname=self.host, port=self.port, userid=self.usr, password=self.psw, virtual_host=self.virtual_host) channel = connection.channel() self.producer = Producer(channel) task_queue = Queue(self.queue_name, durable=True) consumer = Consumer(channel, task_queue, no_ack=False) consumer.qos(prefetch_count=1) consumer.register_callback(self.RequestCallBack) consumer.consume() while True: connection.drain_events() connection.close() except BaseException, e: print e
def heartbeat_check(): print("Heartbeat check") rabbit_host = "amqp://{host}:5672/".format(host=sys.argv[1]) print("Connection to {host}".format(host=rabbit_host)) # Create the connection conn = Connection(rabbit_host) # Create the exchange test_exchange = Exchange("test_exchange", type="direct") # Create the queue queue = Queue(name="queue", exchange=test_exchange, routing_key="test") while True: print("hb ping") conn.heartbeat_check(rate=5) conn.drain_events(timeout=0.01) print("hb pong") time.sleep(10)
def listen(self): logger = utils.getLogger() connect_timeout = 5 wait = 30 connection = None restart = True while restart: restart = False try: # connection does not connect to the server until # either the connection.connect() method is called # explicitly or until kombu calls it implicitly as # needed. logger.debug('AutophonePulseMonitor: Connection()') connection = Connection(hostname=self.hostname, userid=self.userid, password=self.password, virtual_host=self.virtual_host, port=DEFAULT_SSL_PORT, ssl=True, connect_timeout=connect_timeout) logger.debug('AutophonePulseMonitor: connection.Consumer()') consumer = connection.Consumer(self.queues, callbacks=[self.handle_message], accept=['json'], auto_declare=False) logger.debug('AutophonePulseMonitor: bind queues') for queue in self.queues: queue(connection).queue_declare(passive=False) queue(connection).queue_bind() with consumer: while not self._stopping.is_set(): try: connection.drain_events(timeout=self.timeout) except socket.timeout: pass except socket.error, e: if "timed out" not in str(e): raise logger.debug('AutophonePulseMonitor.listen: stopping') except:
def run(rabbit_url): print rabbit_url conn = Connection(rabbit_url) conn.ensure_connection() conn.connect() exchange = Exchange(config.EXCHANGE_NAME, type='direct') queue = Queue(name=config.QUEUE_NAME, exchange=exchange, routing_key=config.ROUTING_KEY) consumer = Consumer(conn, queues=queue, callbacks=[process_message], accept=['text/plain']) consumer.consume() while True: try: print 'drain_events' conn.drain_events(timeout=2) # timeout except socket.timeout: pass
class RpcProxy(object): def __init__(self, amqp_url): self.connection = Connection(amqp_url) self.callback_queue = Queue(uuid(), exclusive=True, auto_delete=True) def on_response(self, message): if message.properties['correlation_id'] == self.correlation_id: result = message.payload ret = pickle.loads(result) if isinstance(ret, Exception): raise ret else: self.response = ret def __getattr__(self, name): def do_rpc(*args, **kwargs): self.response = None self.correlation_id = uuid() with Producer(self.connection) as producer: producer.publish( pickle.dumps((name, args, kwargs)), exchange='', routing_key=settings.RPC_QUEUE, declare=[self.callback_queue], reply_to=self.callback_queue.name, correlation_id=self.correlation_id, ) with Consumer(self.connection, on_message=self.on_response, queues=[self.callback_queue], no_ack=True, accept=['json', 'pickle', 'msgpack']): while self.response is None: self.connection.drain_events() return self.response return do_rpc
class NlpPipe: def __init__(self, conn_str='amqp://*****:*****@localhost/'): self.conn_str = conn_str self.conn = Connection(conn_str) self.callback_queue = Queue(str(uuid()), exclusive=True, auto_delete=True) def on_response(self, message): if message.properties['correlation_id'] == self.correlation_id: res = message.payload if isinstance(res, str): res = json.loads(res) self.response = res def process(self, data, steps): self.response = None self.correlation_id = uuid() logger.info('publish queue={} next={} reply_to={}'.format(steps[0], steps[1:] or None, self.callback_queue.name)) with Producer(self.conn) as producer: producer.publish( data, exchange='', routing_key=steps[0], # headers={'next': json.loads(json.dumps(steps[1:]))}, # headers={'next': ('aa', 'bbb')}, # headers={'next': json.dumps(['aa', 'bbb'])}, headers={'next': '|'.join(steps[1:])}, declare=[self.callback_queue], reply_to=self.callback_queue.name, correlation_id=self.correlation_id, ) with Consumer(self.conn, on_message=self.on_response, queues=[self.callback_queue], no_ack=True): while self.response is None: self.conn.drain_events() logger.info("Response {}".format(self.response)) return self.response
class FibonacciRpcClient(object): def __init__(self): self.connection = Connection('amqp://localhost//') self.channel = self.connection.channel() self.response_queue = self.channel.queue_declare(exclusive=True) self.channel.basic_consume( queue=self.response_queue.queue, callback=self.on_response, no_ack=True) def on_response(self, response): '''consume callback''' correlation_id = response.properties['correlation_id'] if correlation_id == self.corr_id: self.response = response.body def call(self, n): #ipdb.set_trace() self.response = None self.corr_id = str(uuid.uuid4()) producer = Producer(self.connection) producer.publish( str(n), exchange='', routing_key='rpc_queue', reply_to=self.response_queue.queue, correlation_id=self.corr_id) # FIXME(Ray): if we use pika this should be # self.connection.process_data_events() # But in kombu I can not find one for this if self.response is None: self.connection.drain_events() return int(self.response)
def test_publish__consume(self): connection = Connection(transport=Transport) channel = connection.channel() producer = Producer(channel, self.exchange, routing_key='test_Redis') consumer = Consumer(channel, queues=[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 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()
class RabbitmqDaemon(threading.Thread): def __init__(self, cmd_q=None, reply_q=None): threading.Thread.__init__(self) self.settings = ConfigParser.ConfigParser() self.settings.read('../config/site.ini') self.rabbitmqUsername = self.settings.get('rabbitmq', 'username') self.rabbitmqPassword = self.settings.get('rabbitmq', 'password') self.rabbitmqHost = self.settings.get('rabbitmq', 'host') self.conn = Connection('amqp://'+self.rabbitmqUsername+':'+self.rabbitmqPassword+'@'+self.rabbitmqHost+':5672//') self.producer = Producer(self.conn.channel(), exchange = Exchange('eyezon.status', type='fanout'), serializer="json") self.rpcProducer= Producer(self.conn.channel(), serializer="json") self.cmd_q = cmd_q or Queue.Queue() self.reply_q = reply_q or Queue.Queue() queue = kombu.Queue( name="eyezon.cmd", exchange=Exchange('eyezon.cmd'), channel=self.conn.channel(), durable=False, exclusive=False, auto_delete=True) self.consumer = Consumer(self.conn.channel(), queues = queue, auto_declare=True, callbacks=[self.send_cmd]) self.consumer.consume(no_ack=True) self.alarmCache = { "zoneTimerDump": None, "keypadUpdate": None, "zoneStateChange": None, "partitionStateChange": None, "realtimeCIDEvent": None, "zoneTimerDump": None } def send_cmd(self, message, req): msg = message.encode('utf-8') if msg == "^02,$" and self.alarmCache['zoneTimerDump'] != None: self.rpcReply(self.alarmCache['zoneTimerDump'], req) elif msg == "getKeypadStatus" and self.alarmCache['keypadUpdate'] != None: self.rpcReply(self.alarmCache['keypadUpdate'], req) if msg != "getKeypadStatus": self.cmd_q.put(msg) def rpcReply(self, message, req): self.rpcProducer.publish(body=message, **dict({'routing_key': req.properties['reply_to'], 'correlation_id': req.properties.get('correlation_id'), 'content_encoding': req.content_encoding})) def publishEvent(self, event): if event['name'] == "Zone Timer Dump": self.alarmCache["zoneTimerDump"] = event elif event['name'] == "Virtual Keypad Update": self.alarmCache["keypadUpdate"] = event elif event['name'] == "Zone State Change": self.alarmCache["zoneStateChange"] = event elif event['name'] == "Partition State Change": self.alarmCache["partitionStateChange"] = event elif event['name'] == "Realtime CID Event": self.alarmCache["realtimeCIDEvent"] = event elif event['name'] == "Zone Timer Dump": self.alarmCache["zoneTimerDump"] = event self.producer.publish(exchange = 'eyezon.status', routing_key = "", body = event) def run(self): while 1: try: cmd = self.reply_q.get(True, 0.1) self.publishEvent(cmd) except Queue.Empty as e: try: self.conn.drain_events(timeout=0.1) except socket.timeout: None
class test_FilesystemTransport: def setup(self): self.channels = set() try: data_folder_in = tempfile.mkdtemp() data_folder_out = tempfile.mkdtemp() except Exception: raise SkipTest('filesystem transport: cannot create tempfiles') self.c = Connection(transport='filesystem', transport_options={ 'data_folder_in': data_folder_in, 'data_folder_out': data_folder_out, }) self.channels.add(self.c.default_channel) self.p = Connection(transport='filesystem', transport_options={ 'data_folder_in': data_folder_out, 'data_folder_out': data_folder_in, }) self.channels.add(self.p.default_channel) self.e = Exchange('test_transport_filesystem') self.q = Queue('test_transport_filesystem', exchange=self.e, routing_key='test_transport_filesystem') self.q2 = Queue('test_transport_filesystem2', exchange=self.e, routing_key='test_transport_filesystem2') def teardown(self): # make sure we don't attempt to restore messages at shutdown. for channel in self.channels: try: channel._qos._dirty.clear() except AttributeError: pass try: channel._qos._delivered.clear() except AttributeError: pass def _add_channel(self, channel): self.channels.add(channel) return channel def test_produce_consume_noack(self): producer = Producer(self._add_channel(self.p.channel()), self.e) consumer = Consumer(self._add_channel(self.c.channel()), self.q, no_ack=True) for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') _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() assert len(_received) == 10 def test_produce_consume(self): producer_channel = self._add_channel(self.p.channel()) consumer_channel = self._add_channel(self.c.channel()) producer = Producer(producer_channel, self.e) consumer1 = Consumer(consumer_channel, self.q) consumer2 = Consumer(consumer_channel, self.q2) self.q2(consumer_channel).declare() for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem2') _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() assert len(_received1) + len(_received2) == 20 # compression producer.publish({'compressed': True}, routing_key='test_transport_filesystem', compression='zlib') m = self.q(consumer_channel).get() assert m.payload == {'compressed': True} # queue.delete for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') assert self.q(consumer_channel).get() self.q(consumer_channel).delete() self.q(consumer_channel).declare() assert self.q(consumer_channel).get() is None # queue.purge for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem2') assert self.q2(consumer_channel).get() self.q2(consumer_channel).purge() assert self.q2(consumer_channel).get() is None
class test_FilesystemTransport(TestCase): def setUp(self): try: data_folder_in = tempfile.mkdtemp() data_folder_out = tempfile.mkdtemp() except Exception: raise SkipTest('filesystem transport: cannot create tempfiles') self.c = Connection(transport='filesystem', transport_options={ 'data_folder_in': data_folder_in, 'data_folder_out': data_folder_out, }) self.p = Connection(transport='filesystem', transport_options={ 'data_folder_in': data_folder_out, 'data_folder_out': data_folder_in, }) self.e = Exchange('test_transport_filesystem') self.q = Queue('test_transport_filesystem', exchange=self.e, routing_key='test_transport_filesystem') self.q2 = Queue('test_transport_filesystem2', exchange=self.e, routing_key='test_transport_filesystem2') def test_produce_consume_noack(self): producer = Producer(self.p.channel(), self.e) consumer = Consumer(self.c.channel(), self.q, no_ack=True) for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') _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 test_produce_consume(self): producer_channel = self.p.channel() consumer_channel = self.c.channel() producer = Producer(producer_channel, self.e) consumer1 = Consumer(consumer_channel, self.q) consumer2 = Consumer(consumer_channel, self.q2) self.q2(consumer_channel).declare() for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem2') _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_filesystem', compression='zlib') m = self.q(consumer_channel).get() self.assertDictEqual(m.payload, {'compressed': True}) # queue.delete for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') self.assertTrue(self.q(consumer_channel).get()) self.q(consumer_channel).delete() self.q(consumer_channel).declare() self.assertIsNone(self.q(consumer_channel).get()) # queue.purge for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem2') self.assertTrue(self.q2(consumer_channel).get()) self.q2(consumer_channel).purge() self.assertIsNone(self.q2(consumer_channel).get())
class AutophonePulseMonitor(object): """AutophonePulseMonitor provides the means to be notified when Android builds are available for testing and when users have initiated retriggers and cancels via the Treeherder UI. Builds can be selected using repository names, Android platform names or build types. AutophonePulseMonitor detects new builds by listening to un-normalized buildbot initiated pulse messages rather than the normalized messages in order to obtain the check-in comment for a build. The comment is used to determine if a try build has requested Autophone testing. :param hostname: Hostname of Pulse. Defaults to the production pulse server pulse.mozilla.org. :param userid: Pulse User id :param password: Pulse Password :param virtual_host: AMQP virtual host, defaults to '/'. :param durable_queues: If True, will create durable queues in Pulse for the build and job action messages. Defaults to False. In production, durable_queues should be set to True to avoid losing messages if the connection is broken or the application crashes. :param build_exchange_name: Name of build exchange. Defaults to 'exchange/build/'. :param build_queue_name: Build queue name suffix. Defaults to 'builds'. The pulse build queue will be created with a name of the form 'queue/<userid>/<build_queue_name>'. :param jobaction_exchange_name: Name of job action exchange. Defaults to 'exchange/treeherder/v1/job-actions'. Use 'exchange/treeherder-stage/v1/job-actions' to listen to job action messages for Treeherder staging. :param jobaction_queue_name: Job action queue name suffix. Defaults to 'jobactions'. The pulse jobaction queue will be created with a name of the form 'queue/<userid>/<jobaction_queue_name>'. :param build_callback: Required callback function which takes a single `build_data` object as argument containing information on matched builds. `build_callback` is always called on a new thread. `build_data` is an object which is guaranteed to contain the following keys: 'appName': Will always be 'Fennec' 'branch': The repository name of the build, e.g. 'mozilla-central'. 'comments': Check-in comment. 'packageUrl': The url to the apk package for the build. 'platform': The platform name of the build, e.g. 'android-api-11' `build_data` may also contain the following keys: 'buildid': Build id in CCYYMMDDHHMMSS format. 'robocopApkUrl': Url to robocop apk for the build. 'symbolsUrl': Url to the symbols zip file for the build. 'testsUrl': Url to the tests zip file for the build. 'who': Check-in Commiter. :param jobaction_callback: Required callback function which takes a single `jobaction_data` object as argument containing information on matched actions. `jobaction_callback` is always called on a new thread. `jobaction_data` is an object which is contains the following keys: 'action': 'cancel' or 'retrigger', 'project': repository name, 'job_id': treeherder job_id, 'job_guid': treeherder job_guid, 'build_type': 'opt' or 'debug', 'platform': the detected platform, 'build_url': build url, 'machine_name': name of machine , 'job_group_name': treeherder job group name, 'job_group_symbol': treeherder job group symbol, 'job_type_name': treeherder job type name, 'job_type_symbol': treeherder job type symbol, 'result': test result result', :param treeherder_url: Optional Treeherder server url if Treeherder job action pulse messages are to be processed. Defaults to None. :param trees: Required list of repository names to be matched. :param platforms: Required list of platforms to be matched. Currently, the possible values are 'android', 'android-api-9', 'android-api-10', 'android-api-11', and 'android-x86'. :param buildtypes: Required list of build types to process. Possible values are 'opt', 'debug' :param timeout: Timeout in seconds for the kombu connection drain_events. Defaults to 5 seconds. :param shared_lock: Required lock used to control concurrent access. Used to prevent socket based deadlocks. :param verbose: If True, will log build and job action messages. Defaults to False. Usage: :: import threading import time from optparse import OptionParser parser = OptionParser() def build_callback(build_data): logger = logging.getLogger() logger.debug('PULSE BUILD FOUND %s' % build_data) def jobaction_callback(job_action): logger = logging.getLogger() if job_action['job_group_name'] != 'Autophone': return logger.debug('JOB ACTION FOUND %s' % json.dumps( job_action, sort_keys=True, indent=4)) logging.basicConfig() logger = logging.getLogger() logger.setLevel(logging.DEBUG) parser.add_option('--pulse-user', action='store', type='string', dest='pulse_user', default='', help='user id for connecting to PulseGuardian') parser.add_option('--pulse-password', action='store', type='string', dest='pulse_password', default='', help='password for connecting to PulseGuardian') (options, args) = parser.parse_args() shared_lock = threading.Lock() monitor = AutophonePulseMonitor( userid=options.pulse_user, password=options.pulse_password, jobaction_exchange_name='exchange/treeherder-stage/v1/job-actions', build_callback=build_callback, jobaction_callback=jobaction_callback, trees=['try', 'mozilla-inbound'], platforms=['android-api-9', 'android-api-11'], buildtypes=['opt'], shared_lock=shared_lock) monitor.start() time.sleep(3600) """ def __init__(self, hostname='pulse.mozilla.org', userid=None, password=None, virtual_host='/', durable_queues=False, build_exchange_name='exchange/build/', build_queue_name='builds', jobaction_exchange_name='exchange/treeherder/v1/job-actions', jobaction_queue_name='jobactions', build_callback=None, jobaction_callback=None, treeherder_url=None, trees=[], platforms=[], buildtypes=[], timeout=5, shared_lock=None, verbose=False): assert userid, "userid is required." assert password, "password is required." assert build_callback, "build_callback is required." assert trees, "trees is required." assert platforms, "platforms is required." assert buildtypes, "buildtypes is required." assert shared_lock, "shared_lock is required." self.treeherder_url = treeherder_url self.build_callback = build_callback self.jobaction_callback = jobaction_callback self.trees = list(trees) self.platforms = list(platforms) # Sort the platforms in descending order of length, so we do # not make a match on a substring of the platform prematurely. self.platforms.sort(cmp=lambda x,y: (len(y) - len(x))) self.buildtypes = list(buildtypes) self.timeout = timeout self.shared_lock = shared_lock self.verbose = verbose self._stopping = threading.Event() self.listen_thread = None # connection does not connect to the server until either the # connection.connect() method is called explicitly or until # kombu calls it implicitly as needed. self.connection = Connection(hostname=hostname, userid=userid, password=password, virtual_host=virtual_host, port=DEFAULT_SSL_PORT, ssl=True) build_exchange = Exchange(name=build_exchange_name, type='topic') self.queues = [Queue(name='queue/%s/build' % userid, exchange=build_exchange, routing_key='build.#.finished', durable=durable_queues, auto_delete=not durable_queues)] if treeherder_url: jobaction_exchange = Exchange(name=jobaction_exchange_name, type='topic') self.queues.append(Queue(name='queue/%s/jobactions' % userid, exchange=jobaction_exchange, routing_key='#', durable=durable_queues, auto_delete=not durable_queues)) def start(self): """Runs the `listen` method on a new thread.""" if self.listen_thread and self.listen_thread.is_alive(): logger.warning('AutophonePulseMonitor.start: listen thread already started') return logger.debug('AutophonePulseMonitor.start: listen thread starting') self.listen_thread = threading.Thread(target=self.listen, name='PulseMonitorThread') self.listen_thread.daemon = True self.listen_thread.start() def stop(self): """Stops the pulse monitor listen thread.""" logger.debug('AutophonePulseMonitor stopping') self._stopping.set() self.listen_thread.join() logger.debug('AutophonePulseMonitor stopped') def is_alive(self): return self.listen_thread.is_alive() def listen(self): logger.debug('AutophonePulseMonitor: start shared_lock.acquire') self.shared_lock.acquire() try: consumer = self.connection.Consumer(self.queues, callbacks=[self.handle_message], accept=['json'], auto_declare=False) for queue in self.queues: queue(self.connection).queue_declare(passive=False) queue(self.connection).queue_bind() with consumer: while not self._stopping.is_set(): try: logger.debug('AutophonePulseMonitor shared_lock.release') self.shared_lock.release() self.connection.drain_events(timeout=self.timeout) except socket.timeout: pass except KeyboardInterrupt: raise finally: logger.debug('AutophonePulseMonitor shared_lock.acquire') self.shared_lock.acquire() logger.debug('AutophonePulseMonitor.listen: stopping') except: logger.exception('AutophonePulseMonitor Exception') finally: logger.debug('AutophonePulseMonitor exit shared_lock.release') self.shared_lock.release() self.connection.release() def handle_message(self, data, message): if self._stopping.is_set(): return message.ack() if '_meta' in data and 'payload' in data: self.handle_build(data, message) if (self.treeherder_url and 'action' in data and 'project' in data and 'job_id' in data): self.handle_jobaction(data, message) def handle_build(self, data, message): if self.verbose: logger.debug( 'handle_build:\n' '\tdata : %s\n' '\tmessage: %s' % ( json.dumps(data, sort_keys=True, indent=4), json.dumps(message.__dict__, sort_keys=True, indent=4))) try: build = data['payload']['build'] except (KeyError, TypeError), e: logger.debug('AutophonePulseMonitor.handle_build_event: %s pulse build data' % e) return fields = ( 'appName', # Fennec 'branch', 'buildid', 'comments', 'packageUrl', 'platform', 'robocopApkUrl', 'symbolsUrl', 'testsUrl', 'who' ) required_fields = ( 'appName', # Fennec 'branch', # mozilla-central, ... 'comments', 'packageUrl', 'platform', # android... ) build_data = {} builder_name = build['builderName'] build_data['builder_name'] = builder_name build_data['build_type'] = 'debug' if 'debug' in builder_name else 'opt' for property in build['properties']: property_name = property[0] if property_name in fields and len(property) > 1 and property[1]: build_data[property_name] = type(property[1])(property[1]) for required_field in required_fields: if required_field not in build_data or not build_data[required_field]: return if build_data['appName'] != 'Fennec': return if not build_data['platform'].startswith('android'): return if build_data['branch'] not in self.trees: return if build_data['platform'] not in self.platforms: return if build_data['build_type'] not in self.buildtypes: return if build_data['branch'] == 'try' and 'autophone' not in build_data['comments']: return self.build_callback(build_data)
class test_MemoryTransport(Case): def setup(self): self.c = Connection(transport='memory') self.e = Exchange('test_transport_memory') self.q = Queue('test_transport_memory', exchange=self.e, routing_key='test_transport_memory') self.q2 = Queue('test_transport_memory2', exchange=self.e, routing_key='test_transport_memory2') self.fanout = Exchange('test_transport_memory_fanout', type='fanout') self.q3 = Queue('test_transport_memory_fanout1', exchange=self.fanout) self.q4 = Queue('test_transport_memory_fanout2', exchange=self.fanout) def test_driver_version(self): self.assertTrue(self.c.transport.driver_version()) 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 test_produce_consume_fanout(self): producer = self.c.Producer() consumer = self.c.Consumer([self.q3, self.q4]) producer.publish( {'hello': 'world'}, declare=consumer.queues, exchange=self.fanout, ) self.assertEqual(self.q3(self.c).get().payload, {'hello': 'world'}) self.assertEqual(self.q4(self.c).get().payload, {'hello': 'world'}) self.assertIsNone(self.q3(self.c).get()) self.assertIsNone(self.q4(self.c).get()) 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_drain_events(self): with self.assertRaises(socket.timeout): self.c.drain_events(timeout=0.1) c1 = self.c.channel() c2 = self.c.channel() with self.assertRaises(socket.timeout): self.c.drain_events(timeout=0.1) del(c1) # so pyflakes doesn't complain. del(c2) def test_drain_events_unregistered_queue(self): c1 = self.c.channel() producer = self.c.Producer() consumer = self.c.Consumer([self.q2]) producer.publish( {'hello': 'world'}, declare=consumer.queues, routing_key=self.q2.routing_key, exchange=self.q2.exchange, ) message = consumer.queues[0].get()._raw class Cycle(object): def get(self, timeout=None): return (message, 'foo'), c1 self.c.transport.cycle = Cycle() self.c.drain_events() def test_queue_for(self): chan = self.c.channel() chan.queues.clear() x = chan._queue_for('foo') self.assertTrue(x) self.assertIs(chan._queue_for('foo'), x)
class test_FilesystemTransport(Case): def setUp(self): if sys.platform == "win32": raise SkipTest("Needs win32con module") try: data_folder_in = tempfile.mkdtemp() data_folder_out = tempfile.mkdtemp() except Exception: raise SkipTest("filesystem transport: cannot create tempfiles") self.c = Connection( transport="filesystem", transport_options={"data_folder_in": data_folder_in, "data_folder_out": data_folder_out}, ) self.p = Connection( transport="filesystem", transport_options={"data_folder_in": data_folder_out, "data_folder_out": data_folder_in}, ) self.e = Exchange("test_transport_filesystem") self.q = Queue("test_transport_filesystem", exchange=self.e, routing_key="test_transport_filesystem") self.q2 = Queue("test_transport_filesystem2", exchange=self.e, routing_key="test_transport_filesystem2") def test_produce_consume_noack(self): producer = Producer(self.p.channel(), self.e) consumer = Consumer(self.c.channel(), self.q, no_ack=True) for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_filesystem") _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 test_produce_consume(self): producer_channel = self.p.channel() consumer_channel = self.c.channel() producer = Producer(producer_channel, self.e) consumer1 = Consumer(consumer_channel, self.q) consumer2 = Consumer(consumer_channel, self.q2) self.q2(consumer_channel).declare() for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_filesystem") for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_filesystem2") _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_filesystem", compression="zlib") m = self.q(consumer_channel).get() self.assertDictEqual(m.payload, {"compressed": True}) # queue.delete for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_filesystem") self.assertTrue(self.q(consumer_channel).get()) self.q(consumer_channel).delete() self.q(consumer_channel).declare() self.assertIsNone(self.q(consumer_channel).get()) # queue.purge for i in range(10): producer.publish({"foo": i}, routing_key="test_transport_filesystem2") self.assertTrue(self.q2(consumer_channel).get()) self.q2(consumer_channel).purge() self.assertIsNone(self.q2(consumer_channel).get())
class test_FilesystemTransport(Case): def setup(self): try: data_folder_in = tempfile.mkdtemp() data_folder_out = tempfile.mkdtemp() except Exception: raise SkipTest('filesystem transport: cannot create tempfiles') self.c = Connection(transport='filesystem', transport_options={ 'data_folder_in': data_folder_in, 'data_folder_out': data_folder_out, }) self.p = Connection(transport='filesystem', transport_options={ 'data_folder_in': data_folder_out, 'data_folder_out': data_folder_in, }) self.e = Exchange('test_transport_filesystem') self.q = Queue('test_transport_filesystem', exchange=self.e, routing_key='test_transport_filesystem') self.q2 = Queue('test_transport_filesystem2', exchange=self.e, routing_key='test_transport_filesystem2') def test_produce_consume_noack(self): producer = Producer(self.p.channel(), self.e) consumer = Consumer(self.c.channel(), self.q, no_ack=True) for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') _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 test_produce_consume(self): producer_channel = self.p.channel() consumer_channel = self.c.channel() producer = Producer(producer_channel, self.e) consumer1 = Consumer(consumer_channel, self.q) consumer2 = Consumer(consumer_channel, self.q2) self.q2(consumer_channel).declare() for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem2') _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_filesystem', compression='zlib') m = self.q(consumer_channel).get() self.assertDictEqual(m.payload, {'compressed': True}) # queue.delete for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem') self.assertTrue(self.q(consumer_channel).get()) self.q(consumer_channel).delete() self.q(consumer_channel).declare() self.assertIsNone(self.q(consumer_channel).get()) # queue.purge for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_filesystem2') self.assertTrue(self.q2(consumer_channel).get()) self.q2(consumer_channel).purge() self.assertIsNone(self.q2(consumer_channel).get())
def do_consume(user_qs): print("about to listen no queues [%s]" % ", ".join(list(map(lambda x: x, user_qs)))) conn = Connection(amqp_hosts, failover_strategy='round-robin') # try to get a connection no matter what while True: try: conn.ensure_connection(errback=on_ens_conn_err_cb) conn.connect() except Exception as e: print("connection error failed on exception [%s]" % repr(e)) conn.release() continue if conn.connected: break else: print("connection failed in some way, retry") chan = conn.channel() global bound_cons_Q cons_Q = Queue(common.uuid(), queue_arguments=q_expires) bound_cons_Q = cons_Q(chan) bound_cons_Q.declare() # first bind to some control route bound_cons_Q.bind_to(priTopicXchg, routing_key='manage.#') for i in user_qs: if '*' in i or '#' in i: # create the wildcard route_key bind bound_cons_Q.bind_to(priTopicXchg, routing_key=i) else: for j in allQs: if i == j.as_dict()['name']: bound_cons_Q.bind_to(priTopicXchg, routing_key=j.as_dict()['routing_key']) cons = Consumer( chan, accept=['json'], queues=bound_cons_Q, callbacks=[on_msg_cb_1, on_msg_cb_2] ) print("queue set to [%s]" % bound_cons_Q.as_dict(recurse=True)) cons.consume() while True: try: conn.drain_events() except conn.connection_errors + conn.channel_errors as e: print("connection [%s] went down (error[%s]), trying to " "connect to the next one" % (conn.info(), repr(e))) conn.close() conn.release() conn.ensure_connection(errback=on_ens_conn_err_cb) conn.connect() chan = conn.channel() cons_Q.bind(chan) cons = Consumer( chan, accept=['json'], queues=bound_cons_Q, callbacks=[on_msg_cb_1, on_msg_cb_2] ) cons.consume()
result = supervisorConn.supervisor.stopAllProcesses() rpcReply(result, args) def task_restartall(message=None, args=None): result = supervisorConn.system.multicall([ {'methodName':'supervisor.stopAllProcesses'}, {'methodName':'supervisor.startAllProcesses'} ]) rpcReply(result, args) def on_request(body, req): message = json.loads(body) print "Received message ",message sys.stdout.flush() operations = { "list_processes" : list_processes, "task_start" : task_start, "task_stop" : task_stop, "task_restart" : task_restart, "read_log" : read_log } operations[message['operation']](message, req) #lets light this candle consumer = Consumer(rmqConn.channel(), queues = queue, auto_declare=True, callbacks=[on_request]) consumer.consume(no_ack=True) while True: rmqConn.drain_events()
#!/usr/bin/env python from kombu import Connection, Exchange, Queue def process_message(body, message): print body message.ack() nova_exchange = Exchange('nova', 'topic', durable=False) nova_queue = Queue('listener', exchange = nova_exchange, routing_key='#') conn = Connection('amqp://*****:*****@192.168.0.10//') consumer = conn.Consumer(nova_queue, callbacks=[process_message]) consumer.consume() while True: conn.drain_events()
class Dbreader: def __init__(self, broker_cloud, host_influxdb): self.clientDB = InfluxDBClient(host_influxdb, 8086, 'root', 'root', 'Collector_DB') self.clientDB.create_database('Collector_DB') self.producer_connection = Connection(broker_cloud) self.consumer_connection = Connection(broker_cloud) self.exchange = Exchange("IoT", type="direct") def get_item_state(sefl, list_item_global_id): items = [] for item_global_id in list_item_global_id: query_statement = 'SELECT * FROM \"' + item_global_id + '\" ORDER BY time DESC LIMIT 1 ' query_result = sefl.clientDB.query(query_statement) for item in query_result: item_state = { 'item_global_id': item[0]['item_global_id'], 'item_state': item[0]['item_state'], # 'last_changed': covert_time_to_correct_time_zone(item[0]['time']), 'last_changed': item[0]['time'], 'thing_global_id': item[0]['thing_global_id'] } items.append(item_state) return items def api_get_item_state(self, body, message): print("API get_item_state") # Message {'list_item_global_id': [], 'reply_to': " ", } list_item_global_id = json.loads(body)["list_item_global_id"] reply_to = json.loads(body)['reply_to'] items = self.get_item_state(list_item_global_id) message_response = { "items": items } self.producer_connection.ensure_connection() with Producer(self.producer_connection) as producer: producer.publish( json.dumps(message_response), exchange=self.exchange.name, routing_key=reply_to, retry=True ) # print("Done: {}".format(items)) def api_get_item_state_history(self, body, message): print("API get_item_state_history") # Message {'list_item_global_id': [], 'reply_to': " ", } list_global_id = json.loads(body)["list_global_id"] reply_to = json.loads(body)['reply_to'] start_time = json.loads(body)["start_time"] end_time = json.loads(body)["end_time"] scale = json.loads(body)["scale"] items = self.get_item_state_history(list_global_id, start_time, end_time, scale) message_response = { "items": items } self.producer_connection.ensure_connection() with Producer(self.producer_connection) as producer: producer.publish( json.dumps(message_response), exchange=self.exchange.name, routing_key=reply_to, retry=True ) def get_item_state_history(self, list_global_id, start_time, end_time, scale): items = [] print(scale) for global_id in list_global_id: item_global_id = global_id['item_global_id'] thing_global_id = global_id['thing_global_id'] query_statement_type_field = """SHOW FIELD KEYS ON \"Collector_DB\" FROM \"{}\"""".format(item_global_id) query_result_type_field = self.clientDB.query(query_statement_type_field) type_field = list(query_result_type_field.get_points())[0]['fieldType'] if scale == "0s": if type_field == 'integer' or type_field == 'float': query_statement_history = """SELECT * FROM \"{}\" where time >= \'{}\' AND time <= \'{}\'""".format(item_global_id, start_time, end_time) query_result_history = self.clientDB.query(query_statement_history) query_result_history = list(query_result_history.get_points()) query_statement_global = """SELECT MAX(\"item_state\") AS max_state, MIN(\"item_state\") AS min_state, MEAN(\"item_state\") AS average_state FROM \"{}\" where time >= \'{}\' AND time <= \'{}\'""".format(item_global_id, start_time, end_time) query_result_global = self.clientDB.query(query_statement_global) query_result_global = list(query_result_global.get_points()) print(query_result_global[0]['max_state'], query_result_global[0]['min_state'], query_result_global[0]['average_state']) if len(query_result_history) > 0 and len(query_result_global) > 0: item = { 'item_global_id': item_global_id, 'thing_global_id': thing_global_id, 'max_global': query_result_global[0]['max_state'], 'min_global': query_result_global[0]['min_state'], 'average_global': query_result_global[0]['average_state'], 'history': [] } for item_history in query_result_history: item_state = { 'last_changed': item_history['time'], 'item_state': item_history['item_state'], } item['history'].append(item_state) items.append(item) else: query_statement_history = """SELECT * FROM \"{}\" where time >= \'{}\' AND time <= \'{}\'""".format(item_global_id, start_time, end_time) query_result_history = self.clientDB.query(query_statement_history) query_result_history = list(query_result_history.get_points()) if len(query_result_history) > 0: item = { 'item_global_id': item_global_id, 'thing_global_id': thing_global_id, 'history': [] } for item_history in query_result_history: item_state = { 'last_changed': item_history['time'], 'item_state': item_history['item_state'], } item['history'].append(item_state) items.append(item) else: if type_field == 'integer' or type_field == 'float': query_statement_history = """SELECT MODE(\"item_state\") AS item_state, MAX(\"item_state\") AS max_state, MIN(\"item_state\") AS min_state, MEAN(\"item_state\") AS average_state FROM \"{}\" WHERE time >= \'{}\' AND time <= \'{}\' GROUP BY time({}), thing_global_id""".format(item_global_id, start_time, end_time, scale) query_result_history = self.clientDB.query(query_statement_history) query_result_history = list(query_result_history.get_points()) query_statement_global = """SELECT MAX(\"item_state\") AS max_state, MIN(\"item_state\") AS min_state, MEAN(\"item_state\") AS average_state FROM \"{}\" where time >= \'{}\' AND time <= \'{}\'""".format(item_global_id, start_time, end_time) query_result_global = self.clientDB.query(query_statement_global) query_result_global = list(query_result_global.get_points()) if len(query_result_history) > 0 and len(query_result_global) > 0: item = { 'item_global_id': item_global_id, 'thing_global_id': thing_global_id, 'max_global': query_result_global[0]['max_state'], 'min_global': query_result_global[0]['min_state'], 'average_global': query_result_global[0]['average_state'], 'history': [] } for item_history in query_result_history: item_state = { 'last_changed': item_history['time'], 'item_state': item_history['item_state'], 'min_state': item_history['min_state'], 'max_state': item_history['max_state'], 'average_state': item_history['average_state'] } item['history'].append(item_state) items.append(item) else: query_statement_history = """SELECT MODE(\"item_state\") AS item_state FROM \"{}\" WHERE time >= \'{}\' AND time <= \'{}\' GROUP BY time({}), thing_global_id""".format(item_global_id, start_time, end_time, scale) query_result_history = self.clientDB.query(query_statement_history) query_result_history = list(query_result_history.get_points()) if len(query_result_history) > 0: item = { 'item_global_id': item_global_id, 'thing_global_id': thing_global_id, 'history': [] } for item_history in query_result_history: item_state = { 'last_changed': item_history['time'], 'item_state': item_history['item_state'] } item['history'].append(item_state) items.append(item) return items def run(self): queue_get_item_state = Queue(name='dbreader.request.api_get_item_state', exchange=self.exchange, routing_key='dbreader.request.api_get_item_state')#, message_ttl=20) queue_get_item_state_history = Queue(name='dbreader.request.api_get_item_state_history', exchange=self.exchange, routing_key='dbreader.request.api_get_item_state_history')#, message_ttl=20) while 1: try: self.consumer_connection.ensure_connection(max_retries=1) with nested(Consumer(self.consumer_connection, queues=queue_get_item_state, callbacks=[self.api_get_item_state], no_ack=True), Consumer(self.consumer_connection, queues=queue_get_item_state_history, callbacks=[self.api_get_item_state_history], no_ack=True)): while True: self.consumer_connection.drain_events() except (ConnectionRefusedError, exceptions.OperationalError): print('Connection lost') except self.consumer_connection.connection_errors: print('Connection error')
class RabbitmqDaemon(threading.Thread): def __init__(self, actiontecQueue, timecapsuleQueue): threading.Thread.__init__(self) self.settings = ConfigParser.ConfigParser() self.settings.read('../config/site.ini') self.rabbitmqUsername = self.settings.get('rabbitmq', 'username') self.rabbitmqPassword = self.settings.get('rabbitmq', 'password') self.rabbitmqHost = self.settings.get('rabbitmq', 'host') self.rmqConn = Connection('amqp://'+self.rabbitmqUsername+':'+self.rabbitmqPassword+'@'+self.rabbitmqHost+':5672//') self.statusProducer = Producer(self.rmqConn.channel(), exchange = Exchange('actiontec.status', type='fanout'), serializer="json") self.timecapsuleEntries = {} self.discoveredHosts = {} self.timecapsuleQueue = timecapsuleQueue self.actiontecQueue = actiontecQueue def run(self): def list_mac_addresses(message=None, args=None): print "RPC reply with",len(self.discoveredHosts)," cached addresses" sys.stdout.flush() rpcReply(self.discoveredHosts, args) def rpcReply(message, req): rpcProducer.publish(body=message, **dict({'routing_key': req.properties['reply_to'], 'correlation_id': req.properties.get('correlation_id'), 'content_encoding': req.content_encoding})) operations = { "list_mac_addresses" : list_mac_addresses } def on_request(body, req): message = json.loads(body) print "Received message ",message sys.stdout.flush() operations[message['operation']](message, req) rpcProducer= Producer(self.rmqConn.channel(), serializer="json") queue = kombu.Queue( name="actiontec.cmd", exchange=Exchange('actiontec.cmd'), channel=self.rmqConn.channel(), durable=False, exclusive=False, auto_delete=True) consumer = Consumer(self.rmqConn.channel(), queues = queue, auto_declare=True, callbacks=[on_request]) consumer.consume(no_ack=True) while 1: try: self.actiontecEntries = self.actiontecQueue.get(True, 0.1) print "Actiontec cache now contains",len(self.actiontecEntries),"entries" except Queue.Empty as e: self.timecapsuleEntries = self.timecapsuleQueue.get(True, 0.1) # newEntries = self.arpQueue.get(True, 0.1) # for entry in newEntries: # self.entries[entry["mac"]] = entry # print "received",len(self.entries),"hosts from watcher" oldDiscoveredHosts = self.discoveredHosts self.discoveredHosts = {} for mac,details in self.timecapsuleEntries.iteritems(): hostname = "" ip = "" tx = 0 rx = 0 txerr = 0 rxerr = 0 if mac in self.actiontecEntries: hostname = self.actiontecEntries[mac]["hostname"] ip = self.actiontecEntries[mac]["ip"] if mac in oldDiscoveredHosts: now = time.mktime((datetime.datetime.now()).timetuple()) timeDelta = now - oldDiscoveredHosts[mac]["stats"]["timestamp"] rxDelta = int(details["rx"]) - oldDiscoveredHosts[mac]["rawStats"]["rx"] txDelta = int(details["tx"]) - oldDiscoveredHosts[mac]["rawStats"]["tx"] rxerrDelta = int(details["rxerr"]) - oldDiscoveredHosts[mac]["rawStats"]["rxerr"] txerrDelta = int(details["txerr"]) - oldDiscoveredHosts[mac]["rawStats"]["txerr"] tx = int(txDelta // timeDelta) rx = int(rxDelta // timeDelta) rxerr = int(rxerrDelta // timeDelta) txerr = int(txerrDelta // timeDelta) self.discoveredHosts[mac] = { "hostname": hostname, "ip": ip, "mac": mac, "rate": details['rate'], "stats":{ "tx":tx, "rx":rx, "txerr":txerr, "rxerr":rxerr, "signal":int(details['signal']), "noise": int(details['noise']), "timestamp": time.mktime((datetime.datetime.now()).timetuple()), }, "rawStats":{ "tx": details['tx'], "rx": details['rx'], "rates": details['rates'], "time": int(details['time']), "noise": int(details['noise']), "rate": int(details['rate']), "rx": int(details['rx']), "tx": int(details['tx']), "rxerr": int(details['rxerr']), "txerr": int(details['txerr']) } } reply = [] for mac,details in self.discoveredHosts.iteritems(): reply.append({ "hostname":details["hostname"], "ip":details["ip"], "mac":details["mac"], "rate":details["rate"], "stats":details["stats"] }) self.statusProducer.publish(body = reply) except Queue.Empty as e: try: self.rmqConn.drain_events(timeout=0.1) except: None
''' Created on May 19, 2014 @author: xiaoxubeii ''' from kombu import Connection from kombu.messaging import Consumer from entity1 import queue connection = Connection("amqp://*****:*****@xiaoxubeii:5672//") channel = connection.channel() def test(body, message): print body message.ack() consumer = Consumer(channel, queue) consumer.register_callback(test) consumer.consume() while True: connection.drain_events()
class test_PyroTransport: def setup(self): self.c = Connection(transport='pyro', virtual_host="kombu.broker") self.e = Exchange('test_transport_pyro') self.q = Queue('test_transport_pyro', exchange=self.e, routing_key='test_transport_pyro') self.q2 = Queue('test_transport_pyro2', exchange=self.e, routing_key='test_transport_pyro2') self.fanout = Exchange('test_transport_pyro_fanout', type='fanout') self.q3 = Queue('test_transport_pyro_fanout1', exchange=self.fanout) self.q4 = Queue('test_transport_pyro_fanout2', exchange=self.fanout) def test_driver_version(self): assert self.c.transport.driver_version() @pytest.mark.skip("requires running Pyro nameserver and Kombu Broker") 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_pyro') _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() assert len(_received) == 10 def test_drain_events(self): with pytest.raises(socket.timeout): self.c.drain_events(timeout=0.1) c1 = self.c.channel() c2 = self.c.channel() with pytest.raises(socket.timeout): self.c.drain_events(timeout=0.1) del(c1) # so pyflakes doesn't complain. del(c2) @pytest.mark.skip("requires running Pyro nameserver and Kombu Broker") def test_drain_events_unregistered_queue(self): c1 = self.c.channel() producer = self.c.Producer() consumer = self.c.Consumer([self.q2]) producer.publish( {'hello': 'world'}, declare=consumer.queues, routing_key=self.q2.routing_key, exchange=self.q2.exchange, ) message = consumer.queues[0].get()._raw class Cycle(object): def get(self, callback, timeout=None): return (message, 'foo'), c1 self.c.transport.cycle = Cycle() self.c.drain_events() @pytest.mark.skip("requires running Pyro nameserver and Kombu Broker") def test_queue_for(self): chan = self.c.channel() x = chan._queue_for('foo') assert x assert chan._queue_for('foo') is x
class test_basic(TestCase): def setUp(self): self.c = Connection(transport='ironmq') self.p = Connection(transport='ironmq') self.e = Exchange('test_transport_iron') self.q = Queue('test_transport_iron', exchange=self.e, routing_key='test_transport_iron') self.q2 = Queue('test_transport_iron2', exchange=self.e, routing_key='test_transport_iron2') self.q(self.c.channel()).delete() self.q2(self.c.channel()).delete() def test_produce_consume_noack(self): producer = Producer(self.p.channel(), self.e) consumer = Consumer(self.c.channel(), self.q, no_ack=True) for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_iron') _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 test_produce_consume(self): producer_channel = self.p.channel() consumer_channel = self.c.channel() producer = Producer(producer_channel, self.e) consumer1 = Consumer(consumer_channel, self.q) consumer2 = Consumer(consumer_channel, self.q2) self.q2(consumer_channel).declare() for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_iron') for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_iron2') _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_iron', # compression='zlib') #m = self.q(consumer_channel).get() #self.assertDictEqual(m.payload, {'compressed': True}) # queue.delete for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_iron') self.assertTrue(self.q(consumer_channel).get()) self.q(consumer_channel).delete() self.q(consumer_channel).declare() self.assertIsNone(self.q(consumer_channel).get()) # queue.purge for i in range(10): producer.publish({'foo': i}, routing_key='test_transport_iron2') self.assertTrue(self.q2(consumer_channel).get()) self.q2(consumer_channel).purge() self.assertIsNone(self.q2(consumer_channel).get())
class _AMQPServerWrapper(object): def __init__(self, amqp_url): self.__connection = Connection(amqp_url) self.__connection.connect() self.__monitors = {} self.__running = True self.__consumer = Consumer(self.__connection, on_message=self.__on_message) self.__consumer_gl = gevent.spawn(self.__consumer_greenlet_main) def __consumer_greenlet_main(self): gevent.sleep(0) while self.__running: self.__consumer.consume() try: self.__connection.drain_events(timeout=0.1) except Exception as ex: # NOQA: assigned but not used (left in for super-duper-low-level-debug) # print("was woken because {}".format(ex)) pass gevent.sleep(0) # print("---loop") def __on_message(self, msg): ct = msg.delivery_info['consumer_tag'] assert ct in self.__monitors, \ "Message from consumer '{}', but we are not monitoring that (list={})".format( msg.delivery_info['consumer_tag'], self.__monitors.keys()) mon = self.__monitors[ct] mon['event_cb'](msg, msg.body) @property def connected(self): return self.__connection.connected def create_add_monitor(self, exchange, routing_key, event_cb, queue_name=None): mname = "ex={} rk={} qn={}".format(exchange, routing_key, queue_name) if mname in self.__monitors: mon = self.__monitors[mname] mon["event_cb"] = event_cb else: if queue_name is None: queue_name = '' exclusive = True else: exclusive = False ex = Exchange(exchange, 'topic') queue = Queue(exchange=ex, routing_key=routing_key, exclusive=exclusive) bound_queue = queue.bind(self.__connection) self.__consumer.add_queue(bound_queue) bound_queue.consume(mname, self.__on_message) mon = { "event_cb": event_cb, "exchange": ex } self.__monitors[mname] = mon return mon['exchange'] def inject(self, exchange, routing_key, payload): prod = Producer(self.__connection, exchange=exchange, routing_key=routing_key) prod.publish(payload) def test_helper_sync_send_msg(self, exchange, ex_rk, send_rk, payload): ex = Exchange(exchange, 'topic') queue = Queue(exchange=ex, routing_key=ex_rk + '.*', exclusive=True, channel=self.__connection) queue.declare() prod = Producer(self.__connection, exchange=ex, routing_key=send_rk) prod.publish(payload) return queue def test_helper_sync_recv_msg(self, queue): for tick in range(10): msg = queue.get() if msg is not None: break time.sleep(1) return msg
Queue_Port = 5672 Queue_Path = '/websocketserver' def callback(body, message): print body connection = Connection(hostname=Queue_Server, port=Queue_Port, userid=Queue_User, password=Queue_PassWord, virtual_host=Queue_Path) channel = connection.channel() smsExchange = Exchange("sys.sms", type='topic', channel=channel, durable=True, delivery_mode=2) task_queue = Queue('test_recv', exchange=smsExchange, routing_key='sms.code', durable=False, channel=channel) consumer = Consumer(channel, task_queue, no_ack=True, callbacks=[callback]) consumer.qos(prefetch_count=1) consumer.consume() while True: connection.drain_events() connection.close()
class Event_Generator_1(Event_Generator_Base): list_event_condition = [ ] # list_event_condition saved as a mysql table: |condition_id | condition_name | condition | def __init__(self, event_generator_name, event_generator_id, description, event_dest_topic): Event_Generator_Base.__init__(self, event_generator_name, event_generator_id, description, event_dest_topic) BROKER_CLOUD = "192.168.43.30" self.producer_connection = Connection("localhost") self.consumer_connection = Connection("192.168.43.30") self.exchange = Exchange("IoT", type="direct") # self.queue_get_states = Queue(name='data_source.to.' + str(self.event_generator_name), exchange=self.exchange, # routing_key='data_source.to.' + str(self.event_generator_name))#, message_ttl=20) self.queue_get_states = Queue(name='rule.request.states', exchange=self.exchange, routing_key='rule.request.states', message_ttl=20) self.db = MySQLdb.connect(host="0.0.0.0", user="******", passwd="root", db="rule") self.cursor = self.db.cursor() def read_event_condition(self): print("reading event condition ...") request = "Select rule_id, rule_content from Rule" try: # Execute the SQL command self.cursor.execute(request) results = self.cursor.fetchall() # self.list_event_condition = result # print ("results: ", results) for result in results: print("result: ", result) # (rule_id, rule_content) = result rule_id = result[0] print("rule_id: ", rule_id) # rule_content = json.dumps(rule_content) rule_content = json.loads(rule_content) print("\nrule content: ", rule_content) trigger_type = rule_content['trigger_type'] trigger_content = rule_content['trigger_content'] print("\n\ntrigger_type: ", trigger_type) print("\n\ntrigger_content: ", trigger_content) # Commit your changes in the database self.db.commit() return rule_id, trigger_type, trigger_content except: # Rollback in case there is any error print("error read_event_condition") self.db.rollback() return None def check_trigger_item_has_given_state(self, trigger_content): print("checking trigger item_has_given_state ...") print(trigger_content) trigger_content_list = json.loads(trigger_content) pre_result = False total_result = False bitwise_operator = trigger_content['trigger_bitwise'] print("bitwise_operator: ", bitwise_operator) for trigger_content in trigger_content_list: result = False timer = 0 trigger_item_id = trigger_content['id'] print("trigger_item_id: ", trigger_item_id) operator = trigger_content['operator'] print("operator: ", operator) value = trigger_content['value'] print("value: ", value) if (value.isdigit() == True): value = float(value) request = "select time from ItemTable where item_id = '%s' order by time asc limit 1" % ( trigger_item_id) print("time request: ", request) last_insert_time = str(datetime.max) try: # Execute the SQL command self.cursor.execute(request) request_result = self.cursor.fetchall() last_insert_time = request_result[0][0] # Commit your changes in the database self.db.commit() except: print("error read time") result = False pre_result = result self.db.rollback() last_insert_time = datetime.strptime(last_insert_time, '%Y-%m-%d %H:%M:%S.%f') check_time = last_insert_time - timedelta( seconds=float(timer.split('s')[0])) request = "select item_state from ItemTable where item_id = '%s' and time >= '%s' order by time desc" % ( trigger_item_id, check_time) try: # Execute the SQL command self.cursor.execute(request) request_result = self.cursor.fetchall() item_state_list = request_result[0] print("item_state_list: ", item_state_list) # Commit your changes in the database self.db.commit() for item_state in item_state_list: print("item_state: ", item_state) print("value: ", value) result = True if (item_state.isdigit() == True): item_state = float(item_state) # elif (item_state == "on"): # item_state = 1 # elif (item_state == "off"): # item_state = 0 if (operator == "GT"): if (item_state <= value): result = False break elif (operator == "GE"): if (item_state < value): result = False break elif (operator == "LT"): if (item_state >= value): result = False break elif (operator == "LE"): if (item_state > value): result = False break elif (operator == "EQ"): if (item_state != value): result = False break elif (operator == "NE"): if (item_state == value): result = False break else: print("operator is not valid") result = False break print("result: ", result) if (bitwise_operator.upper() == "NONE"): total_result = result pre_result = result elif (bitwise_operator.upper() == "AND"): total_result = pre_result and result pre_result = total_result elif (bitwise_operator.upper() == "OR"): total_result = pre_result or result pre_result = total_result else: print("bitwise operator is not pre-defined") except: # Rollback in case there is any error self.db.rollback() # print ("error check_trigger_item_has_given_state") # return None result = False pre_result = result print("total result: ", total_result) return total_result def check_trigger_condition(self, trigger_type, trigger_content, item_id): print("checking trigger condition ...") result = False if (trigger_type == "item_has_given_state"): result = self.check_trigger_item_has_given_state(trigger_content) else: print("trigger_type is not pre-defined") return result def create_event(self, rule_id): print("creating Event ...") request = "select trigger_content from RuleTable where trigger_id = '%s'" % ( rule_id) # print (request) try: # Execute the SQL command self.cursor.execute(request) request_result = self.cursor.fetchall() print(request_result[0][0]) trigger_content = request_result[0][0] trigger_content = json.loads(trigger_content) message = { 'event_id': event_id, 'event_source': event_source, 'trigger_id': trigger_id, 'time': str(datetime.now()) } # print (trigger_content) output_field = trigger_content['outputs'] print(output_field) # Commit your changes in the database self.db.commit() for output in output_field: event_id = output['event_id'] # event_name = output['event_name'] event_source = output['event_source'] description = output['description'] message = { 'event_generator_id': self.event_generator_id, 'event_id': event_id, # 'event_name' : event_name, 'event_source': event_source, 'trigger_id': trigger_id, 'description': description, 'time': str(datetime.now()) } self.producer_connection.ensure_connection() with Producer(self.producer_connection) as producer: producer.publish(json.dumps(message), exchange=self.exchange.name, routing_key='event_generator.to.' + str(self.event_dest_topic), retry=True) print("Send event to Rule Engine: " + 'event_generator.to.' + str(self.event_dest_topic)) except: print("error read trigger_content") def write_item_to_database(self, item_id, item_name, item_type, item_state, time): print("writting item to database ...") request = """INSERT INTO ItemTable(item_id, item_name, item_type, item_state, time) VALUES ("%s", "%s", "%s", "%s", "%s")""" \ % (item_id, item_name, item_type, item_state, time) print(request) try: # Execute the SQL command print(self.cursor.execute(request)) result = self.cursor.fetchall() print("write item %s to database: %s" % (item_id, result)) self.db.commit() return True except: # Rollback in case there is any error self.db.rollback() print("error write item to database") return False def receive_states(self): def handle_notification(body, message): print("\n\n\n") print("Receive state!") message = json.loads(body)["body"]["states"] for i in range(len(message)): item_id = json.loads(body)["body"]["states"][i]["MetricId"] item_name = json.loads( body)["body"]["states"][i]["MetricLocalId"] item_type = json.loads( body)["body"]["states"][i]["DataPoint"]["DataType"] item_state = json.loads( body)["body"]["states"][i]["DataPoint"]["Value"] # time = json.loads(body)[""] time = datetime.now() time = str(time) # Write new item to the database write_result = self.write_item_to_database( item_id, item_name, item_type, item_state, time) #if write new item success to the database, consider the trigger with that item if (write_result == 1): list_event_condition = self.read_event_condition() print("list event condition: ", list_event_condition) for event_condition in list_event_condition: rule_id = event_condition[0] trigger_type = event_condition[1] trigger_content = event_condition[2] # Check the item with each trigger condition result = self.check_trigger_condition( trigger_type, trigger_content, item_id) print("check trigger : ", result) if (result == None): return None # If checkTriggerCondition success, create an event if (result == True): # event_source = item_id # event_name = str(item_name) + "_" + str(datetime.now()) # event_id = randint(1, 1000000) # my_event = Event(event_name, event_id, event_source) self.create_event(rule_id) # End handle_notification try: self.consumer_connection.ensure_connection(max_retries=1) with nested( Consumer(self.consumer_connection, queues=self.queue_get_states, callbacks=[handle_notification], no_ack=True)): while True: self.consumer_connection.drain_events() except (ConnectionRefusedError, exceptions.OperationalError): print('Connection lost') except self.consumer_connection.connection_errors: print('Connection error') def run(self): self.cursor.execute("""CREATE TABLE IF NOT EXISTS ItemTable( item_id VARCHAR(50), item_name VARCHAR(50), item_type VARCHAR(50), item_state VARCHAR(50), time VARCHAR(50), PRIMARY KEY (item_id, time))""") while 1: try: self.receive_states() except (ConnectionRefusedError, exceptions.OperationalError): print('Connection lost') except self.consumer_connection.connection_errors: print('Connection error')
from kombu import Connection, Exchange, Queue, Consumer ''' Sample Kombu consumer to drain messages from AMQP message bus ''' rabbit_url = "amqp://{rabbit_server_ip}:5672/" conn = Connection(rabbit_url) channel = conn.channel() exchange = Exchange('data_exchange', type="direct") queue = Queue(name="data_q", exchange=exchange, routing_key="data_info") def process_message(body, message): print type(body), body print type(message), message.body print("The body is {}".format(body)) message.ack() with Consumer(conn, queues=queue, callbacks=[process_message], accept=["text/plain", "json"]): conn.drain_events(timeout=6000)
#coding:utf-8 from kombu import Connection from kombu.messaging import Consumer,Producer from kombu import Exchange, Queue Queue_User='******' Queue_PassWord='******' Queue_Server='124.207.209.57' Queue_Port=None Queue_Path='/spider' conn=Connection(hostname=Queue_Server,port=Queue_Port,userid=Queue_User,password=Queue_PassWord,virtual_host=Queue_Path) channel=conn.channel() exch=Exchange('weibodownload',type='topic',durable=True,delivery_mode=2,passive=True) #最新地理位置微薄的routing_key='weibo.geo' 每个人历史记录微薄的routing_key='weibo.user_geo' queue=Queue(exchange=exch,routing_key='weibo.user_geo',auto_delete=True) consumer=Consumer(channel=channel,queues=queue,no_ack=True) consumer.qos(prefetch_count=1) def on_response(body, message): print body consumer.register_callback(on_response) consumer.consume() while True: conn.drain_events()
class test_MemoryTransport(TestCase): def setUp(self): self.c = Connection(transport='memory') self.e = Exchange('test_transport_memory') self.q = Queue('test_transport_memory', exchange=self.e, routing_key='test_transport_memory') self.q2 = Queue('test_transport_memory2', exchange=self.e, routing_key='test_transport_memory2') 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 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_drain_events(self): with self.assertRaises(socket.timeout): self.c.drain_events(timeout=0.1) c1 = self.c.channel() c2 = self.c.channel() with self.assertRaises(socket.timeout): self.c.drain_events(timeout=0.1) del (c1) # so pyflakes doesn't complain. del (c2) def test_drain_events_unregistered_queue(self): c1 = self.c.channel() class Cycle(object): def get(self, timeout=None): return ('foo', 'foo'), c1 self.c.transport.cycle = Cycle() with self.assertRaises(KeyError): self.c.drain_events() def test_queue_for(self): chan = self.c.channel() chan.queues.clear() x = chan._queue_for('foo') self.assertTrue(x) self.assertIs(chan._queue_for('foo'), x)
class MozReviewBot(object): def __init__(self, config_path=None, reviewboard_url=None, reviewboard_user=None, reviewboard_password=None, pulse_host=None, pulse_port=None, pulse_userid=None, pulse_password=None, exchange=None, queue=None, routing_key=None, pulse_timeout=None, pulse_ssl=False, repo_root=None, logger=None): if logger is None: self.logger = logging.getLogger('mozreviewbot') else: self.logger = logger # We use options passed into __init__ preferentially. If any of these # are not specified, we next check the configuration file, if any. # Finally, we use environment variables. if config_path and not os.path.isfile(config_path): # ConfigParser doesn't seem to throw if it is unable to find the # config file so we'll explicitly check that it exists. self.logger.error('could not locate config file: %s' % ( config_path)) config_path = None if config_path: try: config = ConfigParser() config.read(config_path) reviewboard_url = (reviewboard_url or config.get('reviewboard', 'url')) reviewboard_user = (reviewboard_user or config.get('reviewboard', 'user')) reviewboard_password = (reviewboard_password or config.get('reviewboard', 'password')) pulse_host = pulse_host or config.get('pulse', 'host') pulse_port = pulse_port or config.get('pulse', 'port') pulse_userid = pulse_userid or config.get('pulse', 'userid') pulse_password = pulse_password or config.get('pulse', 'password') exchange = exchange or config.get('pulse', 'exchange') queue = queue or config.get('pulse', 'queue') routing_key = routing_key or config.get('pulse', 'routing_key') pulse_timeout = pulse_timeout or config.get('pulse', 'timeout') if pulse_ssl is None: pulse_ssl = config.get('pulse', 'ssl') except NoSectionError as e: self.logger.error('configuration file missing section: %s' % e.section) try: repo_root = repo_root or config.get('hg', 'repo_root') except (NoOptionError, NoSectionError): # Subclasses do not need to define repo root if they do not # plan on using the hg functionality. pass # keep config around in case any subclasses would like to extract # options from it. self.config = config else: self.config = None reviewboard_url = reviewboard_url or os.environ.get('REVIEWBOARD_URL') pulse_host = pulse_host or os.environ.get('PULSE_HOST') pulse_port = pulse_port or os.environ.get('PULSE_PORT') self.rbclient = RBClient(reviewboard_url, username=reviewboard_user, password=reviewboard_password) self.api_root = self.rbclient.get_root() self.conn = Connection(hostname=pulse_host, port=pulse_port, userid=pulse_userid, password=pulse_password, ssl=pulse_ssl) self.exchange = Exchange(exchange, type='topic', durable=True) self.queue = Queue(name=queue, exchange=self.exchange, durable=True, routing_key=routing_key, exclusive=False, auto_delete=False) self.pulse_timeout = float(pulse_timeout) self.repo_root = repo_root self.hg = None for DIR in os.environ['PATH'].split(os.pathsep): p = os.path.join(DIR, 'hg') if os.path.exists(p): self.hg = p def _get_available_messages(self): messages = [] def onmessage(body, message): messages.append((body, message)) consumer = self.conn.Consumer([self.queue], callbacks=[onmessage], auto_declare=True) with consumer: try: self.conn.drain_events(timeout=self.pulse_timeout) except socket.timeout: pass return messages def _run_hg(self, hg_args): # TODO: Use hgtool. args = [self.hg] + hg_args env = dict(os.environ) env['HGENCODING'] = 'utf-8' null = open(os.devnull, 'w') # Execute at / to prevent Mercurial's path traversal logic from # kicking in and picking up unwanted config files. return subprocess.check_output(args, stdin=null, stderr=null, env=env, cwd='/') def ensure_hg_repo_exists(self, landing_repo_url, repo_url, pull_rev=None): # TODO: Use the root changeset in each repository as an identifier. # This will enable "forks" to share the same local clone. # The "share" extension now has support for this. # Read hg help -e share for details about "pooled storage." # We should probably deploy that. url = landing_repo_url or repo_url sha1 = hashlib.sha1(url).hexdigest() repo_path = os.path.join(self.repo_root, sha1) if not os.path.exists(repo_path): args = ['clone', url, repo_path] self.logger.debug('cloning %s' % url) self._run_hg(args) self.logger.debug('finished cloning %s' % url) args = ['-R', repo_path, 'pull', repo_url] if pull_rev: args.extend(['-r', pull_rev]) self.logger.debug('pulling %s' % repo_url) self._run_hg(args) self.logger.debug('finished pulling %s' % repo_url) return repo_path def hg_commit_changes(self, repo_path, node, diff_context=None): """Obtain information about what changed in a Mercurial commit. The return value is a tuple of: (set(adds), set(dels), set(mods), None, diff) The first 4 items list what files changed in the changeset. The last item is a unified diff of the changeset. File copies are currently not returned. ``None`` is being used as a placeholder until support is needed. """ part_delim = str(uuid.uuid4()) item_delim = str(uuid.uuid4()) parts = [ '{join(file_adds, "%s")}' % item_delim, '{join(file_dels, "%s")}' % item_delim, '{join(file_mods, "%s")}' % item_delim, '{join(file_copies, "%s")}' % item_delim, ] template = part_delim.join(parts) self._run_hg(['-R', repo_path, 'up', '-C', node]) res = self._run_hg(['-R', repo_path, 'log', '-r', node, '-T', template]) diff_args = ['-R', repo_path, 'diff', '-c', node] if diff_context is not None: diff_args.extend(['-U', str(diff_context)]) diff = self._run_hg(diff_args) adds, dels, mods, copies = res.split(part_delim) adds = set(f for f in adds.split(item_delim) if f) dels = set(f for f in dels.split(item_delim) if f) mods = set(f for f in mods.split(item_delim) if f) # TODO parse the copies. return adds, dels, mods, None, diff def strip_nonpublic_changesets(self, repo_path): """Strip non-public changesets from a repository. Pulling changesets over and over results in many heads in a repository. This makes Mercurial slow. So, we prune non-public changesets/heads to keep repositories fast. """ self._run_hg(['-R', repo_path, '--config', 'extensions.strip=', 'strip', '--no-backup', '-r', 'not public()']) def get_commit_files(self, commit): """Fetches a list of files that were changed by this commit.""" rrid = commit['review_request_id'] diff_revision = commit['diffset_revision'] start = 0 files = [] while True: result = self.api_root.get_files(review_request_id=rrid, diff_revision=diff_revision, start=start) files.extend(result) start += result.num_items if result.num_items == 0 or start >= result.total_results: break return files def handle_available_messages(self): for body, message in self._get_available_messages(): payload = body['payload'] repo_url = payload['repository_url'] landing_repo_url = payload['landing_repository_url'] commits = payload['commits'] # TODO: should we allow process commits to signal that we should # skip acknowledging the message? try: for commit in commits: rrid = commit['review_request_id'] diff_revision = commit['diffset_revision'] review = BatchReview(self.api_root, rrid, diff_revision) self.process_commit(review, landing_repo_url, repo_url, commit) finally: # This prevents the queue from growing indefinitely but # prevents us from fixing whatever caused the exception # and restarting the bot to handle the message. message.ack() def listen_forever(self): while True: self.handle_available_messages() def process_commit(self, review, repo_url, commits): pass