rnmon 0.1.0__py3-none-any.whl

rnmon/Databases.py

@@ -0,0 +1,37 @@
+import time
+import requests
+from random import randrange
+from collections import deque
+
+import RNS
+from . import MP
+
+class InfluxWriter:
+    def __init__(self, address: str, batch_size: int = 1000, flush_interval: int = 5, **kwargs):
+        self.maxlen = batch_size
+        self.flush_interval = flush_interval
+        self.flush_jitter = kwargs.setdefault('flush_jitter', 0)
+        self.address = address
+        self.http_headers = kwargs.setdefault('http_headers', None)
+        self.run()
+
+    def run(self):
+        last_push = time.time()
+        jitter = 0
+        RNS.log("[RNMon] Started InfluxWriter", RNS.LOG_INFO)
+        while not MP.terminate.is_set():
+            if len(MP.metric_queue) >= self.maxlen or (time.time() - last_push) >  (self.flush_interval + jitter):
+                data = []
+                try:
+                    for _ in range(self.maxlen):
+                        data.append(MP.metric_queue.pop())
+                except IndexError:
+                    pass
+                if data:
+                    RNS.log(f"[RNMon] Pushing metrics - Count: {len(data)} Time: {int(time.time() - last_push)}s", RNS.LOG_DEBUG)
+                    r = requests.post(self.address, headers=self.http_headers, data="\n".join(data))
+                last_push = time.time()
+                jitter = randrange(-self.flush_jitter, self.flush_jitter+1)
+            time.sleep(0.2)
+
+        RNS.log(f"[RNMon] Stopped InfluxWriter", RNS.LOG_INFO)

rnmon/Logging.py

@@ -0,0 +1,6 @@
+import logging
+
+
+log = logging.getLogger(__name__)
+
+log.setLevel(logging.INFO)

rnmon/MP.py

@@ -0,0 +1,5 @@
+import multiprocessing
+from collections import deque
+
+metric_queue = deque(maxlen=10000)
+terminate = multiprocessing.Event()

rnmon/RNSUtils.py

