aboutsummaryrefslogtreecommitdiff
path: root/exporters-influxdb/pyExporter/oexport.py
diff options
context:
space:
mode:
Diffstat (limited to 'exporters-influxdb/pyExporter/oexport.py')
-rw-r--r--exporters-influxdb/pyExporter/oexport.py884
1 files changed, 884 insertions, 0 deletions
diff --git a/exporters-influxdb/pyExporter/oexport.py b/exporters-influxdb/pyExporter/oexport.py
new file mode 100644
index 0000000..03d1ba3
--- /dev/null
+++ b/exporters-influxdb/pyExporter/oexport.py
@@ -0,0 +1,884 @@
+"""
+Ouroboros InfluxDB metrics exporter
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided
+with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived
+from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+import os
+import re
+import socket
+import time
+from datetime import datetime
+from typing import Optional
+
+from influxdb_client import InfluxDBClient, Point
+from influxdb_client.client.write_api import WriteOptions, PointSettings
+from influxdb_client.rest import ApiException
+from pytz import utc
+
+IPCP_TYPE_UNICAST = 'unicast'
+IPCP_TYPE_BROADCAST = 'broadcast'
+IPCP_TYPE_UDP = 'udp'
+IPCP_TYPE_ETH_DIX = 'eth-dix'
+IPCP_TYPE_ETH_LLC = 'eth-llc'
+IPCP_TYPE_LOCAL = 'local'
+IPCP_TYPE_UNKNOWN = 'unknown'
+
+IPCP_TYPES = [IPCP_TYPE_UNICAST,
+ IPCP_TYPE_BROADCAST,
+ IPCP_TYPE_UDP,
+ IPCP_TYPE_ETH_DIX,
+ IPCP_TYPE_ETH_LLC,
+ IPCP_TYPE_LOCAL,
+ IPCP_TYPE_UNKNOWN]
+
+IPCP_STATE_NULL = 'null'
+IPCP_STATE_INIT = 'init'
+IPCP_STATE_OPERATIONAL = 'operational'
+IPCP_STATE_SHUTDOWN = 'shutdown'
+
+IPCP_STATES = [IPCP_STATE_NULL,
+ IPCP_STATE_INIT,
+ IPCP_STATE_OPERATIONAL,
+ IPCP_STATE_SHUTDOWN]
+
+
+class OuroborosRIBReader:
+ """
+ Class for reading stuff from the Ouroboros system
+ Resource Information Base (RIB)
+ """
+ def __init__(self,
+ rib_path: str):
+
+ self.rib_path = rib_path
+
+ def _get_dir_for_ipcp(self,
+ ipcp_name: str) -> str:
+
+ return os.path.join(self.rib_path, ipcp_name)
+
+ def _get_dir_for_process(self,
+ process_name: str) -> str:
+
+ return os.path.join(self.rib_path, process_name)
+
+ def _get_dt_dir_for_ipcp(self,
+ ipcp_name: str) -> Optional[str]:
+
+ path = self._get_dir_for_ipcp(ipcp_name)
+ try:
+ _subdirs = [f.name for f in os.scandir(path)]
+ except IOError as _:
+ return None
+
+ for _dir in _subdirs:
+ if len(_dir) > 3 and _dir[:3] == 'dt.':
+ return os.path.join(path, _dir)
+
+ return None
+
+ def _get_path_for_ipcp_flow_n_plus_1_info(self,
+ ipcp_name: str,
+ fd: str):
+
+ return os.path.join(self.rib_path, ipcp_name, 'flow-allocator', fd)
+
+ def _get_path_for_ipcp_flow_n_minus_1_info(self,
+ ipcp_name: str,
+ fd: str) -> str:
+
+ dt_dir = self._get_dt_dir_for_ipcp(ipcp_name)
+ return os.path.join(dt_dir, fd)
+
+ def _get_path_for_frct_flow_info(self,
+ process: str,
+ fd: str) -> str:
+
+ process_dir = self._get_dir_for_process(process)
+ return os.path.join(process_dir, str(fd), 'frct')
+
+ def _get_ipcp_type_for_ipcp(self,
+ ipcp_name: str) -> str:
+
+ _dir = self._get_dir_for_ipcp(ipcp_name)
+ path = '{}/info/_type'.format(_dir)
+ if not os.path.exists(path):
+ return IPCP_TYPE_UNKNOWN
+
+ try:
+ with open(path) as f:
+ return f.readline()[:-1]
+ except IOError as _:
+ return IPCP_TYPE_UNKNOWN
+
+ def _get_layer_name_for_ipcp(self,
+ ipcp_name: str) -> str:
+
+ _dir = self._get_dir_for_ipcp(ipcp_name)
+ path = '{}/info/_layer'.format(_dir)
+ if not os.path.exists(path):
+ return '(error)'
+
+ try:
+ with open(path) as f:
+ return f.readline()[:-1]
+ except IOError as _:
+ return '(error)'
+
+ def _get_ipcp_state_for_ipcp(self,
+ ipcp_name: str) -> str:
+
+ _dir = self._get_dir_for_ipcp(ipcp_name)
+ path = '{}/info/_state'.format(_dir)
+ if not os.path.exists(path):
+ return IPCP_TYPE_UNKNOWN
+
+ try:
+ with open(path) as f:
+ return f.readline()[:-1]
+ except IOError as e:
+ print(e)
+ return IPCP_TYPE_UNKNOWN
+
+ def _get_n_plus_1_flows_for_ipcp(self,
+ ipcp_name: str) -> list[str]:
+
+ path = os.path.join(self._get_dir_for_ipcp(ipcp_name), 'flow-allocator')
+
+ if not os.path.exists(path):
+ return []
+
+ try:
+ return [f.name for f in os.scandir(path)]
+ except IOError as e:
+ print(e)
+
+ return []
+
+ def _get_n_minus_1_flows_for_ipcp(self,
+ ipcp_name: str) -> list[str]:
+
+ path = self._get_dt_dir_for_ipcp(ipcp_name)
+ if path is None:
+ return []
+
+ if not os.path.exists(path):
+ return []
+
+ try:
+ return [f.name for f in os.scandir(path)]
+ except IOError as e:
+ print(e)
+ return []
+
+ def _get_address_for_ipcp(self,
+ ipcp_name):
+
+ _dir = self._get_dt_dir_for_ipcp(ipcp_name)
+ if _dir and len(_dir) > 3:
+ return _dir[3:]
+
+ return None
+
+ def get_lsdb_stats_for_ipcp(self,
+ ipcp_name: str) -> dict:
+ """
+ Get statistics for the link state database of an IPCP
+ :param ipcp_name: name of the IPCP
+ :return: statistics in a dict
+ """
+
+ address = self._get_address_for_ipcp(ipcp_name)
+ if address is None:
+ return {}
+
+ path = os.path.join(self._get_dir_for_ipcp(ipcp_name), 'lsdb/')
+ if not os.path.exists(path):
+ return {}
+
+ nodes = []
+ neighbors = 0
+ links = 0
+
+ lsdb_entries = []
+ try:
+ lsdb_entries = [f.path for f in os.scandir(path)]
+ except IOError as _:
+ pass
+
+ for lsdb_entry in lsdb_entries:
+ try:
+ with open(lsdb_entry) as e:
+ for line in e.readlines():
+ if 'src' in line:
+ src = line.split()[-1]
+ if src not in nodes:
+ nodes += [src]
+ if src == address:
+ neighbors += 1
+ if 'dst' in line:
+ dst = line.split()[-1]
+ if dst not in nodes:
+ nodes += [dst]
+ links += 1
+ except IOError as _:
+ continue
+
+ stats = {'neighbors': neighbors,
+ 'nodes': len(nodes),
+ 'links': links}
+
+ return stats
+
+ def _get_flows_for_process(self,
+ process_name: str) -> list[str]:
+ path = self._get_dir_for_process(process_name)
+
+ if not os.path.exists(path):
+ return []
+
+ try:
+ return [f.name for f in os.scandir(path) if f.is_dir()]
+ except IOError as e:
+ print(e)
+
+ return []
+
+ @staticmethod
+ def _get_trailing_number(s: str) -> int:
+ m = re.search(r'\d+$', s)
+ return int(m.group()) if m else None
+
+ def _get_flow_info_for_n_plus_1_flow(self,
+ ipcp_name: str,
+ fd: str) -> dict:
+
+ str_to_metric = {
+ 'Flow established at': None,
+ 'Remote address': None,
+ 'Local endpoint ID': 'endpoint_id',
+ 'Remote endpoint ID': None,
+ 'Sent (packets)': 'sent_pkts_total',
+ 'Sent (bytes)': 'sent_bytes_total',
+ 'Send failed (packets)': 'send_failed_packets_total',
+ 'Send failed (bytes)': 'send_failed_bytes_total',
+ 'Received (packets)': 'recv_pkts_total',
+ 'Received (bytes)': 'recv_bytes_total',
+ 'Receive failed (packets)': 'recv_failed_pkts_total',
+ 'Receive failed (bytes)': 'recv_failed_bytes_total',
+ 'Congestion avoidance algorithm': None,
+ 'Upstream congestion level': 'up_cong_lvl',
+ 'Downstream congestion level': 'down_cong_lvl',
+ 'Upstream packet counter': 'up_pkt_ctr',
+ 'Downstream packet counter': 'down_pkt_ctr',
+ 'Congestion window size (ns)': 'cong_wnd_width_ns',
+ 'Packets in this window': 'cong_wnd_current_pkts',
+ 'Bytes in this window': 'cong_wnd_current_bytes',
+ 'Max bytes in this window': 'cong_wnd_size_bytes',
+ 'Current congestion regime': None
+ }
+
+ ret = dict()
+
+ path = self._get_path_for_ipcp_flow_n_plus_1_info(ipcp_name, fd)
+
+ if not os.path.exists(path):
+ return dict()
+
+ with open(path) as f:
+ for line in f.readlines():
+ split_line = line.split(':')
+ phrase = split_line[0]
+ metric = str_to_metric[phrase]
+ if metric is not None:
+ value = self._get_trailing_number(split_line[1])
+ ret[metric] = value
+
+ return ret
+
+ def _get_frct_info_for_process_flow(self,
+ process: str,
+ fd: str) -> dict:
+
+ str_to_metric = {
+ 'Maximum packet lifetime (ns)': 'mpl_timer_ns',
+ 'Max time to Ack (ns)': 'a_timer_ns',
+ 'Max time to Retransmit (ns)': 'r_timer_ns',
+ 'Smoothed rtt (ns)': 'srtt_ns',
+ 'RTT standard deviation (ns)': 'mdev_ns',
+ 'Retransmit timeout RTO (ns)': 'rto_ns',
+ 'Sender left window edge': 'snd_lwe',
+ 'Sender right window edge': 'snd_rwe',
+ 'Sender inactive (ns)': 'snd_inact',
+ 'Sender current sequence number': 'snd_seqno',
+ 'Receiver left window edge': 'rcv_lwe',
+ 'Receiver right window edge': 'rcv_rwe',
+ 'Receiver inactive (ns)': 'rcv_inact',
+ 'Receiver last ack': 'rcv_seqno',
+ }
+
+ ret = dict()
+
+ path = self._get_path_for_frct_flow_info(process, fd)
+
+ if not os.path.exists(path):
+ return dict()
+
+ ret['fd'] = fd
+
+ with open(path) as f:
+ for line in f.readlines():
+ split_line = line.split(':')
+ phrase = split_line[0]
+ metric = str_to_metric[phrase]
+ if metric is not None:
+ value = self._get_trailing_number(split_line[1])
+ ret[metric] = value
+
+ return ret
+
+ def get_flow_allocator_flow_info_for_ipcp(self,
+ ipcp_name: str) -> list[dict]:
+ """
+ Get the flow intformation for all N+1 flows in a certain IPCP
+ :param ipcp_name: name of the IPCP
+ :return: dict with flow information
+ """
+ flow_info = []
+
+ flow_descriptors = self._get_n_plus_1_flows_for_ipcp(ipcp_name)
+ for flow in flow_descriptors:
+ info = self._get_flow_info_for_n_plus_1_flow(ipcp_name, flow)
+ flow_info += [info]
+
+ return flow_info
+
+ def _get_flow_info_for_n_minus_1_flow(self,
+ ipcp_name: str,
+ fd: str) -> dict:
+
+ ret = dict()
+
+ path = self._get_path_for_ipcp_flow_n_minus_1_info(ipcp_name, fd)
+
+ str_to_qos_metric = {
+ 'Flow established at': None,
+ ' sent (packets)': 'sent_packets_total',
+ ' sent (bytes)': 'sent_bytes_total',
+ ' rcvd (packets)': 'recv_packets_total',
+ ' rcvd (bytes)': 'recv_bytes_total',
+ ' local sent (packets)': 'local_sent_packets_total',
+ ' local sent (bytes)': 'local_sent_bytes_total',
+ ' local rcvd (packets)': 'local_recv_packets_total',
+ ' local rcvd (bytes)': 'local_recv_bytes_total',
+ ' dropped ttl (packets)': 'ttl_packets_dropped_total',
+ ' dropped ttl (bytes)': 'ttl_bytes_dropped_total',
+ ' failed writes (packets)': 'write_packets_dropped_total',
+ ' failed writes (bytes)': 'write_bytes_dropped_total',
+ ' failed nhop (packets)': 'nhop_packets_dropped_total',
+ ' failed nhop (bytes)': 'nhop_bytes_dropped_total'
+ }
+
+ if not os.path.exists(path):
+ return dict()
+
+ with open(path) as f:
+ _current_cube = ''
+ ret['fd'] = fd
+ for line in [_line for _line in f.readlines() if _line != '\n']:
+ if 'Endpoint address' in line:
+ ret['endpoint'] = line.split(':')[-1].replace(' ', '')[:-1]
+ elif 'Queued packets (rx)' in line:
+ ret['queued_packets_rx'] = self._get_trailing_number(line)
+ elif 'Queued packets (tx)' in line:
+ ret['queued_packets_tx'] = self._get_trailing_number(line)
+ elif 'Qos cube' in line:
+ _cube = self._get_trailing_number(line[:-2])
+ _current_cube = 'QoS cube ' + str(_cube)
+ ret[_current_cube] = dict()
+ else:
+ split_line = line.split(':')
+ metric = str_to_qos_metric[split_line[0]]
+ if metric is not None:
+ value = self._get_trailing_number(split_line[1])
+ ret[_current_cube][metric] = value
+
+ return ret
+
+ def get_data_transfer_flow_info_for_ipcp(self,
+ ipcp_name: str) -> list[dict]:
+ """
+ Get the flow information for all Data Transfer (N-1) flows in a certain IPCP
+ :param ipcp_name: name of the IPCP
+ :return: flow information for the data transfer flows
+ """
+
+ flow_info = []
+
+ flow_descriptors = self._get_n_minus_1_flows_for_ipcp(ipcp_name)
+ for flow in flow_descriptors:
+ info = self._get_flow_info_for_n_minus_1_flow(ipcp_name, flow)
+ flow_info += [info]
+
+ return flow_info
+
+ def get_frct_info_for_process(self,
+ process_name: str) -> list[dict]:
+ """
+ Get the frct information for all flows for a certain process
+ :param process_name: name of the process
+ :return: flow information for the N-1 flows
+ """
+
+ frct_info = []
+
+ flow_descriptors = self._get_flows_for_process(process_name)
+
+ for flow in flow_descriptors:
+ info = self._get_frct_info_for_process_flow(process_name, flow)
+ frct_info += [info]
+
+ return frct_info
+
+ # pylint: disable-msg=too-many-arguments
+ def get_ipcp_list(self,
+ names_only: bool = False, # return name and layer name
+ types: bool = True,
+ states: bool = True,
+ layers: bool = True,
+ flows: bool = True) -> list[dict]:
+ """
+ Get a list of all IPCPs
+ :param names_only: only return IPCP names and layer names
+ :param types: return IPCP type
+ :param states: return IPCP state
+ :param layers: return layer in which the IPCP is enrolled
+ :param flows: return the number of allocated (N+1) flows for this IPCP
+ :return: list of dicts containing IPCP info
+ """
+
+ ipcp_list = []
+
+ if not os.path.exists(self.rib_path):
+ return []
+
+ for ipcp_dir in [f.path for f in os.scandir(self.rib_path)
+ if f.is_dir() and not f.name.startswith('proc.')]:
+ ipcp_name = os.path.split(ipcp_dir)[-1]
+ ipcp_type = None
+ ipcp_state = None
+ ipcp_layer = self._get_layer_name_for_ipcp(ipcp_name) if layers else None
+ ipcp_flows = None
+ if not names_only:
+ ipcp_type = self._get_ipcp_type_for_ipcp(ipcp_name) if types else None
+ ipcp_state = self._get_ipcp_state_for_ipcp(ipcp_name) if states else None
+ ipcp_flows = self._get_n_plus_1_flows_for_ipcp(ipcp_name) if flows else None
+
+ ipcp_list += [{'name': ipcp_name,
+ 'type': ipcp_type,
+ 'state': ipcp_state,
+ 'layer': ipcp_layer,
+ 'flows': len(ipcp_flows) if ipcp_flows else None}]
+ return ipcp_list
+ # pylint: enable-msg=too-many-arguments
+
+ def get_process_list(self) -> list[str]:
+ """
+ Get a list of all the Ouroboros applications that may be exposing frct stats
+ :return: list of process names ("proc.<pid>")
+ """
+ proc_list = []
+
+ if not os.path.exists(self.rib_path):
+ return []
+
+ for proc in [f.name for f in os.scandir(self.rib_path)
+ if f.is_dir() and f.name.startswith('proc.')]:
+ proc_list += [proc]
+
+ return proc_list
+
+
+class OuroborosExporter:
+ """
+ Export Ouroboros metrics to InfluxDB
+ """
+
+ def __init__(self,
+ bucket='ouroboros-metrics',
+ config='/home/dstaesse/git/ouroboros_influx_exporter/config.ini',
+ rib_path='/tmp/ouroboros/'):
+
+ point_settings = PointSettings()
+ point_settings.add_default_tag('system', socket.gethostname())
+
+ write_options = WriteOptions(batch_size=500,
+ flush_interval=10_000,
+ jitter_interval=1_000,
+ retry_interval=1_000,
+ max_retries=5,
+ max_retry_delay=30_000,
+ exponential_base=2)
+
+ self.bucket = bucket
+ self.client = InfluxDBClient.from_config_file(config)
+ self.write_api = self.client.write_api(write_options=write_options,
+ point_settings=point_settings).write
+ self.query_api = self.client.query_api()
+ self.ribreader = OuroborosRIBReader(rib_path=rib_path)
+
+ def __exit__(self, _type, value, traceback):
+ self.client.close()
+
+ def _write_ouroboros_ipcps_total(self,
+ now,
+ ipcp_type,
+ n_ipcps):
+
+ point = {
+ 'measurement': 'ouroboros_{}_ipcps_total'.format(ipcp_type),
+ 'tags': {
+ 'type': ipcp_type,
+ },
+ 'fields': {
+ 'ipcps': n_ipcps,
+ 'time': str(now)
+ }
+ }
+
+ self.write_api(bucket=self.bucket,
+ record=Point.from_dict(point))
+
+ def _write_ouroboros_flow_allocator_flows_total(self,
+ now,
+ ipcp,
+ layer,
+ n_flows):
+ point = {
+ 'measurement': 'ouroboros_flow_allocator_flows_total',
+ 'tags': {
+ 'ipcp': ipcp,
+ 'layer': layer
+ },
+ 'fields': {
+ 'flows': n_flows,
+ 'time': str(now)
+ }
+ }
+
+ self.write_api(bucket=self.bucket,
+ record=Point.from_dict(point))
+
+ # pylint: disable-msg=too-many-arguments
+ def _write_ouroboros_fa_congestion_metric(self,
+ metric: str,
+ now: str,
+ ipcp_name: str,
+ eid: str,
+ layer,
+ value):
+
+ point = {
+ 'measurement': 'ouroboros_flow_allocator_' + metric,
+ 'tags': {
+ 'ipcp': ipcp_name,
+ 'layer': layer,
+ 'flow_id': eid
+ },
+ 'fields': {
+ metric: value,
+ 'time': now
+ }
+ }
+
+ try:
+ self.write_api(bucket=self.bucket,
+ record=Point.from_dict(point))
+ except ApiException as e:
+ print(e, point)
+
+ def _write_ouroboros_lsdb_node_metric(self,
+ metric: str,
+ now: str,
+ ipcp_name: str,
+ layer: str,
+ value):
+
+ point = {
+ 'measurement': 'ouroboros_lsdb_' + metric + '_total',
+ 'tags': {
+ 'ipcp': ipcp_name,
+ 'layer': layer
+ },
+ 'fields': {
+ metric: value,
+ 'time': now
+ }
+ }
+
+ try:
+ self.write_api(bucket=self.bucket,
+ record=Point.from_dict(point))
+ except ApiException as e:
+ print(e, point)
+
+ def _write_ouroboros_data_transfer_metric(self,
+ metric: str,
+ now: str,
+ qos_cube: str,
+ fd: str,
+ endpoint: str,
+ ipcp_name: str,
+ layer,
+ value):
+
+ point = {
+ 'measurement': 'ouroboros_data_transfer_' + metric,
+ 'tags': {
+ 'ipcp': ipcp_name,
+ 'layer': layer,
+ 'flow_descriptor': fd,
+ 'qos_cube': qos_cube,
+ 'endpoint': endpoint
+ },
+ 'fields': {
+ metric: value,
+ 'time': now
+ }
+ }
+
+ try:
+ self.write_api(bucket=self.bucket,
+ record=Point.from_dict(point))
+ except ApiException as e:
+ print(e, point)
+
+ def _write_ouroboros_data_transfer_queued(self,
+ now,
+ fd,
+ ipcp_name,
+ layer,
+ metrics) -> None:
+ point = dict()
+ for metric in metrics:
+ point = {
+ 'measurement': 'ouroboros_data_transfer_' + metric,
+ 'tags': {
+ 'ipcp': ipcp_name,
+ 'layer': layer,
+ 'flow_descriptor': fd,
+ },
+ 'fields': {
+ metric: metrics[metric],
+ 'time': now
+ }
+ }
+
+ try:
+ self.write_api(bucket=self.bucket,
+ record=Point.from_dict(point))
+ except ApiException as e:
+ print(e, point)
+
+ def _write_ouroboros_process_frct_metric(self,
+ now,
+ metric,
+ fd,
+ process,
+ value):
+ point = {
+ 'measurement': 'ouroboros_process_frct_' + metric,
+ 'tags': {
+ 'process': process,
+ 'flow_descriptor': fd,
+ },
+ 'fields': {
+ metric: value,
+ 'time': now
+ }
+ }
+
+ try:
+ self.write_api(bucket=self.bucket,
+ record=Point.from_dict(point))
+ except ApiException as e:
+ print(e, point)
+ # pylint: enable-msg=too-many-arguments
+
+ @staticmethod
+ def _filter_ipcp_list(ipcp_list: list[dict],
+ ipcp_type: str = None,
+ ipcp_state: str = None,
+ layer: str = None) -> list[dict]:
+
+ if ipcp_type not in IPCP_TYPES:
+ return []
+
+ if ipcp_type:
+ ipcp_list = [ipcp for ipcp in ipcp_list if ipcp['type'] == ipcp_type]
+
+ if ipcp_state:
+ ipcp_list = [ipcp for ipcp in ipcp_list if ipcp['state'] == ipcp_state]
+
+ if layer:
+ ipcp_list = [ipcp for ipcp in ipcp_list if ipcp['layer'] == layer]
+
+ return ipcp_list
+
+ def _export_ouroboros_ipcps_total(self):
+
+ ipcps = self.ribreader.get_ipcp_list()
+
+ ipcps_total = dict()
+
+ for _type in IPCP_TYPES:
+ ipcps_total[_type] = len(self._filter_ipcp_list(ipcps, ipcp_type=_type))
+
+ now = datetime.now(utc)
+
+ for _type, n_ipcps in ipcps_total.items():
+ self._write_ouroboros_ipcps_total(now, _type, n_ipcps)
+
+ def _export_ouroboros_flow_allocator_flows_total(self):
+
+ ipcps = self.ribreader.get_ipcp_list()
+
+ now = datetime.now(utc)
+
+ for ipcp in [ipcp for ipcp in ipcps if ipcp['flows'] is not None]:
+ self._write_ouroboros_flow_allocator_flows_total(now, ipcp['name'], ipcp['layer'], ipcp['flows'])
+
+ def _export_ouroboros_fa_congestion_metrics(self):
+
+ ipcps = self.ribreader.get_ipcp_list(names_only=True)
+
+ now = datetime.now(utc)
+
+ for ipcp in ipcps:
+ flows = self.ribreader.get_flow_allocator_flow_info_for_ipcp(ipcp['name'])
+ for flow in flows:
+ for metric in flow:
+ if metric == 'endpoint_id':
+ continue
+
+ self._write_ouroboros_fa_congestion_metric(metric,
+ str(now),
+ ipcp['name'],
+ flow['endpoint_id'],
+ ipcp['layer'],
+ flow[metric])
+
+ def _export_ouroboros_lsdb_metrics(self):
+
+ ipcps = self.ribreader.get_ipcp_list(names_only=True)
+
+ now = datetime.now(utc)
+
+ for ipcp in ipcps:
+ metrics = self.ribreader.get_lsdb_stats_for_ipcp(ipcp['name'])
+ for metric, value in metrics.items():
+ self._write_ouroboros_lsdb_node_metric(metric,
+ str(now),
+ ipcp['name'],
+ ipcp['layer'],
+ value)
+
+ def _export_ouroboros_data_transfer_metrics(self):
+ ipcps = self.ribreader.get_ipcp_list(names_only=True)
+
+ now = datetime.now(utc)
+
+ for ipcp in ipcps:
+ info = self.ribreader.get_data_transfer_flow_info_for_ipcp(ipcp['name'])
+ for flow in info:
+ qoscubes = [_field for _field in flow if str(_field).startswith('QoS cube')]
+ for qoscube in qoscubes:
+ for metric in flow[qoscube]:
+ self._write_ouroboros_data_transfer_metric(metric,
+ str(now),
+ qoscube,
+ flow['fd'],
+ flow['endpoint'],
+ ipcp['name'],
+ ipcp['layer'],
+ flow[qoscube][metric])
+ self._write_ouroboros_data_transfer_queued(str(now),
+ flow['fd'],
+ ipcp['name'],
+ ipcp['layer'],
+ {'queued_packets_rx': flow['queued_packets_rx'],
+ 'queued_packets_tx': flow['queued_packets_tx']})
+
+ def _export_ouroboros_process_frct_metrics(self):
+ processes = self.ribreader.get_process_list()
+
+ now = datetime.now(utc)
+
+ for process in processes:
+ for frct_info in self.ribreader.get_frct_info_for_process(process):
+ for metric in frct_info:
+ self._write_ouroboros_process_frct_metric(str(now),
+ metric,
+ frct_info['fd'],
+ process,
+ frct_info[metric])
+
+ def export(self):
+ """
+ Export all available metrics
+ :return:
+ """
+
+ self._export_ouroboros_ipcps_total()
+ self._export_ouroboros_flow_allocator_flows_total()
+ self._export_ouroboros_fa_congestion_metrics()
+ self._export_ouroboros_lsdb_metrics()
+ self._export_ouroboros_data_transfer_metrics()
+ self._export_ouroboros_process_frct_metrics()
+
+ def run(self,
+ interval_ms: float = 1000):
+ """
+ Run the ouroboros exporter
+
+ :param interval_ms: read interval in milliseconds
+ :return: None
+ """
+
+ while True:
+ time.sleep(interval_ms / 1000.0)
+ self.export()
+
+
+if __name__ == '__main__':
+
+ exporter = OuroborosExporter()
+ exporter.run(interval_ms=1000)