aprsd 3.4.3__py3-none-any.whl → 4.0.0__py3-none-any.whl

aprsd/packets/packet_list.py

@@ -1,18 +1,18 @@
-from collections import OrderedDict
 import logging
+from collections import OrderedDict
 
 from oslo_config import cfg
 
 from aprsd.packets import core
 from aprsd.utils import objectstore
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
 
 class PacketList(objectstore.ObjectStoreMixin):
     """Class to keep track of the packets we tx/rx."""
+
     _instance = None
     _total_rx: int = 0
     _total_tx: int = 0
@@ -37,9 +37,11 @@ class PacketList(objectstore.ObjectStoreMixin):
             self._total_rx += 1
             self._add(packet)
             ptype = packet.__class__.__name__
-            if ptype not in self.data["types"]:
-                self.data["types"][ptype] = {"tx": 0, "rx": 0}
-            self.data["types"][ptype]["rx"] += 1
+            type_stats = self.data["types"].setdefault(
+                ptype,
+                {"tx": 0, "rx": 0},
+            )
+            type_stats["rx"] += 1
 
     def tx(self, packet: type[core.Packet]):
         """Add a packet that was received."""
@@ -47,9 +49,11 @@ class PacketList(objectstore.ObjectStoreMixin):
             self._total_tx += 1
             self._add(packet)
             ptype = packet.__class__.__name__
-            if ptype not in self.data["types"]:
-                self.data["types"][ptype] = {"tx": 0, "rx": 0}
-            self.data["types"][ptype]["tx"] += 1
+            type_stats = self.data["types"].setdefault(
+                ptype,
+                {"tx": 0, "rx": 0},
+            )
+            type_stats["tx"] += 1
 
     def add(self, packet):
         with self.lock:
@@ -81,28 +85,17 @@ class PacketList(objectstore.ObjectStoreMixin):
             return self._total_tx
 
     def stats(self, serializable=False) -> dict:
-        # limit the number of packets to return to 50
         with self.lock:
