aprsd 3.3.4__py2.py3-none-any.whl → 3.4.0__py2.py3-none-any.whl

aprsd/client.py

@@ -1,15 +1,18 @@
 import abc
+import datetime
 import logging
+import threading
 import time
 
 import aprslib
 from aprslib.exceptions import LoginError
 from oslo_config import cfg
+import wrapt
 
 from aprsd import exception
 from aprsd.clients import aprsis, fake, kiss
-from aprsd.packets import core, packet_list
-from aprsd.utils import trace
+from aprsd.packets import core
+from aprsd.utils import singleton, trace
 
 
 CONF = cfg.CONF
@@ -25,6 +28,34 @@ TRANSPORT_FAKE = "fake"
 factory = None
 
 
+@singleton
+class APRSClientStats:
+
+    lock = threading.Lock()
+
+    @wrapt.synchronized(lock)
+    def stats(self, serializable=False):
+        client = factory.create()
+        stats = {
+            "transport": client.transport(),
+            "filter": client.filter,
+            "connected": client.connected,
+        }
+
+        if client.transport() == TRANSPORT_APRSIS:
+            stats["server_string"] = client.client.server_string
+            keepalive = client.client.aprsd_keepalive
+            if serializable:
+                keepalive = keepalive.isoformat()
+            stats["server_keepalive"] = keepalive
+        elif client.transport() == TRANSPORT_TCPKISS:
+            stats["host"] = CONF.kiss_tcp.host
+            stats["port"] = CONF.kiss_tcp.port
+        elif client.transport() == TRANSPORT_SERIALKISS:
+            stats["device"] = CONF.kiss_serial.device
+        return stats
+
+
 class Client:
     """Singleton client class that constructs the aprslib connection."""
 
@@ -32,16 +63,21 @@ class Client:
     _client = None
 
     connected = False
-    server_string = None
     filter = None
+    lock = threading.Lock()
 
     def __new__(cls, *args, **kwargs):
         """This magic turns this into a singleton."""
         if cls._instance is None:
             cls._instance = super().__new__(cls)
             # Put any initialization here.
+            cls._instance._create_client()
         return cls._instance
 
+    @abc.abstractmethod
+    def stats(self) -> dict:
+        pass
+
     def set_filter(self, filter):
         self.filter = filter
         if self._client:
@@ -50,21 +86,32 @@ class Client:
     @property
     def client(self):
         if not self._client:
-            LOG.info("Creating APRS client")
-            self._client = self.setup_connection()
-            if self.filter:
-                LOG.info("Creating APRS client filter")
-                self._client.set_filter(self.filter)
+            self._create_client()
         return self._client
 
+    def _create_client(self):
+        self._client = self.setup_connection()
+        if self.filter:
+            LOG.info("Creating APRS client filter")
+            self._client.set_filter(self.filter)
+
+    def stop(self):
+        if self._client:
+            LOG.info("Stopping client connection.")
+            self._client.stop()
+
     def send(self, packet: core.Packet):
-        packet_list.PacketList().tx(packet)
+        """Send a packet to the network."""
         self.client.send(packet)
 
+    @wrapt.synchronized(lock)
     def reset(self):
         """Call this to force a rebuild/reconnect."""
+        LOG.info("Resetting client connection.")
         if self._client:
+            self._client.close()
             del self._client
+            self._create_client()
         else:
             LOG.warning("Client not initialized, nothing to reset.")
 
@@ -89,11 +136,38 @@ class Client:
     def decode_packet(self, *args, **kwargs):
         pass
 
+    @abc.abstractmethod
+    def consumer(self, callback, blocking=False, immortal=False, raw=False):
+        pass
+
+    @abc.abstractmethod
+    def is_alive(self):
+        pass
+
+    @abc.abstractmethod
+    def close(self):
+        pass
+
 
 class APRSISClient(Client):
 
     _client = None
 
+    def __init__(self):
+        max_timeout = {"hours": 0.0, "minutes": 2, "seconds": 0}
+        self.max_delta = datetime.timedelta(**max_timeout)
+
+    def stats(self) -> dict:
+        stats = {}
+        if self.is_configured():
+            stats = {
+                "server_string": self._client.server_string,
+                "sever_keepalive": self._client.aprsd_keepalive,
+                "filter": self.filter,
+            }
+
+        return stats
+
     @staticmethod
     def is_enabled():
         # Defaults to True if the enabled flag is non existent