@@ -0,0 +1,77 @@
+import os
+import time
+
+import RNS
+from . import MP
+
+path_request_timeout = 30
+link_est_timeout = 30
+
+def establish_link(dest_identity: str, rpc_identity: os.PathLike, dest_type) -> RNS.Link:
+    mgmt_identity = read_rpc_identity(rpc_identity)
+    dest_hash = RNS.Destination.hash_from_name_and_identity( \
+                '.'.join(dest_type.ASPECTS), bytes.fromhex(dest_identity))
+    ensure_path(dest_hash)
+    RNS.log(f"[RNMon] Setting up Destination: {RNS.prettyhexrep(dest_hash)}", RNS.LOG_INFO)
+    remote_dest = RNS.Destination(
+        RNS.Identity.recall(dest_hash),
+        RNS.Destination.OUT,
+        RNS.Destination.SINGLE,
+        *dest_type.ASPECTS
+    )
+    RNS.log(f"[RNMon] Establishing a new link with {RNS.prettyhexrep(dest_hash)}", RNS.LOG_DEBUG)
+    link = RNS.Link(remote_dest)
+    link.set_link_established_callback(on_link_established(link, mgmt_identity))
+    link.set_link_closed_callback(on_link_closed)
+
+    start = time.time()
+    while link.status != RNS.Link.ACTIVE:
+        # Sometimes with multiple clients in a shared instance, it is possible that
+        # the establishment timeout is reset to PATHFINDER_M due to some edge cases
+        if time.time() - start > link_est_timeout:
+            RNS.log("[RNMon] Timed out waiting for link establishment", RNS.LOG_ERROR)
+            raise RuntimeError
+        RNS.log(f"[RNMon] Link to {dest_identity} Status: {link.status}", RNS.LOG_DEBUG)
+        time.sleep(1)
+    link.identify(mgmt_identity)
+    return link
+
+def on_link_established(link: RNS.Link, rpc_identity: RNS.Identity) -> None:
+    RNS.log("[RNMon] Link established with server", RNS.LOG_DEBUG)
+    RNS.log(f"[RNMon] KEEPALIVE interval: {link.KEEPALIVE}s, Stale time: {link.stale_time}s", RNS.LOG_DEBUG)
+
+def on_link_closed(link: RNS.Link) -> None:
+    reason = link.teardown_reason
+    if reason == RNS.Link.TIMEOUT:
+        RNS.log("[RNMon] The link timed out", RNS.LOG_WARNING)
+    elif reason == RNS.Link.DESTINATION_CLOSED:
+        RNS.log("[RNMon] The link was closed by the server", RNS.LOG_WARNING)
+    elif reason == RNS.Link.INITIATOR_CLOSED:
+        RNS.log("[RNMon] Closing link", RNS.LOG_ERROR)
+
+def ensure_path(dest_hash: bytes) -> None:
+    if not RNS.Transport.has_path(dest_hash):
+        RNS.log(f"[RNMon] No path to destination known. Requesting path and waiting for announce to arrive...")
+        RNS.Transport.request_path(dest_hash)
+        start = time.time()
+        while not RNS.Transport.has_path(dest_hash):
+            time.sleep(0.2)
+            # Abort if the path request is taking too long, for example if the next transport_node
+            # is not in a mode that does path discovery for us, it might take a while to discover the path
+            if time.time() - start > path_request_timeout:
+                RNS.log("[RNMon] Timed out waiting for path announcement", RNS.LOG_ERROR)
+                raise RuntimeError
+
+
+def read_rpc_identity(rpc_identity: os.PathLike) -> RNS.Identity:
+    mgmt_identity = RNS.Identity.from_file(os.path.expanduser(rpc_identity))
+    if not mgmt_identity:
+        raise FileNotFoundError(f"Failed to load identity from {rpc_identity}, check path and permissions.")
+    RNS.log(f"[RNMon] Loaded identity from '{rpc_identity}'", RNS.LOG_INFO)
+    return mgmt_identity
+
+
+def validate_hexhash(hexhash: str) -> None:
+        dest_len = (RNS.Reticulum.TRUNCATED_HASHLENGTH//8)*2
+        if len(hexhash) != dest_len:
+            raise TypeError(f"Destination length is invalid, must be {dest_len} hexadecimal characters ({dest_len//2} bytes)")

rnmon/Remotes.py

@@ -0,0 +1,138 @@
+import os
+import time
+from random import randrange
+
+import RNS
+from . import MP, RNSUtils
+
+class RNSTransportNode:
+    ASPECTS = ("rnstransport", "remote", "management")
+
+    NODE_METRICS = {
+        "rxb": "rns_transport_node_rx_bytes_total",
+        "txb": "rns_transport_node_tx_bytes_total",
+        "transport_uptime": "rns_transport_node_uptime_s",
+        "link_count": "rns_transport_node_link_count", # returned as second array element, unlabelled...
+    }
+    NODE_LABELS = {
+        "transport_id": "transport_id",
+    }
+    IFACE_METRICS = {
+        "clients": "rns_iface_client_count",
+        "bitrate": "rns_iface_bitrate",
+        "status": "rns_iface_up",
+        "mode": "rns_iface_mode",
+        "rxb": "rns_iface_rx_bytes_total",
+        "txb": "rns_iface_tx_bytes_total",
+        "held_announces": "rns_iface_announces_held_count",
+        "announce_queue": "rns_iface_announces_queue_count",
+        "incoming_announce_frequency": "rns_iface_announces_rx_rate",
+        "outgoing_announce_frequency": "rns_iface_announces_tx_rate",
+    }
+    IFACE_LABELS = {
+        "type": "type",
+    }
+
+    LPROTO_LABEL_TTABLE = str.maketrans({
+        " ": "\\ ",
+        ",": "\\,"
+    })
+
+    def __init__(self, interval: int, dest_identity: str, rpc_identity: os.PathLike, name: str, **kwargs) -> None:
+        self.link = RNSUtils.establish_link(dest_identity, rpc_identity, self)
+        self.interval = interval
+        self.collection_jitter = kwargs.setdefault('collection_jitter', 0)
+
+        # Used for metric labeling
+        self.node_name = name
+        self.dest_identity = dest_identity
+
+        self.request_timeout = self.link.rtt * self.link.traffic_timeout_factor + RNS.Resource.RESPONSE_MAX_GRACE_TIME*1.125
+        if self.request_timeout >= interval:
+            self.request_timeout = interval
+        RNS.log(f"[RNMon] Set Request timeout for '{self.node_name}': {self.request_timeout}s", RNS.LOG_EXTREME)
+
+
+
+        self.run()
+
+    def run(self) -> bool:
+        RNS.log(f"[RNMon] Starting RNSTransportNode scraper for '{self.node_name}'", RNS.LOG_INFO)
+        last_request_time = time.time()
+        jitter = 0
+        while not MP.terminate.is_set():
+            if self.link.status != RNS.Link.ACTIVE:
+                RNS.log(f"[RNMon] Link no longer active, stopping scraper for '{self.node_name}", RNS.LOG_DEBUG)
+                break
+            try:
+                # No point in spamming requests if the last one hasnt timed out yet, save local and network resources
+                if not self.link.pending_requests and ((time.time() - last_request_time) > (self.interval + jitter)):
+                    req = self.link.request(
+                        "/status",
+                        data = [True],
+                        response_callback = self._on_response,
+                        failed_callback = self._on_request_fail,
+                        timeout = self.request_timeout
+                    )
+                    last_request_time = time.time()
+                    jitter = randrange(-self.collection_jitter, self.collection_jitter+1)
+                    RNS.log(f"[RNMon] Sending request {RNS.prettyhexrep(req.request_id)} to '{self.node_name}'", RNS.LOG_EXTREME)
+            except Exception as e:
+                RNS.log(f"[RNMon] Error while sending request to '{self.node_name}': {str(e)}")
+
+            time.sleep(0.2)
+
+        RNS.log(f"[RNMon] Stopping RNSTransportNode scraper for '{self.node_name}'", RNS.LOG_INFO)
+        self.link.teardown()
+        return False
+
+    def _on_response(self, response) -> None:
+        self._parse_metrics(response.response)
+
+    def _on_request_fail(self, response) -> None:
+        RNS.log(f"[RNMon] The request {RNS.prettyhexrep(response.request_id)} to '{self.node_name}' failed.", RNS.LOG_DEBUG)
+
+    def _parse_metrics(self, data: list) -> None:
+        iface_labels = {}
+        iface_metrics = {}
+        node_labels = {}
+        node_metrics = {}
+        t = time.time_ns()
+
+        # link_count isnt labeled >.>
+        node_metrics[RNSTransportNode.NODE_METRICS['link_count']] = data[1]
+
+        for mk, mv in data[0].items():
+            if mk == 'interfaces':
+                for iface in mv:
+                    if iface['short_name'].startswith('Client on'):
+                        continue
+
+                    for k, v in iface.items():
+                        if k in RNSTransportNode.IFACE_METRICS:
+                            iface_metrics[RNSTransportNode.IFACE_METRICS[k]] = v
+                        if k in RNSTransportNode.IFACE_LABELS:
+                            iface_labels[RNSTransportNode.IFACE_LABELS[k]] = v
+
+                    iface_labels['name'] = iface['short_name']
+                    iface_labels['identity'] = self.dest_identity
+                    iface_labels['node_name'] = self.node_name
+
+                    # convert to influx line format
+                    labels = ",".join(f"{k}={v.translate(RNSTransportNode.LPROTO_LABEL_TTABLE)}" for k, v in iface_labels.items())
+                    for k, v in iface_metrics.items():
+                        metric = f"{k},{labels} value={v} {t}"
+                        MP.metric_queue.append(metric)
+
+            else:
+                if mk in RNSTransportNode.NODE_METRICS:
+                    node_metrics[RNSTransportNode.NODE_METRICS[mk]] = mv
+
+                node_labels['identity'] = self.dest_identity
+                node_labels['node_name'] = self.node_name
+
+                #convert to influx line format
+                labels = ",".join(f"{k}={v.translate(RNSTransportNode.LPROTO_LABEL_TTABLE)}" for k, v in node_labels.items())
+                for k, v in node_metrics.items():
+                    metric = f"{k},{labels} value={v} {t}"
+                    MP.metric_queue.append(metric)

rnmon/__main__.py

@@ -0,0 +1,3 @@
+from . import rnmon
+
+rnmon.main()

rnmon/rnmon.py

@@ -0,0 +1,84 @@
+import sys
+import time
+import signal
+import argparse
+import concurrent.futures
+
+from yaml import safe_load
+
+import RNS
+# RNS.Link.KEEPALIVE=10
+# RNS.Link.STALE_TIME=2*RNS.Link.KEEPALIVE
+# TODO: PR to have these be configurable as arguments to RNS.Link.__init__
+
+from .Databases import InfluxWriter
+from .Remotes import RNSTransportNode
+from . import MP, RNSUtils
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Simple request/response example")
+    parser.add_argument('-v', '--verbose', action='count', default=0)
+    parser.add_argument("--rns-config", type=str, default=None, \
+                        help="path to Reticulum config directory")
+    parser.add_argument("config", nargs='?', type=argparse.FileType('r'), default="scraping.yaml", \
+                        help="path to target list file")
+    args = parser.parse_args()
+
+    config = safe_load(args.config)
+
+    JOB_TYPES = {
+        "transport_node": RNSTransportNode,
+        "influx": InfluxWriter
+    }
+
+    # Init Reticulum instance
+    RNS.Reticulum(configdir=args.rns_config, verbosity=args.verbose)
+
+    def sig_handler(signum, frame):
+        MP.terminate.set()
+    signal.signal(signal.SIGINT, sig_handler)
+    signal.signal(signal.SIGTERM, sig_handler)
+
+    jobs = []
+    # Setup InfluxWriter push job
+    jobs.append({"type": "influx"} | config['influxdb'])
+    # Setup Scraping Jobs
+    for target in config['targets']:
+        RNSUtils.validate_hexhash(target['dest_identity'])
+        jobs.append({"verbosity": args.verbose} | target)
+
+    futures = {}
+    with concurrent.futures.ThreadPoolExecutor(len(jobs)) as executor:
+
+        for job in jobs:
+            futures[executor.submit(JOB_TYPES[job['type']], **job )] = job
+
+        while len(futures) > 0:
+            new_jobs = {}
+            done, not_done = concurrent.futures.wait(futures, return_when=concurrent.futures.FIRST_COMPLETED)
+            if MP.terminate.is_set():
+                break
+            for future in done:
+                job = futures[future]
+                if future.exception():
+                    RNS.log(f"[RNMon] Job exited with exception: \"{future.exception()}\"", RNS.LOG_WARNING)
+                    RNS.log(f"[RNMon] Job Exception Restart: {JOB_TYPES[job['type']]}", RNS.LOG_WARNING)
+                new_jobs[executor.submit(JOB_TYPES[job['type']], **job)] = job
+            for future in not_done:
+                job = futures[future]
+                new_jobs[future] = job
+            futures = new_jobs
+            time.sleep(1)
+
+
+    # RNS.exit() calls os._exit(), It does not clean things up properly
+    # and triggers semaphore_tracker:UserWarning since multiprocessing.resource_tracker
+    # is running, as intended, until it is terminated on main thread exit
+    # RNS.exit()
+    RNS.Reticulum.exit_handler()
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()

rnmon-0.1.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: rnmon
+Version: 0.1.0
+Summary: RNS Monitoring Agent
+Author: lbatalha
+Requires-Python: >=3.9
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: requests>=2.32.3
+Requires-Dist: rns>=0.9.6
+Description-Content-Type: text/markdown
+
+# RNMon - Reticulum Application Monitoring Daemon
+
+RNMon is a simple monitoring daemon designed to monitor the status of multiple RNS applications and push the metrics over http using the influx line protocol.
+
+## Installing
+
+## Configuration
+
+Configure the daemon via `scraping.yaml`, the example config has comments explaining the options.
+
+The configuration for reticulum is auto-discovered, but you can specify the location of the configuration directory using the `--rns-config` argument.
+
+## Operational principles
+
+The metric pusher and all targets are executed in their own thread. The main thread starts a new RNS instance, and closes it on exit.
+
+A link is established for each scrape target to reduce network overhead. If a link is broken for any reason, the thread is terminated and restarted - this avoids having to deal with the built-in RNS link retry mechanisms, their associated timeouts and any edge cases caused by using shared RNS intances. This might be changed in the future if RNS fixes the issues particular to this use case.

rnmon-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+rnmon/Databases.py,sha256=yUnGYjQDGlYdCYTaIKz0JQob7rN3FcqeoxpdRlYulUc,1463
+rnmon/Logging.py,sha256=eEtf_vyo--rgqXS8cePtIIPEU1jUWp6JbbFbpiNwqWM,79
+rnmon/MP.py,sha256=nub7xJQUYkG3aO6T42mZSHGJO5mII42R0eMxp9srU_c,125
+rnmon/RNSUtils.py,sha256=c9JEMP2yi9FmyDGf96I7O7kh-7Uf4biMSODdKX74i58,3552
+rnmon/Remotes.py,sha256=xzAfvTLeoiADkiY90VE0NCJEEhU-5J9cCto60UZc4Ps,5798
+rnmon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rnmon/__main__.py,sha256=xTyj40x3M7fIPfZbQ7xS4VvA8pRn6hw4dcMplsibdWY,34
+rnmon/rnmon.py,sha256=K7F2T06fStbm3UIg7CPsVdqurC5tnnxQlWzPisjDQ00,2866
+rnmon-0.1.0.dist-info/METADATA,sha256=MdsW3fIFCPPlubLflzGIMUj9FclFt66AaS77CbXkl2k,1297
+rnmon-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rnmon-0.1.0.dist-info/entry_points.txt,sha256=pKY8NEHRhxa8E9Q3H9TlkphkDFoaPwzrHkT4v8mPGsU,43
+rnmon-0.1.0.dist-info/RECORD,,

rnmon-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rnmon-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rnmon = rnmon.rnmon:main