class rabbitmonitor(threading.Thread): def __init__(self): threading.Thread.__init__ (self) self.scheduler = sched.scheduler(time.time,time.sleep) self.cl = Client("localhost:55672","guest","guest") def rabbit_stats(self): rabbit_data={} try: exchanges = self.cl.get_exchanges() queues = self.cl.get_queues() binding = self.cl.get_bindings() rabbit_data['time'] = time.time() rabbit_data['exchanges'] = exchanges rabbit_data['queues'] = queues for q in rabbit_data['queues']: ## delete a tmp query with no consumer ## zombie queue if "amq" in q['name'] and q['consumers'] == 0: vhost = q['vhost'] self.cl.delete_queue(vhost,q['name']) print 'deleting queue' except: print 'error' pass; def run(self): while(1): self.scheduler.enter(400,1,self.rabbit_stats,()); self.scheduler.run()
def main(): rabbit = None outcome = None try: # Ensure there are no paralell runs of this script lock.acquire(timeout=5) # Connect to Rabbit nullwrite = NullWriter() oldstdout = sys.stdout sys.stdout = nullwrite # disable output rabbit = RabbitClient('%s:%s' % (rabbitmq['host'], rabbitmq['port']), rabbitmq['username'], rabbitmq['password']) if not rabbit.is_alive(): raise Exception('Cannot connect to RabbitMQ') queues = rabbit.get_queues(rabbitmq['vhost']) sys.stdout = oldstdout # enable output # Build outcome if args.d == 'queues': outcome = {'data': []} for queue in queues: outcome['data'].append({'{#QUEUE}': queue['name']}) except LockTimeout: print 'Lock not acquired, exiting' except AlreadyLocked: print 'Already locked, exiting' except Exception, e: print type(e) print 'Error: %s' % e
def queues(self, ): cl = Client('{}:15672'.format(self.config["rabbitmq"]["server"]), self.config["rabbitmq"]["user"], self.config["rabbitmq"]["password"]) queues = [q['name'] for q in cl.get_queues()] queues.remove("scan-result") return queues
def main(): rabbit = None try: # Ensure there are no paralell runs of this script lock.acquire(timeout=5) # Connect to Rabbit nullwrite = NullWriter() oldstdout = sys.stdout sys.stdout = nullwrite # disable output rabbit = RabbitClient('%s:%s' % (rabbitmq['host'], rabbitmq['port']), rabbitmq['username'], rabbitmq['password']) if not rabbit.is_alive(): raise Exception('Cannot connect to RabbitMQ') queues = rabbit.get_queues(rabbitmq['vhost']) sys.stdout = oldstdout # enable output # Build outcome if args.d == 'queues': outcome = {'data': []} for queue in queues: outcome['data'].append({'{#QUEUE}': queue['name']}) except LockTimeout: print 'Lock not acquired, exiting' except AlreadyLocked: print 'Already locked, exiting' except Exception, e: print type(e) print 'Error: %s' % e
class MqSmokeTest(unittest.TestCase): def setUp(self): self.cl = Client("mq:15672", os.environ.get("SFM_RABBITMQ_USER"), os.environ.get("SFM_RABBITMQ_PASSWORD")) self.assertTrue(self.cl.is_alive()) def test_exchange(self): exchanges = self.cl.get_exchanges() for exchange in exchanges: if exchange["name"] == "sfm_exchange": break else: self.assertTrue(False, "Exchange not found.") def test_queues(self): queues = self.cl.get_queues() queues_names = {queue["name"] for queue in queues} # Add additional queue names as new components are added. self.assertTrue( queues_names.issuperset( set([ "flickr_harvester", "flickr_exporter", "sfm_ui", "twitter_harvester", "twitter_rest_harvester", "twitter_rest_harvester_priority", "twitter_rest_exporter", "twitter_stream_exporter", "tumblr_harvester", "tumblr_exporter" ])))
def get_queue_depths(host, username, password, vhost): cl = Client(host, username, password) depths = {} queues = [q['name'] for q in cl.get_queues(vhost=vhost)] for queue in queues: depths[queue] = cl.get_queue_depth(vhost, queue) return depths
def Main(): cgiEnv = lib_common.CgiEnv() configNam = cgiEnv.m_entity_id_dict["Url"] namVHost = cgiEnv.m_entity_id_dict["VHost"] nodeManager = survol_rabbitmq_manager.MakeUri(configNam) creds = lib_credentials.GetCredentials("RabbitMQ", configNam) # cl = Client('localhost:12345', 'guest', 'guest') cl = Client(configNam, creds[0], creds[1]) grph = cgiEnv.GetGraph() nodVHost = survol_rabbitmq_vhost.MakeUri(configNam, namVHost) grph.add((nodeManager, lib_common.MakeProp("virtual host node"), nodVHost)) for quList in cl.get_queues(namVHost): namQueue = quList["name"] DEBUG("q=%s", namQueue) nodeQueue = survol_rabbitmq_queue.MakeUri(configNam, namVHost, namQueue) managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "queues", namVHost, namQueue) grph.add((nodeQueue, lib_common.MakeProp("Management"), lib_common.NodeUrl(managementUrl))) grph.add((nodVHost, lib_common.MakeProp("Queue"), nodeQueue)) cgiEnv.OutCgiRdf()
def main(): rabbit = None try: # Ensure there are no paralell runs of this script lock.acquire(timeout=5) # Connect to Rabbit nullwrite = NullWriter() oldstdout = sys.stdout sys.stdout = nullwrite # disable output rabbit = RabbitClient('%s:%s' % (rabbitmq['host'], rabbitmq['port']), rabbitmq['username'], rabbitmq['password']) if not rabbit.is_alive(): raise Exception('Cannot connect to RabbitMQ') vhost = rabbit.get_vhost(rabbitmq['vhost']) queues = rabbit.get_queues(rabbitmq['vhost']) sys.stdout = oldstdout # enable output # Build outcome metrics = [] for key in keys: if type(key) == dict and 'vhost' in key: for subkey in key['vhost']: if subkey in vhost: metrics.append( Metric(rabbitmq['host'], 'rabbitmq.%s.%s' % ('vhost', subkey), vhost[subkey])) elif type(key) == dict and 'vhost.message_stats' in key: for subkey in key['vhost.message_stats']: if subkey in vhost['message_stats']: metrics.append( Metric( rabbitmq['host'], 'rabbitmq.%s.%s' % ('vhost.message_stats', subkey), vhost['message_stats'][subkey])) elif type(key) == dict and 'queues' in key: for queue in queues: for subkey in key['queues']: if subkey in queue: metrics.append( Metric( rabbitmq['host'], 'rabbitmq.%s.%s[%s]' % ('queue', subkey, queue['name']), queue[subkey])) # Send packet to zabbix send_to_zabbix(metrics, zabbix_host, zabbix_port) except LockTimeout: print 'Lock not acquired, exiting' except AlreadyLocked: print 'Already locked, exiting' except Exception, e: print type(e) print 'Error: %s' % e
def get_queue_depths(host, username, password, vhost): cl = Client(host, username, password) if not cl.is_alive(): raise Exception("Failed to connect to rabbitmq") depths = {} queues = [q["name"] for q in cl.get_queues(vhost=vhost)] for queue in queues: if queue == "aliveness-test": continue depths[queue] = cl.get_queue_depth(vhost, queue) return depths
def get_queue_depths(host, username, password, vhost): cl = Client(host, username, password) if not cl.is_alive(): raise Exception("Failed to connect to rabbitmq") depths = {} queues = [q['name'] for q in cl.get_queues(vhost=vhost)] for queue in queues: if queue == "aliveness-test": #pyrabbit continue elif queue.endswith('.pidbox') or queue.startswith('celeryev.'): #celery continue depths[queue] = cl.get_queue_depth(vhost, queue) return depths
def get_queue_depths(host, username, password, vhost): """ Fetches queue depths from rabbitmq instance.""" cl = Client(host, username, password) if not cl.is_alive(): raise Exception("Failed to connect to rabbitmq") depths = {} queues = [q['name'] for q in cl.get_queues(vhost=vhost)] for queue in queues: if queue == "aliveness-test": #pyrabbit continue elif queue.startswith('amq.gen-'): #Anonymous queues continue depths[queue] = cl.get_queue_depth(vhost, queue) return depths
def get_queue_depths(host, username, password, vhost): cl = Client(host, username, password) if not cl.is_alive(): raise Exception("Failed to connect to rabbitmq") depths = {} queues = [q['name'] for q in cl.get_queues(vhost=vhost)] for queue in queues: if queue == "aliveness-test": #pyrabbit continue elif queue.endswith('.pidbox') or queue.startswith( 'celeryev.'): #celery continue depths[queue] = cl.get_queue_depth(vhost, queue) return depths
def main(): rabbit = None try: # Ensure there are no paralell runs of this script lock.acquire(timeout=5) # Connect to Rabbit nullwrite = NullWriter() oldstdout = sys.stdout sys.stdout = nullwrite # disable output rabbit = RabbitClient('%s:%s' % (rabbitmq['host'], rabbitmq['port']), rabbitmq['username'], rabbitmq['password']) if not rabbit.is_alive(): raise Exception('Cannot connect to RabbitMQ') vhost = rabbit.get_vhost(rabbitmq['vhost']) queues = rabbit.get_queues(rabbitmq['vhost']) sys.stdout = oldstdout # enable output # Build outcome metrics = [] for key in keys: if type(key) == dict and 'vhost' in key: for subkey in key['vhost']: if subkey in vhost: metrics.append(Metric(rabbitmq['host'], 'rabbitmq.%s.%s' % ('vhost', subkey), vhost[subkey])) elif type(key) == dict and 'vhost.message_stats' in key: for subkey in key['vhost.message_stats']: if subkey in vhost['message_stats']: metrics.append(Metric(rabbitmq['host'], 'rabbitmq.%s.%s' % ('vhost.message_stats', subkey), vhost['message_stats'][subkey])) elif type(key) == dict and 'queues' in key: for queue in queues: for subkey in key['queues']: if subkey in queue: metrics.append(Metric(rabbitmq['host'], 'rabbitmq.%s.%s[%s]' % ('queue', subkey, queue['name']), queue[subkey])) # Send packet to zabbix send_to_zabbix(metrics, zabbix_host, zabbix_port) except LockTimeout: print 'Lock not acquired, exiting' except AlreadyLocked: print 'Already locked, exiting' except Exception, e: print type(e) print 'Error: %s' % e
def Main(): cgiEnv = lib_common.CgiEnv() configNam = cgiEnv.GetId() nodeManager = survol_rabbitmq_manager.MakeUri(configNam) creds = lib_credentials.GetCredentials("RabbitMQ", configNam) # cl = Client('localhost:12345', 'guest', 'guest') cl = Client(configNam, creds[0], creds[1]) grph = cgiEnv.GetGraph() # cl.is_alive() try: # listQueues = cl.get_queues() except: # exc = sys.exc_info()[1] lib_common.ErrorMessageHtml("Caught:" + str(exc)) for quList in listQueues: namQueue = quList["name"] DEBUG("q=%s", namQueue) namVHost = quList["vhost"] nodVHost = survol_rabbitmq_vhost.MakeUri(configNam, namVHost) nodeQueue = survol_rabbitmq_queue.MakeUri(configNam, namVHost, namQueue) grph.add((nodeQueue, lib_common.MakeProp("vhost"), lib_common.NodeLiteral(namVHost))) grph.add((nodeQueue, lib_common.MakeProp("vhost node"), nodVHost)) managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "queues", namVHost, namQueue) grph.add((nodeQueue, lib_common.MakeProp("Management"), lib_common.NodeUrl(managementUrl))) grph.add((nodeManager, lib_common.MakeProp("Queue"), nodeQueue)) cgiEnv.OutCgiRdf()
def get_testing_devices(): # This is the end-point which would get information of the connected test devices # and then publish them to users. cl = Client("rabbitmq-broker:15672", "admin", "admin") queues = [ q["name"].split("/")[-1] for q in cl.get_queues() if "request" in q["name"] ] if len(queues) > 0: response = {"status": 200, "queues": queues} else: response = { "status": 404, "message": "No device is connected right now." } return jsonify(response), response["status"]
def consume(vhost): cl = Client('localhost:15672', 'guest', 'guest') # for vhost in cl.get_vhost_names(): # queues = cl.get_queues(vhost) queues = cl.get_queues(vhost) client = puka.Client(f"amqp://localhost/{vhost}") promise = client.connect() client.wait(promise) print(" [*] Waiting for messages. Press CTRL+C to quit.") queues = [queue['name'] for queue in queues] print(queues) consume_promise = client.basic_consume_multi(queues=queues, prefetch_count=1) while True: result = client.wait(consume_promise) print(" [x] Received message %r" % (result, )) client.basic_ack(result) promise = client.close() client.wait(promise)
class rabbitmonitor(threading.Thread): def __init__(self): threading.Thread.__init__ (self) self.scheduler = sched.scheduler(time.time,time.sleep) self.cl = Client("localhost:55672","guest","guest") def rabbit_stats(self): rabbit_data={} try: exchanges = self.cl.get_exchanges() queues = self.cl.get_queues() binding = self.cl.get_bindings() rabbit_data['time'] = time.time() rabbit_data['exchanges'] = exchanges rabbit_data['queues'] = queues print rabbit_data except: pass; def run(self): while(1): self.scheduler.enter(2,1,self.rabbit_stats,()); self.scheduler.run()
class MqSmokeTest(unittest.TestCase): def setUp(self): self.cl = Client("mq:15672", os.environ.get("RABBITMQ_USER"), os.environ.get("RABBITMQ_PASSWORD")) self.assertTrue(self.cl.is_alive()) def test_exchange(self): exchanges = self.cl.get_exchanges() for exchange in exchanges: if exchange["name"] == "sfm_exchange": break else: self.assertTrue(False, "Exchange not found.") def test_queues(self): queues = self.cl.get_queues() queues_names = {queue["name"] for queue in queues} # Add additional queue names as new components are added. self.assertTrue(queues_names.issuperset(set(["flickr_harvester", "sfm_ui", "twitter_harvester", "twitter_rest_harvester"])))
class rabbitmonitor(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.scheduler = sched.scheduler(time.time, time.sleep) self.cl = Client("localhost:55672", "guest", "guest") def rabbit_stats(self): rabbit_data = {} try: exchanges = self.cl.get_exchanges() queues = self.cl.get_queues() binding = self.cl.get_bindings() rabbit_data['time'] = time.time() rabbit_data['exchanges'] = exchanges rabbit_data['queues'] = queues print rabbit_data except: pass def run(self): while (1): self.scheduler.enter(2, 1, self.rabbit_stats, ()) self.scheduler.run()
help="Username", default='test') parser.add_argument("-password", dest='password', type=str, help="Password", default='swordfish') parser.add_argument("-vhostname", dest='vhostname', type=str, help="Vhost name", default='test') args = parser.parse_args() rabbitmq_url = args.rabbitmq_url rabbitmq_user = args.rabbitmq_username rabbitmq_password = args.rabbitmq_password user = args.username password = args.password vhost = args.vhostname cl = Client(rabbitmq_url, rabbitmq_user, rabbitmq_password) assert cl.is_alive() for queue in cl.get_queues(): if queue['vhost'] == vhost: cl.purge_queue(vhost, queue['name']) cl.delete_queue(vhost, queue['name']) for vhost_ in cl.get_all_vhosts(): if vhost_['name'] == vhost: while True: try: cl.delete_vhost(vhost_['name']) break except Exception: pass for user_ in cl.get_users(): if user_['name'] == user:
def _list_amqp_queues(self): rabbit_client = Client('localhost:15672', 'guest', 'guest') queues = [q['name'] for q in rabbit_client.get_queues()] return queues
# {ip, "127.0.0.1"}]} # rabbitmq-plugins enable rabbitmq_management cl = Client('localhost:12345', 'guest', 'guest') sys.stdout.write("\n"+"cl=%s\n"%str(cl)) isal = cl.is_alive() sys.stdout.write("\n"+"isalive=%s\n"%str(isal)) sys.stdout.write("\n\n") # queues = [q['name'] for q in cl.get_queues()] queues = [q for q in cl.get_queues()] # exclusive=False # reductions=11223 # garbage_collection={u'min_heap_size': 233, u'fullsweep_after': 65535, u'minor_gcs': 2, u'min_bin_vheap_size': 46422} # messages_ready_ram=0 # idle_since=2017-02-05 14:08:12 # message_bytes_unacknowledged=0 # message_stats={u'deliver_no_ack': 0, u'publish_out': 0, u'get_no_ack': 10, u'return_unroutable': 0, u'confirm': 0, u'get_no_ack_details': {u'rate': 0.0}, u'publish': 10, u'confirm_details': {u'rate': 0.0}, u'ack_details': {u'rate': 0.0}, u'get': 0, u'publish_out_details': {u'rate': 0.0}, u'deliver': 0, u'deliver_no_ack_details': {u'rate': 0.0}, u'deliver_details': {u'rate': 0.0}, u'deliver_get_details': {u'rate': 0.0}, u'publish_details': {u'rate': 0.0}, u'publish_in_details': {u'rate': 0.0}, u'ack': 0, u'publish_in': 0, u'return_unroutable_details': {u'rate': 0.0}, u'get_details': {u'rate': 0.0}, u'deliver_get': 10, u'redeliver_details': {u'rate': 0.0}, u'redeliver': 0} # messages_unacknowledged=0 # messages_unacknowledged_ram=0 # recoverable_slaves=None # consumers=0 # durable=False # state=running # message_bytes_persistent=0
def getQueues(): cl = Client('localhost:15672', 'guest', 'guest') return [q['name'] for q in cl.get_queues()]
def _list_amqp_queues(self): rabbit_client = Client("localhost:15672", "guest", "guest") queues = [q["name"] for q in rabbit_client.get_queues()] return queues
class MainWindow(QMainWindow): def __init__(self): super(MainWindow, self).__init__() loadUi('chat.ui', self) self.username = QInputDialog.getText(self, 'Zdarova', 'User name:') self.history = '' if not self.username[1]: return self.connection = pika.BlockingConnection( pika.ConnectionParameters(host='localhost')) self.channel = self.connection.channel() self.channel.exchange_declare(exchange='ex', exchange_type='topic') self.channel.exchange_declare(exchange='exx', exchange_type='fanout') self.channel.queue_declare(queue=self.username[0]) self.channel.queue_bind(exchange='ex', queue=self.username[0], routing_key=self.username[0]) self.channel.queue_bind(exchange='exx', queue=self.username[0]) self.model = QStandardItemModel() self.textEdit = QTextEdit() self.textEdit.setReadOnly(True) self.tabWidget.addTab(self.textEdit, 'Общий чат') self.timer = QTimer() self.timer.timeout.connect(self.update) self.timer.start(1000) self.cl = Client('localhost:15672', 'guest', 'guest') self.btnSend.clicked.connect(self.send) self.listView.clicked.connect(self.lsopen) self.tabWidget.tabCloseRequested.connect(self.closeTab) self.tabWidget.currentChanged.connect(self.changeTab) self.listView.customContextMenuRequested.connect(self.popUp) self.blackList = list() def popUp(self, position): menu = QMenu("Menu", self) menu.addAction("Заблокировать").connect(self.block) menu.exec_(self.listView.mapToGlobal(position)) def block(self): print(1) def changeTab(self, index): self.textEditLs = self.tabWidget.currentWidget() def closeTab(self, index): if index == 0: return self.tabWidget.removeTab(index) def lsopen(self, index): if not index.isValid(): return for i in range(1, self.tabWidget.count()): if self.tabWidget.tabText(i) == self.listView.model().data(index): self.tabWidget.setCurrentIndex(i) self.textEditLs = self.tabWidget.currentWidget() return self.textEditLs = QTextEdit() self.textEditLs.setReadOnly(True) self.tabWidget.addTab(self.textEditLs, self.listView.model().data(index)) self.tabWidget.setCurrentIndex(self.tabWidget.count() - 1) def __del__(self): self.timer.stop() self.channel.queue_delete(queue=self.username[0]) self.connection.close() def send(self): message = time.ctime( ) + ' ' + self.username[0] + ': ' + self.edtMes.text() + '\n' if self.tabWidget.currentIndex() == 0: self.channel.basic_publish(exchange='exx', routing_key='', body=message) else: self.channel.basic_publish(exchange='ex', routing_key=self.tabWidget.tabText( self.tabWidget.currentIndex()), body=message) self.channel.basic_publish(exchange='ex', routing_key=self.tabWidget.tabText( self.tabWidget.currentIndex()), body=self.username[0]) self.textEditLs.append(message) self.edtMes.clear() def update(self): self.timer.stop() queues = [q['name'] for q in self.cl.get_queues()] self.model.clear() for i in range(len(queues)): item = QStandardItem(queues[i]) if queues[i] == self.username[0]: font = item.font() font.setBold(True) item.setFont(font) self.model.setItem(i, item) self.listView.setModel(self.model) method, properties, body = self.channel.basic_get( queue=self.username[0]) if (method == None): self.timer.start(1000) return elif method.routing_key == self.username[0]: method2, properties2, body2 = self.channel.basic_get( queue=self.username[0]) for i in range(1, self.tabWidget.count()): if self.tabWidget.tabText(i) == body2.decode('utf-8'): self.tabWidget.setCurrentIndex(i) self.textEditLs = self.tabWidget.currentWidget() self.textEditLs.append(body.decode('utf-8')) self.timer.start(1000) return self.textEditLs = QTextEdit() self.textEditLs.setReadOnly(True) self.tabWidget.addTab(self.textEditLs, body2.decode('utf-8')) self.textEditLs.append(body.decode('utf-8')) self.timer.start(1000) else: self.textEdit.append(body.decode('utf-8')) self.timer.start(1000)
def list_queues(host='localhost', port=15672, user_id='guest', password='******'): url = '%s:%s' % (host, port) client = Client(url, user_id, password) queues = [q['name'] for q in client.get_queues()] return queues