def _diagnostics_links_cb(data):
node_key = lambda n: '/node/links%s' % n
# nothing to do if the message is empty
if len(data.links) <= 0:
return
# store info about links
node = data.links[0].node
links = [
{
'topic': link.topic,
'remote': link.remote,
'direction': TopicDirection(link.direction).name,
'connected': link.connected,
'transport': link.transport,
'messages': link.messages,
'dropped': link.dropped,
'bytes': link.bytes,
'frequency': link.frequency,
'bandwidth': link.bandwidth
}
for link in data.links
if not is_infra_topic(link.topic)
]
# ---
KnowledgeBase.set(node_key(node), links)
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 _list():
try:
return response_ok({
'nodes': sorted(KnowledgeBase.get('/node/list', []))
})
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 _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 _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 _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 _diagnostics_node_cb(data):
if is_infra_node(data.name):
return
# ---
key = '/node/info%s' % data.name
# store info about nodes
info = {
'help': data.help,
'type': NodeType(data.type).name,
'health': NodeHealth(data.health).name,
'health_value': NodeHealth(data.health).value,
'health_reason': data.health_reason,
'health_stamp': data.health_stamp,
'enabled': data.enabled,
'machine': data.machine,
'module_type': data.module_type,
'module_instance': data.module_instance
}
KnowledgeBase.set(key, info)
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 _diagnostics_params_cb(data):
node_key = lambda n: '/node/params%s' % n
param_key = lambda p: '/param/info%s' % p
# nothing to do if the message is empty
if len(data.params) <= 0:
return
# store info about params
node = data.params[0].node
params = KnowledgeBase.get(node_key(node), [])
for param in data.params:
info = {
'help': param.help,
'type': ParamType(param.type).name,
'min_value': param.min_value,
'max_value': param.max_value,
'editable': param.editable
}
KnowledgeBase.set(param_key(param.name), info)
# make list of params per node
params.append(param.name)
# ---
KnowledgeBase.set(node_key(node), list(set(params)))
def _diagnostics_topics_cb(data):
topic_key = lambda k, t: '/topic/%s%s' % (k, t)
node_key = lambda n: '/node/topics%s' % n
# nothing to do if the message is empty
if len(data.topics) <= 0:
return
# store info about topics
node = data.topics[0].node
topics = KnowledgeBase.get(node_key(node), {})
for topic in data.topics:
if is_infra_topic(topic.name):
continue
# ---
# store topic type
topic_type_str = TopicType(topic.type).name
KnowledgeBase.set(topic_key('type', topic.name), topic_type_str)
# compile topic info
info = {
'help': topic.help,
'message_type': None,
'type': topic_type_str,
# TODO: these should be averaged
'bandwidth': topic.bandwidth,
'frequency': topic.frequency,
'effective_frequency': topic.effective_frequency
}
KnowledgeBase.set(topic_key('info', topic.name), info)
# frequency
KnowledgeBase.set(topic_key('hz', topic.name), topic.frequency)
# bandwidth
KnowledgeBase.set(topic_key('bw', topic.name), topic.bandwidth)
# add topic to node topics
topics[topic.name] = {
'direction': TopicDirection(topic.direction).name,
'healthy_frequency': topic.healthy_frequency,
'processing_time': topic.processing_time,
'enabled': topic.enabled
}
topics[topic.name].update(info)
# store info about node topics
KnowledgeBase.set(node_key(node), topics)
def __init__(self):
super(ROS_HTTP_API_Node, self).__init__(
node_name='ros_http_api_node',
node_type=NodeType.INFRASTRUCTURE,
dt_ghost=True
)
# ---
# subscriber: diagnostics/ros/node
self._diagnostics_node_sub = SubscriberProvider(
apply_namespace(DIAGNOSTICS_ROS_NODE_TOPIC, 1),
DiagnosticsRosNode,
self._diagnostics_node_cb,
queue_size=100,
dt_ghost=True,
dt_timeout=-1
)
KnowledgeBase.register_provider('/node/info/', self._diagnostics_node_sub)
# subscriber: diagnostics/ros/topics
self._diagnostics_topics_sub = SubscriberProvider(
apply_namespace(DIAGNOSTICS_ROS_TOPICS_TOPIC, 1),
DiagnosticsRosTopicArray,
self._diagnostics_topics_cb,
queue_size=100,
dt_ghost=True,
dt_timeout=20
)
KnowledgeBase.register_provider('/node/topics/', self._diagnostics_topics_sub)
KnowledgeBase.register_provider('/topic/type/', self._diagnostics_topics_sub)
KnowledgeBase.register_provider('/topic/info/', self._diagnostics_topics_sub)
KnowledgeBase.register_provider('/topic/hz/', self._diagnostics_topics_sub)
KnowledgeBase.register_provider('/topic/bw/', self._diagnostics_topics_sub)
# subscriber: diagnostics/ros/parameters
self._diagnostics_params_sub = SubscriberProvider(
apply_namespace(DIAGNOSTICS_ROS_PARAMETERS_TOPIC, 1),
DiagnosticsRosParameterArray,
self._diagnostics_params_cb,
queue_size=100,
dt_ghost=True,
dt_timeout=-1
)
KnowledgeBase.register_provider('/node/params/', self._diagnostics_params_sub)
KnowledgeBase.register_provider('/param/info/', self._diagnostics_params_sub)
# subscriber: diagnostics/ros/links
self._diagnostics_links_sub = SubscriberProvider(
apply_namespace(DIAGNOSTICS_ROS_LINKS_TOPIC, 1),
DiagnosticsRosLinkArray,
self._diagnostics_links_cb,
queue_size=100,
dt_ghost=True,
dt_timeout=20
)
KnowledgeBase.register_provider('/node/links/', self._diagnostics_links_sub)
# rosgraph provider
self._graph_provider = RosGraphProvider()
KnowledgeBase.register_provider('/topic/publishers/', self._graph_provider)
KnowledgeBase.register_provider('/topic/subscribers/', self._graph_provider)
KnowledgeBase.register_provider('/topic/info/', self._graph_provider)
KnowledgeBase.register_provider('/topic/list/', self._graph_provider)
KnowledgeBase.register_provider('/service/list/', self._graph_provider)
KnowledgeBase.register_provider('/service/info/', self._graph_provider)
KnowledgeBase.register_provider('/service/providers/', self._graph_provider)
KnowledgeBase.register_provider('/node/list/', self._graph_provider)
KnowledgeBase.register_provider('/node/topics/', self._graph_provider)
KnowledgeBase.register_provider('/node/services/', self._graph_provider)
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))
