def __init__(self, mq_server = None, virtual_host = cfg.CB_CLUSTER_TAG):
if mq_server == None:
mq_server = cfg.RABBITMQ_IP
self.connection = Connection(host= mq_server, userid="guest", password="******", virtual_host = virtual_host)
self.manager = Client(mq_server+":55672", "guest", "guest")
def Main():
cgiEnv = lib_common.ScriptEnvironment()
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()
try:
lstOverview = cl.get_overview()
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:" + str(exc))
for keyOverview in lstOverview:
valOverview = lstOverview[keyOverview]
valClean = valOverview
# Otherwise it does not work as these chars should be espaced.
# TODO: Nice display for Python lists and dicts.
valClean = str(valClean).replace("{", "").replace("}", "")
grph.add((nodeManager, lib_common.MakeProp(keyOverview),
lib_util.NodeLiteral(valClean)))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
config_nam = cgiEnv.m_entity_id_dict["Url"]
nam_v_host = cgiEnv.m_entity_id_dict["VHost"]
node_manager = survol_rabbitmq_manager.MakeUri(config_nam)
creds = lib_credentials.GetCredentials("RabbitMQ", config_nam)
# cl = Client('localhost:12345', 'guest', '*****')
cl = Client(config_nam, creds[0], creds[1])
grph = cgiEnv.GetGraph()
nod_v_host = survol_rabbitmq_vhost.MakeUri(config_nam, nam_v_host)
grph.add(
(node_manager, lib_common.MakeProp("virtual host node"), nod_v_host))
for obj_exchange in cl.get_exchanges(nam_v_host):
nam_exchange = obj_exchange["name"]
logging.debug("nam_exchange=%s", nam_exchange)
node_exchange = survol_rabbitmq_exchange.MakeUri(
config_nam, nam_v_host, nam_exchange)
management_url = rabbitmq.ManagementUrlPrefix(config_nam, "exchanges",
nam_v_host, nam_exchange)
grph.add((node_exchange, lib_common.MakeProp("Management"),
lib_common.NodeUrl(management_url)))
grph.add((nod_v_host, lib_common.MakeProp("Exchange"), node_exchange))
cgiEnv.OutCgiRdf()
def health_iogt(request):
status_code = status.HTTP_200_OK
if settings.RABBITMQ_MANAGEMENT_INTERFACE:
rx = re.compile(r"amqp://(?P<username>[^:]+).*?:(?P<password>[^@]+)."
"*/(?P<vhost>[^&]+)")
match = rx.search(settings.BROKER_URL)
username = match.groupdict()['username']
password = match.groupdict()['password']
vhost = match.groupdict()['vhost']
base_url = settings.RABBITMQ_MANAGEMENT_INTERFACE
mq_client = Client(base_url, username, password)
queue_data = mq_client.get_queue(vhost, 'celery')
messages = queue_data['messages']
rate = queue_data['messages_details']['rate']
if (messages > 0 and rate == 0):
status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
app_id = environ.get('MARATHON_APP_ID', None)
ver = environ.get('MARATHON_APP_VERSION', None)
return JsonResponse({'id': app_id, 'version': ver}, status=status_code)
def main():
global rabbitClient
# load config file
configFilePath = args.config
if os.path.isfile(configFilePath):
logging.debug('Processing config file {0}'.format(configFilePath))
with open(configFilePath) as configFile:
conf = json.load(configFile)
logging.debug('Graphite configuration: {0}'.format(
conf["graphite_servers"]))
logging.debug('RabbitMQ configuration: {0}'.format(
conf["rabbitmq_clusters"]))
for rabbitmq in conf["rabbitmq_clusters"]:
logging.debug('Working on Rabbitmq cluster: {0}'.format(
rabbitmq['cluster_name']))
rabbitClient = Client(
'{0}:{1}'.format(rabbitmq['host'], rabbitmq['port']),
rabbitmq['username'], rabbitmq['password'])
for graphite in conf["graphite_servers"]:
process(rabbitmq, graphite)
else:
logging.error(
'You must pass existing configFilePath, actual is {0}'.format(
configFilePath))
sys.exit(1)
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 connect(options):
server = environ.get("server", "localhost:15672")
client = Client(server, environ.get("username", "guest"),
environ.get("password", "guest"))
client.is_admin = True
return client
def configure(configobj):
global INTERVAL
global cl
global queues_to_count
global vhost
config = {c.key: c.values for c in configobj.children}
INTERVAL = config['interval'][0]
host = config['host'][0]
port = int(config['port'][0])
username = config['username'][0]
password = config['password'][0]
if 'vhost' in config:
vhost = config['vhost'][0]
else:
vhost = '/'
queues_to_count = []
if 'message_count' in config:
queues_to_count = config['message_count']
collectd.info('rabbitmq_monitoring: Interval: {}'.format(INTERVAL))
cl = Client('{}:{}'.format(host, port), username, password)
collectd.info(
'rabbitmq_monitoring: Connecting to: {}:{} as user:{} password:{}'.
format(host, port, username, password))
collectd.info('rabbitmq_monitoring: Counting messages on: {}'.format(
queues_to_count))
collectd.register_read(read, INTERVAL)
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():
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 objExchange in cl.get_exchanges(namVHost):
namExchange = objExchange["name"]
sys.stderr.write("namExchange=%s\n" % (namExchange))
nodeExchange = survol_rabbitmq_exchange.MakeUri(
configNam, namVHost, namExchange)
managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "exchanges",
namVHost, namExchange)
grph.add((nodeExchange, lib_common.MakeProp("Management"),
lib_common.NodeUrl(managementUrl)))
grph.add((nodVHost, lib_common.MakeProp("Exchange"), nodeExchange))
cgiEnv.OutCgiRdf()
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.ScriptEnvironment()
config_nam = cgiEnv.m_entity_id_dict["Url"]
nam_connection = cgiEnv.m_entity_id_dict["Connection"]
node_manager = survol_rabbitmq_manager.MakeUri(config_nam)
creds = lib_credentials.GetCredentials("RabbitMQ", config_nam)
cl = Client(config_nam, creds[0], creds[1])
grph = cgiEnv.GetGraph()
logging.debug("nam_connection=%s", nam_connection)
nod_connection = survol_rabbitmq_connection.MakeUri(config_nam, nam_connection)
grph.add((node_manager, lib_common.MakeProp("Connection"), nod_connection))
try:
connect_list = cl.get_connection(nam_connection)
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:" + str(exc))
for connect_key in connect_list:
connect_val = connect_list[connect_key]
if connect_key == "vhost":
nod_v_host = survol_rabbitmq_vhost.MakeUri(config_nam, connect_val)
grph.add((nod_connection, lib_common.MakeProp("Virtual host"), nod_v_host))
elif connect_key == "user":
nod_user = survol_rabbitmq_user.MakeUri(config_nam, connect_val)
grph.add((nod_connection, lib_common.MakeProp("User"), nod_user))
elif connect_key == "host":
nod_host = lib_uris.gUriGen.HostnameUri(connect_val)
grph.add((nod_connection, lib_common.MakeProp("Host"), nod_host))
elif connect_key in ["name", "peer_host", "peer_port"]:
pass
else:
if isinstance(connect_val, six.string_types):
connect_val = connect_val.replace(">", "@")
logging.debug("connect_key=%s connect_val=%s", connect_key, connect_val)
elif isinstance(connect_val, dict):
pass
elif isinstance(connect_val, tuple):
pass
elif isinstance(connect_val, list):
pass
else:
pass
logging.debug("Literal=%s", lib_util.NodeLiteral(connect_val))
grph.add((nod_connection, lib_common.MakeProp(connect_key), lib_util.NodeLiteral(connect_val)))
survol_rabbitmq_connection.AddSockets(grph, nod_connection, nam_connection)
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
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.get_all_vhosts()
# http://localhost:12345/api/vhosts
# [{u'name': u'/', u'tracing': False, u'messages_details': {u'rate': 0.0}, u'messages': 0, u'message_stats': {u'deliver_no_ack': 0, u'
# publish_out': 0, u'get_no_ack': 13, u'return_unroutable': 0, u'confirm': 0, u'deliver_get': 13, u'publish': 13, u'confirm_details':
# {u'rate': 0.0}, u'ack_details': {u'rate': 0.0}, u'get': 0, u'deliver': 0, u'publish_out_details': {u'rate': 0.0}, u'redeliver_detail
# s': {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'get_no_ack_details': {u'rate': 0.0}, u'deliver_no_ack_details': {u'rate': 0.0}, u'redeliver': 0}, u'messages_unackno
# wledged_details': {u'rate': 0.0}, u'messages_ready_details': {u'rate': 0.0}, u'messages_unacknowledged': 0, u'messages_ready': 0}]
try:
#
listVHosts = cl.get_all_vhosts()
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:" + str(exc))
for objVHost in listVHosts:
namVHost = objVHost["name"]
logging.debug("q=%s", namVHost)
nodeVHost = survol_rabbitmq_vhost.MakeUri(configNam, namVHost)
try:
grph.add((nodeVHost, lib_common.MakeProp("tracing"),
lib_util.NodeLiteral(objVHost["tracing"])))
except KeyError:
pass
try:
grph.add((nodeVHost, lib_common.MakeProp("messages"),
lib_util.NodeLiteral(objVHost["messages"])))
except KeyError:
pass
# http://127.0.0.1:12345/#/vhosts//
managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "vhosts",
namVHost)
grph.add((nodeVHost, lib_common.MakeProp("Management"),
lib_common.NodeUrl(managementUrl)))
grph.add((nodeManager, lib_common.MakeProp("Virtual host"), nodeVHost))
cgiEnv.OutCgiRdf()
def _get_rabbit_connection():
"""Helper giving us a rabbit connection from settings.BROKER_URL"""
host_with_port = "{}:{}/api/".format(settings.RABBITMQ_HOST, settings.RABBITMQ_MANAGEMENT_PORT)
if settings.BROKER_USE_SSL:
scheme = 'https'
else:
scheme = 'http'
return Client(host_with_port, settings.RABBITMQ_DEFAULT_USER, settings.RABBITMQ_DEFAULT_PASS, scheme=scheme)
def get_host_action(self, vhost):
for host in self.rabbit_config.hosts:
cl = Client(f'{host}:15672', self.rabbit_config.username, self.rabbit_config.password)
try:
cl.is_alive(vhost)
return host
except APIError:
pass
def check_queue(mpc, min_consumers, max_consumers, rabbitmq_server,
rabbitmq_vhost, rabbitmq_queue, instance_group):
cl = Client(rabbitmq_server, 'admin', 'rabbit4ever')
try:
messages = cl.get_queue(rabbitmq_vhost, rabbitmq_queue).get('messages')
except:
bash_delete_auto_resize = "sed -i '/" + rabbitmq_queue + " " + instance_group + " " + mpc + " /d' " + file_path
os.system(bash_delete_auto_resize)
else:
bash_instance_group_info = "gcloud compute instance-groups managed describe " + instance_group + " --zone=us-central1-a"
instance_group_info = subprocess.check_output(bash_instance_group_info,
shell=True)
cur_size = re.findall("targetSize:.*", instance_group_info,
re.MULTILINE)
if not cur_size:
print("Instance group %s does not exist" % instance_group)
bash_delete_auto_resize = "sed -i '/" + rabbitmq_queue + " " + instance_group + " " + mpc + " /d' " + file_path
os.system(bash_delete_auto_resize)
else:
cur_max_replicas = re.findall("maxNumReplicas:.*",
instance_group_info, re.MULTILINE)
if max_consumers == 0:
if not cur_max_replicas:
print(
"Auto scaling for instance group %s is already disabled"
% instance_group)
else:
resize_instance_group(instance_group, 0, 0)
bash_delete_auto_resize = "sed -i '/" + rabbitmq_queue + " " + instance_group + " " + mpc + " /d' " + file_path
os.system(bash_delete_auto_resize)
else:
if messages == 0:
if not cur_max_replicas:
print(
"Auto scaling for instance group %s is already disabled"
% instance_group)
else:
resize_instance_group(instance_group, 0, 0)
else:
consumers = cl.get_queue(rabbitmq_vhost,
rabbitmq_queue).get('consumers')
if (messages / mpc) != consumers:
if not cur_max_replicas:
print(
"Auto scaling for instance group %s is disabled, going to resize instance group"
% instance_group)
resize_instance_group(instance_group,
min_consumers, max_consumers)
else:
cur_max_replicas = int(
cur_max_replicas[0].split(": ")[1])
max_replicas = max(cur_max_replicas, max_consumers)
min_replicas = min(
max(messages / mpc, min_consumers),
max_replicas)
resize_instance_group(instance_group, min_replicas,
max_replicas)
def countMessagesQueue(self, vhost, queue):
qtd = 0
cl = Client('{}:{}'.format(self.host, self.web_port), self.user,
self.password)
try:
qtd = cl.get_queue_depth(vhost, queue)
except HTTPError as e:
logger.error(e)
raise e
return qtd
def rabbit_manager(request):
config = request.config
rabbit_ctl_uri = urlparse(config.getoption('RABBIT_CTL_URI'))
host_port = '{0.hostname}:{0.port}'.format(rabbit_ctl_uri)
rabbit = Client(host_port, rabbit_ctl_uri.username,
rabbit_ctl_uri.password)
return rabbit
def get_bindings(self):
client = Client("localhost:15672", "guest", "guest")
bindings = client.get_bindings()
bindings_result = []
for b in bindings:
if b["source"] == "exchange_baby_monitor":
bindings_result.append(b)
return bindings_result
def getRabbitmqQueueDetails(queueName, host='/'):
cluster = constant.config['cluster']
url = constant.rabbitmqCred[cluster]
user = constant.rabbitmqCred['username']
passwd = constant.rabbitmqCred['passwd']
obj = Client(url, user, passwd)
try:
return obj.get_queue(vhost=host, name=queueName)
except pyrabbit.http.HTTPError:
return {}
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()
#>>> cl.get_users()
#[{u'hashing_algorithm': u'rabbit_password_hashing_sha256', u'name': u'guest', u'tags': u'administrator', u'password_hash': u'xxxxxx'}]
try:
#
listUsers = cl.get_users()
except:
#
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Caught:" + str(exc))
for objUser in listUsers:
namUser = objUser["name"]
DEBUG("q=%s", namUser)
nodeUser = survol_rabbitmq_user.MakeUri(configNam, namUser)
try:
grph.add((nodeUser, lib_common.MakeProp("Tags"),
lib_common.NodeLiteral(objUser["tags"])))
except KeyError:
pass
try:
grph.add((nodeUser, lib_common.MakeProp("Hashing algorithm"),
lib_common.NodeLiteral(objUser["hashing_algorithm"])))
except KeyError:
pass
# http://127.0.0.1:12345/#/users/guest
managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "users",
namUser)
grph.add((nodeUser, lib_common.MakeProp("Management"),
lib_common.NodeUrl(managementUrl)))
grph.add((nodeManager, lib_common.MakeProp("User"), nodeUser))
cgiEnv.OutCgiRdf()
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 connect(self):
connections['default'].close()
rabbitmq = ALCO_SETTINGS['RABBITMQ']
self.amqp = Connection(**rabbitmq)
self.redis = redis.Redis(**ALCO_SETTINGS['REDIS'])
self.insert_thread = Thread(target=self.inserter_loop)
self.insert_thread.start()
hostname = '%s:%s' % (rabbitmq['host'],
ALCO_SETTINGS['RABBITMQ_API_PORT'])
self.rabbit = Client(hostname, rabbitmq['userid'],
rabbitmq['password'])
self.vhost = rabbitmq['virtual_host']
def get_rabbitmq_queue_length(q):
"""Fetch queue length from RabbitMQ for a given queue.
Used periodically to decide if we want to queue more functions or not.
Uses the Management HTTP API of RabbitMQ, since the Celery client doesn not have access to these counts.
"""
from pyrabbit.api import Client
cl = Client(settings.SNOOP_RABBITMQ_HTTP_URL, 'guest', 'guest')
return cl.get_queue_depth('/', q)
async def monitor(request):
#data loaded for the first time from the function call
global refresh
db = request.app['db']
await db.collection.drop()
if refresh == 0:
#Client creation
try:
client = Client('localhost:15672', 'guest', 'guest')
except:
return {"result":"Client not created"}
#get all the bindings()
try:
bindings = client.get_bindings()
n = len(bindings)
except:
return {"result":"binding error"}
#final list of all the rows
result_list = []
for i in range(n):
#dict for storing values for each connection
try:
dict_each = {}
vhost_name = bindings[i]['vhost']
dict_each['vhost_name'] = vhost_name
dict_each['exchange_name'] = bindings[i]['source']
queue_name = bindings[i]['destination']
dict_each['queue_name'] = queue_name
dict_each['queue_size'] = client.get_queue_depth(vhost=vhost_name, name=queue_name)
result_list.append(dict_each)
except:
return {"result" : "data not found"}
#insert data in the db
try:
await db.collection.insert_many(i for i in result_list)
except:
return {'result': "data not stored in the db"}
refresh+=1
return {'result_list': result_list}
#data retrieved from the database after refresh
if refresh>0:
result_list = []
async for document in db.collection.find():
result_list.append(document)
return {"result_list" : result_list}
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 get_client(cfg):
"""
Get RabbitMQ client based on provided configuration or default settings.
:param cfg: config dict
:return: RabbitMQ client object
"""
username_from_env = os.getenv('CHECK_RABBITMQ_QUEUES_USERNAME')
password_from_env = os.getenv('CHECK_RABBITMQ_QUEUES_PASSWORD')
client = Client('%s:%s' % (cfg.get('host', DEFAULT_HOSTNAME),
cfg.get('port', DEFAULT_PORT)),
username_from_env or cfg.get('username', DEFAULT_USERNAME),
password_from_env or cfg.get('password', DEFAULT_PASSWORD))
return client
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 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()
try:
#
listExchanges = cl.get_exchanges()
except:
#
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Caught:" + str(exc))
for objExchange in listExchanges:
namExchange = objExchange["name"]
DEBUG("namExchange=%s", namExchange)
namVHost = objExchange["vhost"]
nodeExchange = survol_rabbitmq_exchange.MakeUri(
configNam, namVHost, namExchange)
nodVHost = survol_rabbitmq_vhost.MakeUri(configNam, namVHost)
grph.add(
(nodeExchange, lib_common.MakeProp("virtual host node"), nodVHost))
managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "exchanges",
namVHost, namExchange)
grph.add((nodeExchange, lib_common.MakeProp("Management"),
lib_common.NodeUrl(managementUrl)))
grph.add((nodVHost, lib_common.MakeProp("Exchange"), nodeExchange))
cgiEnv.OutCgiRdf()
