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

aprsd/packets/packet_list.py

@@ -37,9 +37,10 @@ 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 +48,10 @@ 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 +83,16 @@ 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

@@ -470,9 +470,12 @@ 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 +484,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/email.py

@@ -12,6 +12,7 @@ import imapclient
 from oslo_config import cfg
 
 from aprsd import packets, plugin, threads, utils
+from aprsd.stats import collector
 from aprsd.threads import tx
 from aprsd.utils import trace
 
@@ -126,6 +127,11 @@ class EmailPlugin(plugin.APRSDRegexCommandPluginBase):
 
             shortcuts = _build_shortcuts_dict()
             LOG.info(f"Email shortcuts {shortcuts}")
+
+            # Register the EmailStats producer with the stats collector
+            # We do this here to prevent EmailStats from being registered
+            # when email is not enabled in the config file.
+            collector.Collector().register_producer(EmailStats)
         else:
             LOG.info("Email services not enabled.")
             self.enabled = False

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/location.py

@@ -2,8 +2,10 @@ import logging
 import re
 import time
 
-from geopy.geocoders import ArcGIS, AzureMaps, Baidu, Bing, GoogleV3
-from geopy.geocoders import HereV7, Nominatim, OpenCage, TomTom, What3WordsV3, Woosmap
+from geopy.geocoders import (
+    ArcGIS, AzureMaps, Baidu, Bing, GoogleV3, HereV7, Nominatim, OpenCage,
+    TomTom, What3WordsV3, Woosmap,
+)
 from oslo_config import cfg
 
 from aprsd import packets, plugin, plugin_utils
@@ -39,8 +41,8 @@ class USGov:
         result = plugin_utils.get_weather_gov_for_gps(lat, lon)
         # LOG.info(f"WEATHER: {result}")
         # LOG.info(f"area description {result['location']['areaDescription']}")
-        if 'location' in result:
-            loc = UsLocation(result['location']['areaDescription'])
+        if "location" in result:
+            loc = UsLocation(result["location"]["areaDescription"])
         else:
             loc = UsLocation("Unknown Location")
 

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

@@ -10,7 +10,7 @@ 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."""
         ...
 
@@ -35,3 +35,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/aprsd.py

@@ -2,6 +2,7 @@ import abc
 import datetime
 import logging
 import threading
+import time
 from typing import List
 
 import wrapt
@@ -14,6 +15,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)
@@ -26,7 +29,18 @@ class APRSDThread(threading.Thread, metaclass=abc.ABCMeta):
         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
@@ -47,11 +61,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 +88,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:
@@ -103,6 +127,24 @@ class APRSDThreadList:
                 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."""

aprsd/threads/keep_alive.py

@@ -5,6 +5,7 @@ import tracemalloc
 
 from loguru import logger
 from oslo_config import cfg
+import timeago
 
 from aprsd import packets, utils
 from aprsd.client import client_factory
@@ -98,6 +99,13 @@ class KeepAliveThread(APRSDThread):
 
             # check the APRS connection
             cl = client_factory.create()
+            cl_stats = cl.stats()
+            ka = cl_stats.get("connection_keepalive", None)
+            if ka:
+                keepalive = timeago.format(ka)
+            else:
+                keepalive = "N/A"
+            LOGU.opt(colors=True).info(f"<green>Client keepalive {keepalive}</green>")
             # 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

aprsd/threads/rx.py

@@ -11,6 +11,7 @@ from aprsd.client import client_factory
 from aprsd.packets import collector
 from aprsd.packets import log as packet_log
 from aprsd.threads import APRSDThread, tx
+from aprsd.utils import trace
 
 
 CONF = cfg.CONF
@@ -18,10 +19,11 @@ LOG = logging.getLogger("APRSD")
 
 
 class APRSDRXThread(APRSDThread):
+    _client = None
+
     def __init__(self, packet_queue):
         super().__init__("RX_PKT")
         self.packet_queue = packet_queue
-        self._client = client_factory.create()
 
     def stop(self):
         self.thread_stop = True
@@ -33,6 +35,12 @@ class APRSDRXThread(APRSDThread):
             self._client = client_factory.create()
             time.sleep(1)
             return True
+
+        if not self._client.is_connected:
+            self._client = client_factory.create()
+            time.sleep(1)
+            return True
+
         # setup the consumer of messages and block until a messages
         try:
             # This will register a packet consumer with aprslib
@@ -63,6 +71,7 @@ class APRSDRXThread(APRSDThread):
             self._client.reset()
             time.sleep(5)
         # Continue to loop
+        time.sleep(1)
         return True
 
     def _process_packet(self, *args, **kwargs):
@@ -84,6 +93,7 @@ class APRSDDupeRXThread(APRSDRXThread):
     to be processed.
     """
 
+    @trace.trace
     def process_packet(self, *args, **kwargs):
         """This handles the processing of an inbound packet.
 