@@ -125,44 +199,56 @@ class APRSISClient(Client):
             return True
         return True
 
+    def _is_stale_connection(self):
+        delta = datetime.datetime.now() - self._client.aprsd_keepalive
+        if delta > self.max_delta:
+            LOG.error(f"Connection is stale, last heard {delta} ago.")
+            return True
+
     def is_alive(self):
         if self._client:
-            return self._client.is_alive()
+            return self._client.is_alive() and not self._is_stale_connection()
         else:
+            LOG.warning(f"APRS_CLIENT {self._client} alive? NO!!!")
             return False
 
+    def close(self):
+        if self._client:
+            self._client.stop()
+            self._client.close()
+
     @staticmethod
     def transport():
         return TRANSPORT_APRSIS
 
     def decode_packet(self, *args, **kwargs):
         """APRS lib already decodes this."""
-        return core.Packet.factory(args[0])
+        return core.factory(args[0])
 
     def setup_connection(self):
         user = CONF.aprs_network.login
         password = CONF.aprs_network.password
         host = CONF.aprs_network.host
         port = CONF.aprs_network.port
-        connected = False
+        self.connected = False
         backoff = 1
         aprs_client = None
-        while not connected:
+        while not self.connected:
             try:
-                LOG.info("Creating aprslib client")
+                LOG.info(f"Creating aprslib client({host}:{port}) and logging in {user}.")
                 aprs_client = aprsis.Aprsdis(user, passwd=password, host=host, port=port)
                 # Force the log to be the same
                 aprs_client.logger = LOG
                 aprs_client.connect()
-                connected = True
+                self.connected = True
                 backoff = 1
             except LoginError as e:
                 LOG.error(f"Failed to login to APRS-IS Server '{e}'")
-                connected = False
+                self.connected = False
                 time.sleep(backoff)
             except Exception as e:
                 LOG.error(f"Unable to connect to APRS-IS server. '{e}' ")
-                connected = False
+                self.connected = False
                 time.sleep(backoff)
                 # Don't allow the backoff to go to inifinity.
                 if backoff > 5:
@@ -170,15 +256,28 @@ class APRSISClient(Client):
                 else:
                     backoff += 1
                 continue
-        LOG.debug(f"Logging in to APRS-IS with user '{user}'")
         self._client = aprs_client
         return aprs_client
 
+    def consumer(self, callback, blocking=False, immortal=False, raw=False):
+        self._client.consumer(
+            callback, blocking=blocking,
+            immortal=immortal, raw=raw,
+        )
+
 
 class KISSClient(Client):
 
     _client = None
 
+    def stats(self) -> dict:
+        stats = {}
+        if self.is_configured():
+            return {
+                "transport": self.transport(),
+            }
+        return stats
+
     @staticmethod
     def is_enabled():
         """Return if tcp or serial KISS is enabled."""
@@ -217,6 +316,10 @@ class KISSClient(Client):
         else:
             return False
 
+    def close(self):
+        if self._client:
+            self._client.stop()
+
     @staticmethod
     def transport():
         if CONF.kiss_serial.enabled:
@@ -238,7 +341,7 @@ class KISSClient(Client):
         # LOG.debug(f"Decoding {msg}")
 
         raw = aprslib.parse(str(frame))
-        packet = core.Packet.factory(raw)
+        packet = core.factory(raw)
         if isinstance(packet, core.ThirdParty):
             return packet.subpacket
         else:
@@ -246,11 +349,18 @@ class KISSClient(Client):
 
     def setup_connection(self):
         self._client = kiss.KISS3Client()
+        self.connected = True
         return self._client
 
+    def consumer(self, callback, blocking=False, immortal=False, raw=False):
+        self._client.consumer(callback)
+
 
 class APRSDFakeClient(Client, metaclass=trace.TraceWrapperMetaclass):
 
+    def stats(self) -> dict:
+        return {}
+
     @staticmethod
     def is_enabled():
         if CONF.fake_client.enabled:
@@ -264,7 +374,11 @@ class APRSDFakeClient(Client, metaclass=trace.TraceWrapperMetaclass):
     def is_alive(self):
         return True
 
+    def close(self):
+        pass
+
     def setup_connection(self):
+        self.connected = True
         return fake.APRSDFakeClient()
 
     @staticmethod
@@ -304,7 +418,6 @@ class ClientFactory:
                 key = TRANSPORT_FAKE
 
         builder = self._builders.get(key)
-        LOG.debug(f"Creating client {key}")
         if not builder:
             raise ValueError(key)
         return builder()

