def _type(topic):
topic = '/' + topic
try:
_topic_type, _, _ = rt.get_topic_type(topic)
if _topic_type:
return response_ok({'topic': topic, 'message_type': _topic_type})
else:
return response_error("Topic '{:s}' not found".format(topic))
except Exception as e:
return response_error(str(e))
def _list():
try:
return response_ok({
'nodes': sorted(KnowledgeBase.get('/node/list', []))
})
except Exception as e:
return response_error(str(e))
def _find(msg_type):
try:
return response_ok({
'message_type': msg_type,
'topics': rt.find_by_type(msg_type)
})
except Exception as e:
return response_error(str(e))
def _services(node):
try:
return response_ok({
'node': '/' + node,
'services': KnowledgeBase.get('/node/services/%s' % node, {})
})
except Exception as e:
return response_error(str(e))
def _params(node):
try:
return response_ok({
'node': '/' + node,
'parameters': KnowledgeBase.get('/node/params/%s' % node, {})
})
except Exception as e:
return response_error(str(e))
def _info(param):
param = '/' + param
try:
info = {'param': param, 'value': rp.get_param(param)}
info.update(
KnowledgeBase.get('/param/info%s' % param, default_param_info()))
return response_ok(info)
except Exception as e:
return response_error(str(e))
def _subscribers(topic):
topic = '/' + topic
try:
return response_ok({
'topic':
topic,
'subscribers':
KnowledgeBase.get('/topic/subscribers%s' % topic, [])
})
except Exception as e:
return response_error(str(e))
def _dttype(topic):
topic = '/' + topic
try:
return response_ok({
'topic':
topic,
'type':
KnowledgeBase.get('/topic/type%s' % topic,
default_topic_type(topic))
})
except Exception as e:
return response_error(str(e))
def _bw(topic):
key = '/topic/bw/' + topic
try:
bw_time, bw = KnowledgeBase.get(key, None, get_time=True)
# return
return response_ok({
'topic': '/' + topic,
'bandwidth': bw,
'secs_since_update': bw_time
})
except Exception as e:
return response_error(str(e))
def _topics(node):
try:
return response_ok({
'node': '/' + node,
'topics': {
t_name: {
'direction': t_info['direction']
} for t_name, t_info in KnowledgeBase.get('/node/topics/%s' % node, {}).items()
}
})
except Exception as e:
return response_error(str(e))
def _hz(topic):
key = lambda s: '/topic/{0}/{1}'.format(s, topic)
try:
hz_time, hz = KnowledgeBase.get(key('hz'), None, get_time=True)
info = KnowledgeBase.get(key('info'), {'effective_frequency': -1})
# return
return response_ok({
'topic': '/' + topic,
'frequency': hz,
'effective_frequency': info['effective_frequency'],
'secs_since_update': hz_time
})
except Exception as e:
return response_error(str(e))
def _info(topic):
topic = '/' + topic
key = lambda x: '/topic/%s%s' % (x, topic)
try:
info = {
'topic': topic,
'type': KnowledgeBase.get(key('type'), default_topic_type(topic)),
'publishers': KnowledgeBase.get(key('publishers'), []),
'subscribers': KnowledgeBase.get(key('subscribers'), [])
}
info.update(KnowledgeBase.get(key('info'), {}))
info['message_type'] = rt.get_topic_type(topic)[0]
return response_ok(info)
except Exception as e:
return response_error(str(e))
def _info(node):
node = '/' + node
key = lambda x: '/node/%s%s' % (x, node)
try:
# compile node info
info = KnowledgeBase.get(key('info'), DEFAULT_NODE_INFO)
info['node'] = node
# get topics
info['topics'] = KnowledgeBase.get(key('topics'), {}).keys()
# get links
# TODO: links are not reported for now
# info['links'] = KnowledgeBase.get(key('links'), [])
# get params
info['services'] = KnowledgeBase.get(key('services'), [])
# get services
info['parameters'] = KnowledgeBase.get(key('params'), [])
return response_ok(info)
except Exception as e:
return response_error(str(e))
def _graph():
node_key = lambda x, n: '/node/%s%s' % (x, n)
topic_key = lambda x, t: '/topic/%s%s' % (x, t)
try:
# put in nodes and topics
nodes = {
n: KnowledgeBase.get(node_key('info', n))
for n in KnowledgeBase.get(node_key('list', ''), [])
if KnowledgeBase.has(node_key('info', n))
}
topics = {
t: KnowledgeBase.get(topic_key('info', t))
for t in KnowledgeBase.get(topic_key('list', ''))
if KnowledgeBase.has(topic_key('info', t))
}
# message_type is not delivered in graph
for topic in topics:
if 'message_type' in topics[topic]:
del topics[topic]['message_type']
# ---
graph = {
'nodes': nodes.keys(),
'edges': {
'node_to_topic': [],
'topic_to_node': [],
'node_to_node': [],
'topic_to_topic': []
}
}
# collect edges (node -> topic)
graph['edges']['node_to_topic'].extend([
{
'from': n,
'to': t
}
for t in topics
for n in KnowledgeBase.get(topic_key('publishers', t), [])
])
# collect edges (topic -> node)
graph['edges']['topic_to_node'].extend([
{
'from': t,
'to': n
}
for t in topics
for n in KnowledgeBase.get(topic_key('subscribers', t), [])
])
# collect edges (topic -> topic)
edges = set()
for t0 in topics:
for n in KnowledgeBase.get(topic_key('subscribers', t0), []):
for t1, t1_info in KnowledgeBase.get(node_key('topics', n), {}).items():
if t1_info['direction'] == TopicDirection.OUTBOUND.name:
edges.add((t0, n, t1))
for n in KnowledgeBase.get(topic_key('publishers', t0), []):
for t1, t1_info in KnowledgeBase.get(node_key('topics', n), {}).items():
if t1_info['direction'] == TopicDirection.INBOUND.name:
edges.add((t1, n, t0))
graph['edges']['topic_to_topic'] = [
{
'from': t0,
'middle': n,
'to': t1
}
for t0, n, t1 in edges
]
# collect edges (node -> node)
edges = set()
for n0 in graph['nodes']:
for t, t_info in KnowledgeBase.get(node_key('topics', n0), {}).items():
if t_info['direction'] == TopicDirection.OUTBOUND.name:
for n1 in KnowledgeBase.get(topic_key('subscribers', t), []):
edges.add((n0, t, n1))
if t_info['direction'] == TopicDirection.INBOUND.name:
for n1 in KnowledgeBase.get(topic_key('publishers', t), []):
edges.add((n1, t, n0))
graph['edges']['node_to_node'] = [
{
'from': n0,
'middle': t,
'to': n1
}
for n0, t, n1 in edges
]
# ---
return response_ok({
'graph': graph,
'nodes': nodes,
'topics': topics
})
except Exception as e:
return response_error(str(e))
def _get(param):
param = '/' + param
try:
return response_ok({'parameter': param, 'value': rp.get_param(param)})
except Exception as e:
return response_error(str(e))
def _list(ns=''):
ns = '/' + ns
try:
return response_ok({'parameters': sorted(rp.list_params(ns))})
except Exception as e:
return response_error(str(e))