@@ -96,7 +106,6 @@ class APRSDDupeRXThread(APRSDRXThread):
         PluginProcessPacketThread for processing.
         """
         packet = self._client.decode_packet(*args, **kwargs)
-        # LOG.debug(raw)
         packet_log.log(packet)
         pkt_list = packets.PacketList()
 
@@ -113,6 +122,12 @@ class APRSDDupeRXThread(APRSDRXThread):
                 # Find the packet in the list of already seen packets
                 # Based on the packet.key
                 found = pkt_list.find(packet)
+                if not packet.msgNo:
+                    # If the packet doesn't have a message id
+                    # then there is no reliable way to detect
+                    # if it's a dupe, so we just pass it on.
+                    # it shouldn't get acked either.
+                    found = False
             except KeyError:
                 found = False
 
@@ -151,6 +166,11 @@ class APRSDProcessPacketThread(APRSDThread):
     def __init__(self, packet_queue):
         self.packet_queue = packet_queue
         super().__init__("ProcessPKT")
+        if not CONF.enable_sending_ack_packets:
+            LOG.warning(
+                "Sending ack packets is disabled, messages "
+                "will not be acknowledged.",
+            )
 
     def process_ack_packet(self, packet):
         """We got an ack for a message, no need to resend it."""
@@ -214,13 +234,14 @@ class APRSDProcessPacketThread(APRSDThread):
                     # It's a MessagePacket and it's for us!
                     # let any threads do their thing, then ack
                     # send an ack last
-                    tx.send(
-                        packets.AckPacket(
-                            from_call=CONF.callsign,
-                            to_call=from_call,
-                            msgNo=msg_id,
-                        ),
-                    )
+                    if msg_id:
+                        tx.send(
+                            packets.AckPacket(
+                                from_call=CONF.callsign,
+                                to_call=from_call,
+                                msgNo=msg_id,
+                            ),
+                        )
 
                     self.process_our_message_packet(packet)
                 else:
@@ -240,7 +261,7 @@ class APRSDProcessPacketThread(APRSDThread):
     def process_other_packet(self, packet, for_us=False):
         """Process an APRS Packet that isn't a message or ack"""
         if not for_us:
-            LOG.info("Got a packet not meant for us.")
+            LOG.info("Got a packet meant for someone else '{packet.to_call}'")
         else:
             LOG.info("Got a non AckPacket/MessagePacket")
 
@@ -328,8 +349,15 @@ class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
             # If the message was for us and we didn't have a
             # response, then we send a usage statement.
             if to_call == CONF.callsign and not replied:
