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 _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 _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 _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_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 _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 _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))