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

aprsd/packets/watch_list.py

@@ -1,11 +1,10 @@
 import datetime
 import logging
-import threading
 
 from oslo_config import cfg
-import wrapt
 
 from aprsd import utils
+from aprsd.packets import collector, core
 from aprsd.utils import objectstore
 
 
@@ -17,56 +16,75 @@ class WatchList(objectstore.ObjectStoreMixin):
     """Global watch list and info for callsigns."""
 
     _instance = None
-    lock = threading.Lock()
     data = {}
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
-            cls._instance._init_store()
-            cls._instance.data = {}
         return cls._instance
 
-    def __init__(self, config=None):
-        ring_size = CONF.watch_list.packet_keep_count
-
-        if CONF.watch_list.callsigns:
-            for callsign in CONF.watch_list.callsigns:
-                call = callsign.replace("*", "")
-                # FIXME(waboring) - we should fetch the last time we saw
-                # a beacon from a callsign or some other mechanism to find
-                # last time a message was seen by aprs-is.  For now this
-                # is all we can do.
-                self.data[call] = {
-                    "last": datetime.datetime.now(),
-                    "packets": utils.RingBuffer(
-                        ring_size,
-                    ),
+    def __init__(self):
+        super().__init__()
+        self._update_from_conf()
+
+    def _update_from_conf(self, config=None):
+        with self.lock:
+            if CONF.watch_list.enabled and CONF.watch_list.callsigns:
+                for callsign in CONF.watch_list.callsigns:
+                    call = callsign.replace("*", "")
+                    # FIXME(waboring) - we should fetch the last time we saw
+                    # a beacon from a callsign or some other mechanism to find
+                    # last time a message was seen by aprs-is.  For now this
+                    # is all we can do.
+                    if call not in self.data:
+                        self.data[call] = {
+                            "last": None,
+                            "packet": None,
+                        }
+
+    def stats(self, serializable=False) -> dict:
+        stats = {}
+        with self.lock:
+            for callsign in self.data:
+                stats[callsign] = {
+                    "last": self.data[callsign]["last"],
+                    "packet": self.data[callsign]["packet"],
+                    "age": self.age(callsign),
+                    "old": self.is_old(callsign),
                 }
+        return stats
 
     def is_enabled(self):
         return CONF.watch_list.enabled
 
     def callsign_in_watchlist(self, callsign):
-        return callsign in self.data
+        with self.lock:
+            return callsign in self.data
+
+    def rx(self, packet: type[core.Packet]) -> None:
+        """Track when we got a packet from the network."""
+        callsign = packet.from_call
 
-    @wrapt.synchronized(lock)
-    def update_seen(self, packet):
-        if packet.addresse:
-            callsign = packet.addresse
-        else:
-            callsign = packet.from_call
         if self.callsign_in_watchlist(callsign):
-            self.data[callsign]["last"] = datetime.datetime.now()
-            self.data[callsign]["packets"].append(packet)
+            with self.lock:
+                self.data[callsign]["last"] = datetime.datetime.now()
+                self.data[callsign]["packet"] = packet
+
+    def tx(self, packet: type[core.Packet]) -> None:
+        """We don't care about TX packets."""
 
     def last_seen(self, callsign):
-        if self.callsign_in_watchlist(callsign):
-            return self.data[callsign]["last"]
+        with self.lock:
+            if self.callsign_in_watchlist(callsign):
+                return self.data[callsign]["last"]
 
     def age(self, callsign):
         now = datetime.datetime.now()
-        return str(now - self.last_seen(callsign))
+        last_seen_time = self.last_seen(callsign)
+        if last_seen_time:
+            return str(now - last_seen_time)
+        else:
+            return None
 
     def max_delta(self, seconds=None):
         if not seconds:
@@ -83,14 +101,22 @@ class WatchList(objectstore.ObjectStoreMixin):
         We put this here so any notification plugin can use this
         same test.
         """
-        age = self.age(callsign)
+        if not self.callsign_in_watchlist(callsign):
+            return False
 
-        delta = utils.parse_delta_str(age)
-        d = datetime.timedelta(**delta)
+        age = self.age(callsign)
+        if age:
+            delta = utils.parse_delta_str(age)
+            d = datetime.timedelta(**delta)
 
-        max_delta = self.max_delta(seconds=seconds)
+            max_delta = self.max_delta(seconds=seconds)
 
-        if d > max_delta:
-            return True
+            if d > max_delta:
+                return True
+            else:
+                return False
         else:
             return False
+
+
+collector.PacketCollector().register(WatchList)

aprsd/plugin.py

@@ -1,4 +1,5 @@
-# The base plugin class
+from __future__ import annotations
+
 import abc
 import importlib
 import inspect
@@ -42,7 +43,7 @@ class APRSDPluginSpec:
     """A hook specification namespace."""
 
     @hookspec
-    def filter(self, packet: packets.core.Packet):
+    def filter(self, packet: type[packets.Packet]):
         """My special little hook that you can customize."""
 
 
@@ -65,7 +66,7 @@ class APRSDPluginBase(metaclass=abc.ABCMeta):
         self.threads = self.create_threads() or []
         self.start_threads()
 
-    def start_threads(self):
+    def start_threads(self) -> None:
         if self.enabled and self.threads:
             if not isinstance(self.threads, list):
                 self.threads = [self.threads]
@@ -90,10 +91,10 @@ class APRSDPluginBase(metaclass=abc.ABCMeta):
                 )
 
     @property
-    def message_count(self):
+    def message_count(self) -> int:
         return self.message_counter
 
-    def help(self):
+    def help(self) -> str:
         return "Help!"
 
     @abc.abstractmethod
@@ -118,11 +119,11 @@ class APRSDPluginBase(metaclass=abc.ABCMeta):
                 thread.stop()
 
     @abc.abstractmethod
-    def filter(self, packet: packets.core.Packet):
+    def filter(self, packet: type[packets.Packet]) -> str | packets.MessagePacket:
         pass
 
     @abc.abstractmethod
-    def process(self, packet: packets.core.Packet):
+    def process(self, packet: type[packets.Packet]):
         """This is called when the filter passes."""
 
 
@@ -154,7 +155,7 @@ class APRSDWatchListPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
                 LOG.warning("Watch list enabled, but no callsigns set.")
 
     @hookimpl
-    def filter(self, packet: packets.core.Packet):
+    def filter(self, packet: type[packets.Packet]) -> str | packets.MessagePacket:
         result = packets.NULL_MESSAGE
         if self.enabled:
             wl = watch_list.WatchList()
@@ -206,14 +207,14 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
         self.enabled = True
 
     @hookimpl
-    def filter(self, packet: packets.core.MessagePacket):
-        LOG.info(f"{self.__class__.__name__} called")
+    def filter(self, packet: packets.MessagePacket) -> str | packets.MessagePacket:
+        LOG.debug(f"{self.__class__.__name__} called")
         if not self.enabled:
             result = f"{self.__class__.__name__} isn't enabled"
             LOG.warning(result)
             return result
 
-        if not isinstance(packet, packets.core.MessagePacket):
+        if not isinstance(packet, packets.MessagePacket):
             LOG.warning(f"{self.__class__.__name__} Got a {packet.__class__.__name__} ignoring")
             return packets.NULL_MESSAGE
 
@@ -226,7 +227,7 @@ class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
         # and is an APRS message format and has a message.
         if (
             tocall == CONF.callsign
-            and isinstance(packet, packets.core.MessagePacket)
+            and isinstance(packet, packets.MessagePacket)
             and message
         ):
             if re.search(self.command_regex, message, re.IGNORECASE):
@@ -269,7 +270,7 @@ class HelpPlugin(APRSDRegexCommandPluginBase):
     def help(self):
         return "Help: send APRS help or help <plugin>"
 
-    def process(self, packet: packets.core.MessagePacket):
+    def process(self, packet: packets.MessagePacket):
         LOG.info("HelpPlugin")
         # fromcall = packet.get("from")
         message = packet.message_text
@@ -343,6 +344,28 @@ class PluginManager:
         self._watchlist_pm = pluggy.PluginManager("aprsd")
         self._watchlist_pm.add_hookspecs(APRSDPluginSpec)
 
+    def stats(self, serializable=False) -> dict:
+        """Collect and return stats for all plugins."""
+        def full_name_with_qualname(obj):
+            return "{}.{}".format(
+                obj.__class__.__module__,
+                obj.__class__.__qualname__,
+            )
+
+        plugin_stats = {}
+        plugins = self.get_plugins()
+        if plugins:
+
+            for p in plugins:
+                plugin_stats[full_name_with_qualname(p)] = {
+                    "enabled": p.enabled,
+                    "rx": p.rx_count,
+                    "tx": p.tx_count,
+                    "version": p.version,
+                }
+
+        return plugin_stats
+
     def is_plugin(self, obj):
         for c in inspect.getmro(obj):
             if issubclass(c, APRSDPluginBase):
@@ -368,7 +391,9 @@ class PluginManager:
         try:
             module_name, class_name = module_class_string.rsplit(".", 1)
             module = importlib.import_module(module_name)
-            module = importlib.reload(module)
+            # Commented out because the email thread starts in a different context
+            # and hence gives a different singleton for the EmailStats
+            # module = importlib.reload(module)
         except Exception as ex:
             if not module_name:
                 LOG.error(f"Failed to load Plugin {module_class_string}")
@@ -469,12 +494,12 @@ class PluginManager:
 
         LOG.info("Completed Plugin Loading.")
 
-    def run(self, packet: packets.core.MessagePacket):
+    def run(self, packet: packets.MessagePacket):
         """Execute all the plugins run method."""
         with self.lock:
             return self._pluggy_pm.hook.filter(packet=packet)
 
-    def run_watchlist(self, packet: packets.core.Packet):
+    def run_watchlist(self, packet: packets.Packet):
         with self.lock:
             return self._watchlist_pm.hook.filter(packet=packet)
 

aprsd/plugins/email.py

@@ -11,7 +11,7 @@ import time
 import imapclient
 from oslo_config import cfg
 
-from aprsd import packets, plugin, stats, threads
+from aprsd import packets, plugin, threads, utils
 from aprsd.threads import tx
 from aprsd.utils import trace
 
@@ -60,6 +60,38 @@ class EmailInfo:
             self._delay = val
 
 
+@utils.singleton
+class EmailStats:
+    """Singleton object to store stats related to email."""
+    _instance = None
+    tx = 0
+    rx = 0
+    email_thread_last_time = None
+
+    def stats(self, serializable=False):
+        if CONF.email_plugin.enabled:
+            last_check_time = self.email_thread_last_time
+            if serializable and last_check_time:
+                last_check_time = last_check_time.isoformat()
+            stats = {
+                "tx": self.tx,
+                "rx": self.rx,
+                "last_check_time": last_check_time,
+            }
+        else:
+            stats = {}
+        return stats
+
+    def tx_inc(self):
+        self.tx += 1
+
+    def rx_inc(self):
+        self.rx += 1
+
+    def email_thread_update(self):
+        self.email_thread_last_time = datetime.datetime.now()
+
+
 class EmailPlugin(plugin.APRSDRegexCommandPluginBase):
     """Email Plugin."""
 
@@ -190,10 +222,6 @@ class EmailPlugin(plugin.APRSDRegexCommandPluginBase):
 def _imap_connect():
     imap_port = CONF.email_plugin.imap_port
     use_ssl = CONF.email_plugin.imap_use_ssl
-    # host = CONFIG["aprsd"]["email"]["imap"]["host"]
-    # msg = "{}{}:{}".format("TLS " if use_ssl else "", host, imap_port)
-    #    LOG.debug("Connect to IMAP host {} with user '{}'".
-    #              format(msg, CONFIG['imap']['login']))
 
     try:
         server = imapclient.IMAPClient(
@@ -440,7 +468,7 @@ def send_email(to_addr, content):
                 [to_addr],
                 msg.as_string(),
             )
-            stats.APRSDStats().email_tx_inc()
+            EmailStats().tx_inc()
         except Exception:
             LOG.exception("Sendmail Error!!!!")
             server.quit()
@@ -545,7 +573,7 @@ class APRSDEmailThread(threads.APRSDThread):
 
     def loop(self):
         time.sleep(5)
-        stats.APRSDStats().email_thread_update()
+        EmailStats().email_thread_update()
         # always sleep for 5 seconds and see if we need to check email
         # This allows CTRL-C to stop the execution of this loop sooner
         # than check_email_delay time

aprsd/plugins/time.py

@@ -1,9 +1,9 @@
 import logging
 import re
-import time
 
 from oslo_config import cfg
 import pytz
+from tzlocal import get_localzone
 
 from aprsd import packets, plugin, plugin_utils
 from aprsd.utils import fuzzy, trace
@@ -22,7 +22,8 @@ class TimePlugin(plugin.APRSDRegexCommandPluginBase):
     short_description = "What is the current local time."
 
     def _get_local_tz(self):
-        return pytz.timezone(time.strftime("%Z"))
+        lz = get_localzone()
+        return pytz.timezone(str(lz))
 
     def _get_utcnow(self):
         return pytz.datetime.datetime.utcnow()

aprsd/plugins/version.py

@@ -1,7 +1,8 @@
 import logging
 
 import aprsd
-from aprsd import plugin, stats
+from aprsd import plugin
+from aprsd.stats import collector
 
 
 LOG = logging.getLogger("APRSD")
@@ -23,10 +24,8 @@ class VersionPlugin(plugin.APRSDRegexCommandPluginBase):
         # fromcall = packet.get("from")
         # message = packet.get("message_text", None)
         # ack = packet.get("msgNo", "0")
-        stats_obj = stats.APRSDStats()
-        s = stats_obj.stats()
-        print(s)
+        s = collector.Collector().collect()
         return "APRSD ver:{} uptime:{}".format(
             aprsd.__version__,
-            s["aprsd"]["uptime"],
+            s["APRSDStats"]["uptime"],
         )

aprsd/plugins/weather.py

@@ -110,7 +110,6 @@ class USMetarPlugin(plugin.APRSDRegexCommandPluginBase, plugin.APRSFIKEYMixin):
 
     @trace.trace
     def process(self, packet):
-        print("FISTY")
         fromcall = packet.get("from")
         message = packet.get("message_text", None)
         # ack = packet.get("msgNo", "0")

aprsd/stats/__init__.py

@@ -0,0 +1,20 @@
+from aprsd import client as aprs_client
+from aprsd import plugin
+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
+
+
+# Create the collector and register all the objects
+# that APRSD has that implement the stats protocol
+stats_collector = collector.Collector()
+stats_collector.register_producer(app.APRSDStats)
+stats_collector.register_producer(packet_list.PacketList)
+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(aprs_client.APRSClientStats)
+stats_collector.register_producer(seen_list.SeenList)

aprsd/stats/app.py

@@ -0,0 +1,46 @@
+import datetime
+import tracemalloc
+
+from oslo_config import cfg
+
+import aprsd
+from aprsd import utils
+
+
+CONF = cfg.CONF
+
+
+class APRSDStats:
+    """The AppStats class is used to collect stats from the application."""
+
+    _instance = None
+    start_time = None
+
+    def __new__(cls, *args, **kwargs):
+        """Have to override the new method to make this a singleton
+
+        instead of using @singletone decorator so the unit tests work.
+        """
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+            cls._instance.start_time = datetime.datetime.now()
+        return cls._instance
+
+    def uptime(self):
+        return datetime.datetime.now() - self.start_time
+
+    def stats(self, serializable=False) -> dict:
+        current, peak = tracemalloc.get_traced_memory()
+        uptime = self.uptime()
+        if serializable:
+            uptime = str(uptime)
+        stats = {
+            "version": aprsd.__version__,
+            "uptime": uptime,
+            "callsign": CONF.callsign,
+            "memory_current": int(current),
+            "memory_current_str": utils.human_size(current),
+            "memory_peak": int(peak),
+            "memory_peak_str": utils.human_size(peak),
+        }
+        return stats

aprsd/stats/collector.py

@@ -0,0 +1,38 @@
+import logging
+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:
+        """provide stats in a dictionary format."""
+        ...
+
+
+@singleton
+class Collector:
+    """The Collector class is used to collect stats from multiple StatsProducer instances."""
+    def __init__(self):
+        self.producers: list[Callable] = []
+
+    def collect(self, serializable=False) -> dict:
+        stats = {}
+        for name in self.producers:
+            cls = name()
+            if isinstance(cls, StatsProducer):
+                try:
+                    stats[cls.__class__.__name__] = cls.stats(serializable=serializable).copy()
+                except Exception as e:
+                    LOG.error(f"Error in producer {name} (stats): {e}")
+            else:
+                raise TypeError(f"{cls} is not an instance of StatsProducer")
+        return stats
+
+    def register_producer(self, producer_name: Callable):
+        self.producers.append(producer_name)

aprsd/threads/__init__.py

@@ -3,8 +3,9 @@ import queue
 # Make these available to anyone importing
 # aprsd.threads
 from .aprsd import APRSDThread, APRSDThreadList  # noqa: F401
-from .keep_alive import KeepAliveThread  # noqa: F401
-from .rx import APRSDRXThread, APRSDDupeRXThread, APRSDProcessPacketThread  # noqa: F401
+from .rx import (  # noqa: F401
+    APRSDDupeRXThread, APRSDProcessPacketThread, APRSDRXThread,
+)
 
 
 packet_queue = queue.Queue(maxsize=20)

aprsd/threads/aprsd.py

@@ -2,6 +2,7 @@ import abc
 import datetime
 import logging
 import threading
+from typing import List
 
 import wrapt
 
@@ -9,43 +10,10 @@ import wrapt
 LOG = logging.getLogger("APRSD")
 
 
-class APRSDThreadList:
-    """Singleton class that keeps track of application wide threads."""
-
-    _instance = None
-
-    threads_list = []
-    lock = threading.Lock()
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls.threads_list = []
-        return cls._instance
-
-    @wrapt.synchronized(lock)
-    def add(self, thread_obj):
-        self.threads_list.append(thread_obj)
-
-    @wrapt.synchronized(lock)
-    def remove(self, thread_obj):
-        self.threads_list.remove(thread_obj)
-
-    @wrapt.synchronized(lock)
-    def stop_all(self):
-        """Iterate over all threads and call stop on them."""
-        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}")
-            th.stop()
-
-    @wrapt.synchronized(lock)
-    def __len__(self):
-        return len(self.threads_list)
-
-
 class APRSDThread(threading.Thread, metaclass=abc.ABCMeta):
+    """Base class for all threads in APRSD."""
+
+    loop_count = 1
 
     def __init__(self, name):
         super().__init__(name=name)
@@ -79,6 +47,7 @@ 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:
@@ -86,3 +55,65 @@ class APRSDThread(threading.Thread, metaclass=abc.ABCMeta):
         self._cleanup()
         APRSDThreadList().remove(self)
         LOG.debug("Exiting")
+
+
+class APRSDThreadList:
+    """Singleton class that keeps track of application wide threads."""
+
+    _instance = None
+
+    threads_list: List[APRSDThread] = []
+    lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls.threads_list = []
+        return cls._instance
+
+    def stats(self, serializable=False) -> dict:
+        stats = {}
+        for th in self.threads_list:
+            age = th.loop_age()
+            if serializable:
+                age = str(age)
+            stats[th.name] = {
+                "name": th.name,
+                "class": th.__class__.__name__,
+                "alive": th.is_alive(),
+                "age": th.loop_age(),
+                "loop_count": th.loop_count,
+            }
+        return stats
+
+    @wrapt.synchronized(lock)
+    def add(self, thread_obj):
+        self.threads_list.append(thread_obj)
+
+    @wrapt.synchronized(lock)
+    def remove(self, thread_obj):
+        self.threads_list.remove(thread_obj)
+
+    @wrapt.synchronized(lock)
+    def stop_all(self):
+        """Iterate over all threads and call stop on them."""
+        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}")
+            th.stop()
+
+    @wrapt.synchronized(lock)
+    def info(self):
+        """Go through all the threads and collect info about each."""
+        info = {}
+        for thread in self.threads_list:
+            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}
+        return info
+
+    @wrapt.synchronized(lock)
+    def __len__(self):
+        return len(self.threads_list)