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 _list_amqp_queues(self):
rabbit_client = Client('localhost:15672', 'guest', 'guest')
queues = [q['name'] for q in rabbit_client.get_queues()]
return queues
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