-                LOG.warning("Sending help!")
-                message_text = "Unknown command! Send 'help' message for help"
+
+                # Tailor the messages accordingly
+                if CONF.load_help_plugin:
+                    LOG.warning("Sending help!")
+                    message_text = "Unknown command! Send 'help' message for help"
+                else:
+                    LOG.warning("Unknown command!")
+                    message_text = "Unknown command!"
+
                 tx.send(
                     packets.MessagePacket(
                         from_call=CONF.callsign,

aprsd/threads/tx.py

@@ -48,12 +48,15 @@ def send(packet: core.Packet, direct=False, aprs_client=None):
     """Send a packet either in a thread or directly to the client."""
     # prepare the packet for sending.
     # This constructs the packet.raw
-    packet.prepare()
+    packet.prepare(create_msg_number=True)
     # Have to call the collector to track the packet
     # After prepare, as prepare assigns the msgNo
     collector.PacketCollector().tx(packet)
     if isinstance(packet, core.AckPacket):
-        _send_ack(packet, direct=direct, aprs_client=aprs_client)
+        if CONF.enable_sending_ack_packets:
+            _send_ack(packet, direct=direct, aprs_client=aprs_client)
+        else:
+            LOG.info("Sending ack packets is disabled. Not sending AckPacket.")
     else:
         _send_packet(packet, direct=direct, aprs_client=aprs_client)
 
@@ -89,6 +92,9 @@ def _send_direct(packet, aprs_client=None):
     except Exception as e:
         LOG.error(f"Failed to send packet: {packet}")
         LOG.error(e)
+        return False
+    else:
+        return True
 
 
 class SendPacketThread(aprsd_threads.APRSDThread):
@@ -150,8 +156,17 @@ class SendPacketThread(aprsd_threads.APRSDThread):
                 # no attempt time, so lets send it, and start
                 # tracking the time.
                 packet.last_send_time = int(round(time.time()))
-                _send_direct(packet)
-                packet.send_count += 1
+                sent = False
+                try:
+                    sent = _send_direct(packet)
+                except Exception:
+                    LOG.error(f"Failed to send packet: {packet}")
+                else:
+                    # If an exception happens while sending
+                    # we don't want this attempt to count
+                    # against the packet
+                    if sent:
+                        packet.send_count += 1
 
             time.sleep(1)
             # Make sure we get called again.
@@ -199,8 +214,18 @@ class SendAckThread(aprsd_threads.APRSDThread):
             send_now = True
 
         if send_now:
-            _send_direct(self.packet)
-            self.packet.send_count += 1
+            sent = False
+            try:
+                sent = _send_direct(self.packet)
+            except Exception:
+                LOG.error(f"Failed to send packet: {self.packet}")
+            else:
+                # If an exception happens while sending
+                # we don't want this attempt to count
+                # against the packet
+                if sent:
+                    self.packet.send_count += 1
+
             self.packet.last_send_time = int(round(time.time()))
 
         time.sleep(1)

aprsd/utils/__init__.py

@@ -174,14 +174,29 @@ def load_entry_points(group):
             print(traceback.format_exc(), file=sys.stderr)
 
 
-def calculate_initial_compass_bearing(start, end):
-    if (type(start) != tuple) or (type(end) != tuple):  # noqa: E721
+def calculate_initial_compass_bearing(point_a, point_b):
+    """
+    Calculates the bearing between two points.
+    The formulae used is the following:
+        θ = atan2(sin(Δlong).cos(lat2),
+                  cos(lat1).sin(lat2) − sin(lat1).cos(lat2).cos(Δlong))
+    :Parameters:
+      - `pointA: The tuple representing the latitude/longitude for the
+        first point. Latitude and longitude must be in decimal degrees
+      - `pointB: The tuple representing the latitude/longitude for the
+        second point. Latitude and longitude must be in decimal degrees
+    :Returns:
+      The bearing in degrees
+    :Returns Type:
+      float
+    """
+    if (type(point_a) != tuple) or (type(point_b) != tuple):  # noqa: E721
         raise TypeError("Only tuples are supported as arguments")
 
-    lat1 = math.radians(float(start[0]))
-    lat2 = math.radians(float(end[0]))
+    lat1 = math.radians(float(point_a[0]))
+    lat2 = math.radians(float(point_b[0]))
 
-    diff_long = math.radians(float(end[1]) - float(start[1]))
+    diff_long = math.radians(float(point_b[1]) - float(point_a[1]))
 
     x = math.sin(diff_long) * math.cos(lat2)
     y = math.cos(lat1) * math.sin(lat2) - (

aprsd/utils/counter.py

@@ -1,4 +1,3 @@
-from multiprocessing import RawValue
 import random
 import threading
 
@@ -10,12 +9,12 @@ MAX_PACKET_ID = 9999
 
 class PacketCounter:
     """
-    Global Packet id counter class.
+    Global Packet ID counter class.
 
-    This is a singleton based class that keeps
+    This is a singleton-based class that keeps
     an incrementing counter for all packets to
-    be sent.  All new Packet objects gets a new
-    message id, which is the next number available
+    be sent. All new Packet objects get a new
+    message ID, which is the next number available
     from the PacketCounter.
 
     """
@@ -27,25 +26,29 @@ class PacketCounter:
         """Make this a singleton class."""
         if cls._instance is None:
             cls._instance = super().__new__(cls, *args, **kwargs)
-            cls._instance.val = RawValue("i", random.randint(1, MAX_PACKET_ID))
+            cls._instance._val = random.randint(1, MAX_PACKET_ID)  # Initialize counter
         return cls._instance
 
     @wrapt.synchronized(lock)
     def increment(self):
-        if self.val.value == MAX_PACKET_ID:
-            self.val.value = 1
+        """Increment the counter, reset if it exceeds MAX_PACKET_ID."""
+        if self._val == MAX_PACKET_ID:
+            self._val = 1
         else:
-            self.val.value += 1
+            self._val += 1
 
     @property
     @wrapt.synchronized(lock)
     def value(self):
-        return str(self.val.value)
+        """Get the current value as a string."""
+        return str(self._val)
 
     @wrapt.synchronized(lock)
     def __repr__(self):
-        return str(self.val.value)
+        """String representation of the current value."""
+        return str(self._val)
 
     @wrapt.synchronized(lock)
     def __str__(self):
-        return str(self.val.value)
+        """String representation of the current value."""
+        return str(self._val)

aprsd/utils/trace.py

@@ -28,7 +28,8 @@ def trace(*dec_args, **dec_kwargs):
 
     def _decorator(f):
 
-        func_name = f.__name__
+        func_name = f.__qualname__
+        func_file = "/".join(f.__code__.co_filename.split("/")[-4:])
 
         @functools.wraps(f)
         def trace_logging_wrapper(*args, **kwargs):
@@ -46,10 +47,11 @@ def trace(*dec_args, **dec_kwargs):
 
             if pass_filter:
                 logger.debug(
-                    "==> %(func)s: call %(all_args)r",
+                    "==> %(func)s: call %(all_args)r file: %(file)s",
                     {
                         "func": func_name,
                         "all_args": str(all_args),
+                        "file": func_file,
                     },
                 )