aprsd/clients/aprsis.py

@@ -1,3 +1,4 @@
+import datetime
 import logging
 import select
 import threading
@@ -11,7 +12,6 @@ from aprslib.exceptions import (
 import wrapt
 
 import aprsd
-from aprsd import stats
 from aprsd.packets import core
 
 
@@ -24,6 +24,9 @@ class Aprsdis(aprslib.IS):
     # flag to tell us to stop
     thread_stop = False
 
+    # date for last time we heard from the server
+    aprsd_keepalive = datetime.datetime.now()
+
     # timeout in seconds
     select_timeout = 1
     lock = threading.Lock()
@@ -142,7 +145,6 @@ class Aprsdis(aprslib.IS):
 
             self.logger.info(f"Connected to {server_string}")
             self.server_string = server_string
-            stats.APRSDStats().set_aprsis_server(server_string)
 
         except LoginError as e:
             self.logger.error(str(e))
@@ -176,13 +178,14 @@ class Aprsdis(aprslib.IS):
             try:
                 for line in self._socket_readlines(blocking):
                     if line[0:1] != b"#":
+                        self.aprsd_keepalive = datetime.datetime.now()
                         if raw:
                             callback(line)
                         else:
                             callback(self._parse(line))
                     else:
                         self.logger.debug("Server: %s", line.decode("utf8"))
-                        stats.APRSDStats().set_aprsis_keepalive()
+                        self.aprsd_keepalive = datetime.datetime.now()
             except ParseError as exp:
                 self.logger.log(
                     11,

aprsd/clients/fake.py

@@ -67,7 +67,7 @@ class APRSDFakeClient(metaclass=trace.TraceWrapperMetaclass):
         # Generate packets here?
         raw = "GTOWN>APDW16,WIDE1-1,WIDE2-1:}KM6LYW-9>APZ100,TCPIP,GTOWN*::KM6LYW   :KM6LYW: 19 Miles SW"
         pkt_raw = aprslib.parse(raw)
-        pkt = core.Packet.factory(pkt_raw)
+        pkt = core.factory(pkt_raw)
         callback(packet=pkt)
         LOG.debug(f"END blocking FAKE consumer {self}")
         time.sleep(8)

aprsd/clients/kiss.py

@@ -81,7 +81,7 @@ class KISS3Client:
             LOG.error("Failed to parse bytes received from KISS interface.")
             LOG.exception(ex)
 
-    def consumer(self, callback, blocking=False, immortal=False, raw=False):
+    def consumer(self, callback):
         LOG.debug("Start blocking KISS consumer")
         self._parse_callback = callback
         self.kiss.read(callback=self.parse_frame, min_frames=None)

aprsd/cmds/completion.py

@@ -1,5 +1,5 @@
 import click
-import click_completion
+import click.shell_completion
 
 from aprsd.main import cli
 
@@ -7,30 +7,16 @@ from aprsd.main import cli
 CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
 
 
-@cli.group(help="Click Completion subcommands", context_settings=CONTEXT_SETTINGS)
-@click.pass_context
-def completion(ctx):
-    pass
+@cli.command()
+@click.argument("shell", type=click.Choice(list(click.shell_completion._available_shells)))
+def completion(shell):
+    """Show the shell completion code"""
+    from click.utils import _detect_program_name
 
-
-# show dumps out the completion code for a particular shell
-@completion.command(help="Show completion code for shell", name="show")
-@click.option("-i", "--case-insensitive/--no-case-insensitive", help="Case insensitive completion")
-@click.argument("shell", required=False, type=click_completion.DocumentedChoice(click_completion.core.shells))
-def show(shell, case_insensitive):
-    """Show the click-completion-command completion code"""
-    extra_env = {"_CLICK_COMPLETION_COMMAND_CASE_INSENSITIVE_COMPLETE": "ON"} if case_insensitive else {}
-    click.echo(click_completion.core.get_code(shell, extra_env=extra_env))
-
-
-# install will install the completion code for a particular shell
-@completion.command(help="Install completion code for a shell", name="install")
-@click.option("--append/--overwrite", help="Append the completion code to the file", default=None)
-@click.option("-i", "--case-insensitive/--no-case-insensitive", help="Case insensitive completion")
-@click.argument("shell", required=False, type=click_completion.DocumentedChoice(click_completion.core.shells))
-@click.argument("path", required=False)
-def install(append, case_insensitive, shell, path):
-    """Install the click-completion-command completion"""
-    extra_env = {"_CLICK_COMPLETION_COMMAND_CASE_INSENSITIVE_COMPLETE": "ON"} if case_insensitive else {}
-    shell, path = click_completion.core.install(shell=shell, path=path, append=append, extra_env=extra_env)
-    click.echo(f"{shell} completion installed in {path}")
+    cls = click.shell_completion.get_completion_class(shell)
+    prog_name = _detect_program_name()
+    complete_var = f"_{prog_name}_COMPLETE".replace("-", "_").upper()
+    print(cls(cli, {}, prog_name, complete_var).source())
+    print("# Add the following line to your shell configuration file to have aprsd command line completion")
+    print("# but remove the leading '#' character.")
+    print(f"# eval \"$(aprsd completion {shell})\"")

aprsd/cmds/fetch_stats.py

@@ -1,10 +1,9 @@
-# Fetch active stats from a remote running instance of aprsd server
-# This uses the RPC server to fetch the stats from the remote server.
-
+# Fetch active stats from a remote running instance of aprsd admin web interface.
 import logging
 
 import click
 from oslo_config import cfg
+import requests
 from rich.console import Console
 from rich.table import Table
 
@@ -12,7 +11,6 @@ from rich.table import Table
 import aprsd
 from aprsd import cli_helper
 from aprsd.main import cli
-from aprsd.rpc import client as rpc_client
 
 
 # setup the global logger
@@ -26,87 +24,80 @@ CONF = cfg.CONF
 @click.option(
     "--host", type=str,
     default=None,
-    help="IP address of the remote aprsd server to fetch stats from.",
+    help="IP address of the remote aprsd admin web ui fetch stats from.",
 )
 @click.option(
     "--port", type=int,
     default=None,
-    help="Port of the remote aprsd server rpc port to fetch stats from.",
-)
-@click.option(
-    "--magic-word", type=str,
-    default=None,
-    help="Magic word of the remote aprsd server rpc port to fetch stats from.",
+    help="Port of the remote aprsd web admin interface to fetch stats from.",
 )
 @click.pass_context
 @cli_helper.process_standard_options
-def fetch_stats(ctx, host, port, magic_word):
-    """Fetch stats from a remote running instance of aprsd server."""
-    LOG.info(f"APRSD Fetch-Stats started version: {aprsd.__version__}")
+def fetch_stats(ctx, host, port):
+    """Fetch stats from a APRSD admin web interface."""
+    console = Console()
+    console.print(f"APRSD Fetch-Stats started version: {aprsd.__version__}")
 
     CONF.log_opt_values(LOG, logging.DEBUG)
     if not host:
-        host = CONF.rpc_settings.ip
+        host = CONF.admin.web_ip
     if not port:
-        port = CONF.rpc_settings.port
-    if not magic_word:
-        magic_word = CONF.rpc_settings.magic_word
+        port = CONF.admin.web_port
 
-    msg = f"Fetching stats from {host}:{port} with magic word '{magic_word}'"
-    console = Console()
+    msg = f"Fetching stats from {host}:{port}"
     console.print(msg)
     with console.status(msg):
-        client = rpc_client.RPCClient(host, port, magic_word)
-        stats = client.get_stats_dict()
-        if stats:
-            console.print_json(data=stats)
-        else:
-            LOG.error(f"Failed to fetch stats via RPC aprsd server at {host}:{port}")
+        response = requests.get(f"http://{host}:{port}/stats", timeout=120)
+        if not response:
+            console.print(
+                f"Failed to fetch stats from {host}:{port}?",
+                style="bold red",
+            )
             return
+
+        stats = response.json()
+        if not stats:
+            console.print(
+                f"Failed to fetch stats from aprsd admin ui at {host}:{port}",
+                style="bold red",
+            )
+            return
+
     aprsd_title = (
         "APRSD "
-        f"[bold cyan]v{stats['aprsd']['version']}[/] "
-        f"Callsign [bold green]{stats['aprsd']['callsign']}[/] "
-        f"Uptime [bold yellow]{stats['aprsd']['uptime']}[/]"
+        f"[bold cyan]v{stats['APRSDStats']['version']}[/] "
+        f"Callsign [bold green]{stats['APRSDStats']['callsign']}[/] "
+        f"Uptime [bold yellow]{stats['APRSDStats']['uptime']}[/]"
     )
 
-    console.rule(f"Stats from {host}:{port} with magic word '{magic_word}'")
+    console.rule(f"Stats from {host}:{port}")
     console.print("\n\n")
     console.rule(aprsd_title)
 
     # Show the connection to APRS
     # It can be a connection to an APRS-IS server or a local TNC via KISS or KISSTCP
     if "aprs-is" in stats:
-        title = f"APRS-IS Connection {stats['aprs-is']['server']}"
+        title = f"APRS-IS Connection {stats['APRSClientStats']['server_string']}"
         table = Table(title=title)
         table.add_column("Key")
         table.add_column("Value")
-        for key, value in stats["aprs-is"].items():
+        for key, value in stats["APRSClientStats"].items():
             table.add_row(key, value)
         console.print(table)
 
     threads_table = Table(title="Threads")
     threads_table.add_column("Name")
     threads_table.add_column("Alive?")
-    for name, alive in stats["aprsd"]["threads"].items():
+    for name, alive in stats["APRSDThreadList"].items():
         threads_table.add_row(name, str(alive))
 
     console.print(threads_table)
 
-    msgs_table = Table(title="Messages")
-    msgs_table.add_column("Key")
-    msgs_table.add_column("Value")
-    for key, value in stats["messages"].items():
-        msgs_table.add_row(key, str(value))
-
-    console.print(msgs_table)
-
     packet_totals = Table(title="Packet Totals")
     packet_totals.add_column("Key")
     packet_totals.add_column("Value")
-    packet_totals.add_row("Total Received", str(stats["packets"]["total_received"]))
-    packet_totals.add_row("Total Sent", str(stats["packets"]["total_sent"]))
-    packet_totals.add_row("Total Tracked", str(stats["packets"]["total_tracked"]))
+    packet_totals.add_row("Total Received", str(stats["PacketList"]["rx"]))
+    packet_totals.add_row("Total Sent", str(stats["PacketList"]["tx"]))
     console.print(packet_totals)
 
     # Show each of the packet types
@@ -114,47 +105,52 @@ def fetch_stats(ctx, host, port, magic_word):
     packets_table.add_column("Packet Type")
     packets_table.add_column("TX")
     packets_table.add_column("RX")
-    for key, value in stats["packets"]["by_type"].items():
+    for key, value in stats["PacketList"]["packets"].items():
         packets_table.add_row(key, str(value["tx"]), str(value["rx"]))
 
     console.print(packets_table)
 
     if "plugins" in stats:
-        count = len(stats["plugins"])
+        count = len(stats["PluginManager"])
         plugins_table = Table(title=f"Plugins ({count})")
         plugins_table.add_column("Plugin")
         plugins_table.add_column("Enabled")
         plugins_table.add_column("Version")
         plugins_table.add_column("TX")
         plugins_table.add_column("RX")
-        for key, value in stats["plugins"].items():
+        plugins = stats["PluginManager"]
+        for key, value in plugins.items():
             plugins_table.add_row(
                 key,
-                str(stats["plugins"][key]["enabled"]),
-                stats["plugins"][key]["version"],
-                str(stats["plugins"][key]["tx"]),
-                str(stats["plugins"][key]["rx"]),
+                str(plugins[key]["enabled"]),
+                plugins[key]["version"],
+                str(plugins[key]["tx"]),
+                str(plugins[key]["rx"]),
             )
 
         console.print(plugins_table)
 
-    if "seen_list" in stats["aprsd"]:
-        count = len(stats["aprsd"]["seen_list"])
+    seen_list = stats.get("SeenList")
+
+    if seen_list:
+        count = len(seen_list)
         seen_table = Table(title=f"Seen List ({count})")
         seen_table.add_column("Callsign")
         seen_table.add_column("Message Count")
         seen_table.add_column("Last Heard")
-        for key, value in stats["aprsd"]["seen_list"].items():
+        for key, value in seen_list.items():
             seen_table.add_row(key, str(value["count"]), value["last"])
 
         console.print(seen_table)
 
-    if "watch_list" in stats["aprsd"]:
-        count = len(stats["aprsd"]["watch_list"])
+    watch_list = stats.get("WatchList")
+
+    if watch_list:
+        count = len(watch_list)
         watch_table = Table(title=f"Watch List ({count})")
         watch_table.add_column("Callsign")
         watch_table.add_column("Last Heard")
-        for key, value in stats["aprsd"]["watch_list"].items():
+        for key, value in watch_list.items():
             watch_table.add_row(key, value["last"])
 
         console.print(watch_table)