-            tmp = OrderedDict(
-                reversed(
-                    list(
-                        self.data.get("packets", OrderedDict()).items(),
-                    ),
-                ),
-            )
-            pkts = []
-            count = 1
-            for packet in tmp:
-                pkts.append(tmp[packet])
-                count += 1
-                if count > CONF.packet_list_stats_maxlen:
-                    break
+            # Get last N packets directly using list slicing
+            packets_list = list(self.data.get("packets", {}).values())
+            pkts = packets_list[-CONF.packet_list_stats_maxlen :][::-1]
 
             stats = {
-                "total_tracked": self._total_rx + self._total_rx,
+                "total_tracked": self._total_rx
+                + self._total_tx,  # Fixed typo: was rx + rx
                 "rx": self._total_rx,
                 "tx": self._total_tx,
-                "types": self.data.get("types", []),
+                "types": self.data.get("types", {}),  # Changed default from [] to {}
                 "packet_count": len(self.data.get("packets", [])),
                 "maxlen": self.maxlen,
                 "packets": pkts,

aprsd/plugin.py

@@ -8,14 +8,13 @@ import re
 import textwrap
 import threading
 
-from oslo_config import cfg
 import pluggy
+from oslo_config import cfg
 
 import aprsd
 from aprsd import client, packets, threads
 from aprsd.packets import watch_list
 
-
 # setup the global logger
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
@@ -166,7 +165,8 @@ class APRSDWatchListPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
                 except Exception as ex:
                     LOG.error(
                         "Plugin {} failed to process packet {}".format(
-                            self.__class__, ex,
+                            self.__class__,
+                            ex,
                         ),
                     )
                 if result:
@@ -214,7 +214,9 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
             return result
 
         if not isinstance(packet, packets.MessagePacket):
-            LOG.warning(f"{self.__class__.__name__} Got a {packet.__class__.__name__} ignoring")
+            LOG.warning(
+                f"{self.__class__.__name__} Got a {packet.__class__.__name__} ignoring"
+            )
             return packets.NULL_MESSAGE
 
         result = None
@@ -236,7 +238,8 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
                 except Exception as ex:
                     LOG.error(
                         "Plugin {} failed to process packet {}".format(
-                            self.__class__, ex,
+                            self.__class__,
+                            ex,
                         ),
                     )
                     LOG.exception(ex)
@@ -286,7 +289,8 @@ class HelpPlugin(APRSDRegexCommandPluginBase):
             reply = None
             for p in pm.get_plugins():
                 if (
-                    p.enabled and isinstance(p, APRSDRegexCommandPluginBase)
+                    p.enabled
+                    and isinstance(p, APRSDRegexCommandPluginBase)
                     and p.command_name.lower() == command_name
                 ):
                     reply = p.help()
@@ -345,6 +349,7 @@ class PluginManager:
 
     def stats(self, serializable=False) -> dict:
         """Collect and return stats for all plugins."""
+
         def full_name_with_qualname(obj):
             return "{}.{}".format(
                 obj.__class__.__module__,
@@ -354,7 +359,6 @@ class PluginManager:
         plugin_stats = {}
         plugins = self.get_plugins()
         if plugins:
-
             for p in plugins:
                 plugin_stats[full_name_with_qualname(p)] = {
                     "enabled": p.enabled,
@@ -439,7 +443,9 @@ class PluginManager:
                         )
                         self._watchlist_pm.register(plugin_obj)
                     else:
-                        LOG.warning(f"Plugin {plugin_obj.__class__.__name__} is disabled")
+                        LOG.warning(
+                            f"Plugin {plugin_obj.__class__.__name__} is disabled"
+                        )
                 elif isinstance(plugin_obj, APRSDRegexCommandPluginBase):
                     if plugin_obj.enabled:
                         LOG.info(
@@ -451,7 +457,9 @@ class PluginManager:
                         )
                         self._pluggy_pm.register(plugin_obj)
                     else:
-                        LOG.warning(f"Plugin {plugin_obj.__class__.__name__} is disabled")
+                        LOG.warning(
+                            f"Plugin {plugin_obj.__class__.__name__} is disabled"
+                        )
                 elif isinstance(plugin_obj, APRSDPluginBase):
                     if plugin_obj.enabled:
                         LOG.info(
@@ -462,7 +470,9 @@ class PluginManager:
                         )
                         self._pluggy_pm.register(plugin_obj)
                     else:
-                        LOG.warning(f"Plugin {plugin_obj.__class__.__name__} is disabled")
+                        LOG.warning(
+                            f"Plugin {plugin_obj.__class__.__name__} is disabled"
+                        )
         except Exception as ex:
             LOG.error(f"Couldn't load plugin '{plugin_name}'")
             LOG.exception(ex)
@@ -470,9 +480,13 @@ class PluginManager:
     def reload_plugins(self):
         with self.lock:
             del self._pluggy_pm
-            self.setup_plugins()
+            self.setup_plugins(load_help_plugin=CONF.load_help_plugin)
 
-    def setup_plugins(self, load_help_plugin=True):
+    def setup_plugins(
+        self,
+        load_help_plugin=True,
+        plugin_list=[],
+    ):
         """Create the plugin manager and register plugins."""
 
         LOG.info("Loading APRSD Plugins")
@@ -481,9 +495,13 @@ class PluginManager:
             _help = HelpPlugin()
             self._pluggy_pm.register(_help)
 
-        enabled_plugins = CONF.enabled_plugins
-        if enabled_plugins:
-            for p_name in enabled_plugins:
+        # if plugins_list is passed in, only load
+        # those plugins.
+        if plugin_list:
+            for plugin_name in plugin_list:
+                self._load_plugin(plugin_name)
+        elif CONF.enabled_plugins:
+            for p_name in CONF.enabled_plugins:
                 self._load_plugin(p_name)
         else:
             # Enabled plugins isn't set, so we default to loading all of

aprsd/plugins/fortune.py

@@ -8,7 +8,7 @@ from aprsd.utils import trace
 
 LOG = logging.getLogger("APRSD")
 
-DEFAULT_FORTUNE_PATH = '/usr/games/fortune'
+DEFAULT_FORTUNE_PATH = "/usr/games/fortune"
 
 
 class FortunePlugin(plugin.APRSDRegexCommandPluginBase):
@@ -45,7 +45,7 @@ class FortunePlugin(plugin.APRSDRegexCommandPluginBase):
                 command,
                 shell=True,
                 timeout=3,
-                universal_newlines=True,
+                text=True,
             )
             output = (
                 output.replace("\r", "")

aprsd/plugins/notify.py

@@ -4,7 +4,6 @@ from oslo_config import cfg
 
 from aprsd import packets, plugin
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
@@ -43,9 +42,7 @@ class NotifySeenPlugin(plugin.APRSDWatchListPluginBase):
                 pkt = packets.MessagePacket(
                     from_call=CONF.callsign,
                     to_call=notify_callsign,
-                    message_text=(
-                        f"{fromcall} was just seen by type:'{packet_type}'"
-                    ),
+                    message_text=(f"{fromcall} was just seen by type:'{packet_type}'"),
                     allow_delay=False,
                 )
                 pkt.allow_delay = False

aprsd/plugins/weather.py

@@ -2,13 +2,12 @@ import json
 import logging
 import re
 
-from oslo_config import cfg
 import requests
+from oslo_config import cfg
 
 from aprsd import plugin, plugin_utils
 from aprsd.utils import trace
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
@@ -205,8 +204,9 @@ class OWMWeatherPlugin(plugin.APRSDRegexCommandPluginBase):
 
     def help(self):
         _help = [
-            "openweathermap: Send {} to get weather "
-            "from your location".format(self.command_regex),
+            "openweathermap: Send {} to get weather " "from your location".format(
+                self.command_regex
+            ),
             "openweathermap: Send {} <callsign> to get "
             "weather from <callsign>".format(self.command_regex),
         ]
@@ -327,10 +327,12 @@ class AVWXWeatherPlugin(plugin.APRSDRegexCommandPluginBase):
 
     def help(self):
         _help = [
-            "avwxweather: Send {} to get weather "
-            "from your location".format(self.command_regex),
-            "avwxweather: Send {} <callsign> to get "
-            "weather from <callsign>".format(self.command_regex),
+            "avwxweather: Send {} to get weather " "from your location".format(
+                self.command_regex
+            ),
+            "avwxweather: Send {} <callsign> to get " "weather from <callsign>".format(
+                self.command_regex
+            ),
         ]
         return _help
 

aprsd/stats/__init__.py

@@ -1,7 +1,6 @@
 from aprsd import plugin
 from aprsd.client import stats as client_stats
 from aprsd.packets import packet_list, seen_list, tracker, watch_list
-from aprsd.plugins import email
 from aprsd.stats import app, collector
 from aprsd.threads import aprsd
 
@@ -15,6 +14,5 @@ stats_collector.register_producer(watch_list.WatchList)
 stats_collector.register_producer(tracker.PacketTrack)
 stats_collector.register_producer(plugin.PluginManager)
 stats_collector.register_producer(aprsd.APRSDThreadList)
-stats_collector.register_producer(email.EmailStats)
 stats_collector.register_producer(client_stats.APRSClientStats)
 stats_collector.register_producer(seen_list.SeenList)

aprsd/stats/collector.py

@@ -3,14 +3,14 @@ from typing import Callable, Protocol, runtime_checkable
 
 from aprsd.utils import singleton
 
-
 LOG = logging.getLogger("APRSD")
 
 
 @runtime_checkable
 class StatsProducer(Protocol):
     """The StatsProducer protocol is used to define the interface for collecting stats."""
-    def stats(self, serializeable=False) -> dict:
+
+    def stats(self, serializable=False) -> dict:
         """provide stats in a dictionary format."""
         ...
 
@@ -18,6 +18,7 @@ class StatsProducer(Protocol):
 @singleton
 class Collector:
     """The Collector class is used to collect stats from multiple StatsProducer instances."""
+
     def __init__(self):
         self.producers: list[Callable] = []
 
@@ -26,7 +27,9 @@ class Collector:
         for name in self.producers:
             cls = name()
             try:
-                stats[cls.__class__.__name__] = cls.stats(serializable=serializable).copy()
+                stats[cls.__class__.__name__] = cls.stats(
+                    serializable=serializable
+                ).copy()
             except Exception as e:
                 LOG.error(f"Error in producer {name} (stats): {e}")
         return stats
@@ -35,3 +38,8 @@ class Collector:
         if not isinstance(producer_name, StatsProducer):
             raise TypeError(f"Producer {producer_name} is not a StatsProducer")
         self.producers.append(producer_name)
+
+    def unregister_producer(self, producer_name: Callable):
+        if not isinstance(producer_name, StatsProducer):
+            raise TypeError(f"Producer {producer_name} is not a StatsProducer")
+        self.producers.remove(producer_name)

aprsd/threads/__init__.py

@@ -4,8 +4,9 @@ import queue
 # aprsd.threads
 from .aprsd import APRSDThread, APRSDThreadList  # noqa: F401
 from .rx import (  # noqa: F401
-    APRSDDupeRXThread, APRSDProcessPacketThread, APRSDRXThread,
+    APRSDDupeRXThread,
+    APRSDProcessPacketThread,
+    APRSDRXThread,
 )
 
-
 packet_queue = queue.Queue(maxsize=20)

aprsd/threads/aprsd.py

@@ -2,11 +2,11 @@ import abc
 import datetime
 import logging
 import threading
+import time
 from typing import List
 
 import wrapt
 
-
 LOG = logging.getLogger("APRSD")
 
 
@@ -14,6 +14,8 @@ class APRSDThread(threading.Thread, metaclass=abc.ABCMeta):
     """Base class for all threads in APRSD."""
 
     loop_count = 1
+    _pause = False
+    thread_stop = False
 
     def __init__(self, name):
         super().__init__(name=name)
@@ -22,11 +24,22 @@ class APRSDThread(threading.Thread, metaclass=abc.ABCMeta):
         self._last_loop = datetime.datetime.now()
 
     def _should_quit(self):
-        """ see if we have a quit message from the global queue."""
+        """see if we have a quit message from the global queue."""
         if self.thread_stop:
             return True
 
+    def pause(self):
+        """Logically pause the processing of the main loop."""
+        LOG.debug(f"Pausing thread '{self.name}' loop_count {self.loop_count}")
+        self._pause = True
+
+    def unpause(self):
+        """Logically resume processing of the main loop."""
+        LOG.debug(f"Resuming thread '{self.name}' loop_count {self.loop_count}")
+        self._pause = False
+
     def stop(self):
+        LOG.debug(f"Stopping thread '{self.name}'")
         self.thread_stop = True
 
     @abc.abstractmethod
@@ -37,7 +50,9 @@ class APRSDThread(threading.Thread, metaclass=abc.ABCMeta):
         """Add code to subclass to do any cleanup"""
 
     def __str__(self):
-        out = f"Thread <{self.__class__.__name__}({self.name}) Alive? {self.is_alive()}>"
+        out = (
+            f"Thread <{self.__class__.__name__}({self.name}) Alive? {self.is_alive()}>"
+        )
         return out
 
     def loop_age(self):
@@ -47,11 +62,14 @@ class APRSDThread(threading.Thread, metaclass=abc.ABCMeta):
     def run(self):
         LOG.debug("Starting")
         while not self._should_quit():
-            self.loop_count += 1
-            can_loop = self.loop()
-            self._last_loop = datetime.datetime.now()
-            if not can_loop:
-                self.stop()
+            if self._pause:
+                time.sleep(1)
+            else:
+                self.loop_count += 1
+                can_loop = self.loop()
+                self._last_loop = datetime.datetime.now()
+                if not can_loop:
+                    self.stop()
         self._cleanup()
         APRSDThreadList().remove(self)
         LOG.debug("Exiting")
@@ -71,6 +89,13 @@ class APRSDThreadList:
             cls.threads_list = []
         return cls._instance
 
+    def __contains__(self, name):
+        """See if we have a thread in our list"""
+        for t in self.threads_list:
+            if t.name == name:
+                return True
+        return False
+
     def stats(self, serializable=False) -> dict:
         stats = {}
         for th in self.threads_list:
@@ -100,9 +125,27 @@ class APRSDThreadList:
         for th in self.threads_list:
             LOG.info(f"Stopping Thread {th.name}")
             if hasattr(th, "packet"):
-                LOG.info(F"{th.name} packet {th.packet}")
+                LOG.info(f"{th.name} packet {th.packet}")
             th.stop()
 
+    @wrapt.synchronized
+    def pause_all(self):
+        """Iterate over all threads and pause them."""
+        for th in self.threads_list:
+            LOG.info(f"Pausing Thread {th.name}")
+            if hasattr(th, "packet"):
+                LOG.info(f"{th.name} packet {th.packet}")
+            th.pause()
+
+    @wrapt.synchronized
+    def unpause_all(self):
+        """Iterate over all threads and resume them."""
+        for th in self.threads_list:
+            LOG.info(f"Resuming Thread {th.name}")
+            if hasattr(th, "packet"):
+                LOG.info(f"{th.name} packet {th.packet}")
+            th.unpause()
+
     @wrapt.synchronized(lock)
     def info(self):
         """Go through all the threads and collect info about each."""
@@ -111,7 +154,11 @@ class APRSDThreadList:
             alive = thread.is_alive()
             age = thread.loop_age()
             key = thread.__class__.__name__
-            info[key] = {"alive": True if alive else False, "age": age, "name": thread.name}
+            info[key] = {
+                "alive": True if alive else False,
+                "age": age,
+                "name": thread.name,
+            }
         return info
 
     @wrapt.synchronized(lock)

aprsd/threads/{keep_alive.py → keepalive.py}

@@ -7,11 +7,10 @@ from loguru import logger
 from oslo_config import cfg
 
 from aprsd import packets, utils
-from aprsd.client import client_factory
 from aprsd.log import log as aprsd_log
 from aprsd.stats import collector
 from aprsd.threads import APRSDThread, APRSDThreadList
-
+from aprsd.utils import keepalive_collector
 
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
@@ -35,18 +34,14 @@ class KeepAliveThread(APRSDThread):
             thread_list = APRSDThreadList()
             now = datetime.datetime.now()
 
-            if "EmailStats" in stats_json:
-                email_stats = stats_json["EmailStats"]
-                if email_stats.get("last_check_time"):
-                    email_thread_time = utils.strfdelta(now - email_stats["last_check_time"])
-                else:
-                    email_thread_time = "N/A"
-            else:
-                email_thread_time = "N/A"
-
-            if "APRSClientStats" in stats_json and stats_json["APRSClientStats"].get("transport") == "aprsis":
+            if (
+                "APRSClientStats" in stats_json
+                and stats_json["APRSClientStats"].get("transport") == "aprsis"
+            ):
                 if stats_json["APRSClientStats"].get("server_keepalive"):
-                    last_msg_time = utils.strfdelta(now - stats_json["APRSClientStats"]["server_keepalive"])
+                    last_msg_time = utils.strfdelta(
+                        now - stats_json["APRSClientStats"]["server_keepalive"]
+                    )
                 else:
                     last_msg_time = "N/A"
             else:
@@ -63,7 +58,7 @@ class KeepAliveThread(APRSDThread):
 
             keepalive = (
                 "{} - Uptime {} RX:{} TX:{} Tracker:{} Msgs TX:{} RX:{} "
-                "Last:{} Email: {} - RAM Current:{} Peak:{} Threads:{} LoggingQueue:{}"
+                "Last:{} - RAM Current:{} Peak:{} Threads:{} LoggingQueue:{}"
             ).format(
                 stats_json["APRSDStats"]["callsign"],
                 stats_json["APRSDStats"]["uptime"],
@@ -73,7 +68,6 @@ class KeepAliveThread(APRSDThread):
                 tx_msg,
                 rx_msg,
                 last_msg_time,
-                email_thread_time,
                 stats_json["APRSDStats"]["memory_current_str"],
                 stats_json["APRSDStats"]["memory_peak_str"],
                 len(thread_list),
@@ -96,28 +90,11 @@ class KeepAliveThread(APRSDThread):
                     LOGU.opt(colors=True).info(thread_msg)
                     # LOG.info(f"{key: <15} Alive? {str(alive): <5} {str(age): <20}")
 
-            # check the APRS connection
-            cl = client_factory.create()
-            # Reset the connection if it's dead and this isn't our
-            # First time through the loop.
-            # The first time through the loop can happen at startup where
-            # The keepalive thread starts before the client has a chance
-            # to make it's connection the first time.
-            if not cl.is_alive() and self.cntr > 0:
-                LOG.error(f"{cl.__class__.__name__} is not alive!!! Resetting")
-                client_factory.create().reset()
-            # else:
-            #     # See if we should reset the aprs-is client
-            #     # Due to losing a keepalive from them
-            #     delta_dict = utils.parse_delta_str(last_msg_time)
-            #     delta = datetime.timedelta(**delta_dict)
-            #
-            #     if delta > self.max_delta:
-            #         #  We haven't gotten a keepalive from aprs-is in a while
-            #         # reset the connection.a
-            #         if not client.KISSClient.is_enabled():
-            #             LOG.warning(f"Resetting connection to APRS-IS {delta}")
-            #             client.factory.create().reset()
+            # Go through the registered keepalive collectors
+            # and check them as well as call log.
+            collect = keepalive_collector.KeepAliveCollector()
+            collect.check()
+            collect.log()
 
             # Check version every day
             delta = now - self.checker_time

aprsd/threads/registry.py

@@ -1,19 +1,19 @@
 import logging
 import time
 
-from oslo_config import cfg
 import requests
+from oslo_config import cfg
 
 import aprsd
 from aprsd import threads as aprsd_threads
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
 
 class APRSRegistryThread(aprsd_threads.APRSDThread):
     """This sends service information to the configured APRS Registry."""
+
     _loop_cnt: int = 1
 
     def __init__(self):
@@ -41,7 +41,7 @@ class APRSRegistryThread(aprsd_threads.APRSDThread):
                 "description": CONF.aprs_registry.description,
                 "service_website": CONF.aprs_registry.service_website,
                 "software": f"APRSD version {aprsd.__version__} "
-                            "https://github.com/craigerl/aprsd",
+                "https://github.com/craigerl/aprsd",
             }
             try:
                 requests.post(