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

aprsd/threads/rx.py

@@ -11,17 +11,18 @@ 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
 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 +34,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
@@ -45,7 +52,9 @@ class APRSDRXThread(APRSDThread):
             # kwargs.  :(
             # https://github.com/rossengeorgiev/aprs-python/pull/56
             self._client.consumer(
-                self._process_packet, raw=False, blocking=False,
+                self._process_packet,
+                raw=False,
+                blocking=False,
             )
         except (
             aprslib.exceptions.ConnectionDrop,
@@ -63,6 +72,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 +94,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 +107,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 +123,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
 
@@ -123,7 +139,9 @@ class APRSDDupeRXThread(APRSDRXThread):
             elif packet.timestamp - found.timestamp < CONF.packet_dupe_timeout:
                 # If the packet came in within N seconds of the
                 # Last time seeing the packet, then we drop it as a dupe.
-                LOG.warning(f"Packet {packet.from_call}:{packet.msgNo} already tracked, dropping.")
+                LOG.warning(
+                    f"Packet {packet.from_call}:{packet.msgNo} already tracked, dropping."
+                )
             else:
                 LOG.warning(
                     f"Packet {packet.from_call}:{packet.msgNo} already tracked "
@@ -134,7 +152,7 @@ class APRSDDupeRXThread(APRSDRXThread):
 
 
 class APRSDPluginRXThread(APRSDDupeRXThread):
-    """"Process received packets.
+    """ "Process received packets.
 
     For backwards compatibility, we keep the APRSDPluginRXThread.
     """
@@ -151,6 +169,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 +237,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:
@@ -228,7 +252,8 @@ class APRSDProcessPacketThread(APRSDThread):
                     self.process_other_packet(packet, for_us=False)
             else:
                 self.process_other_packet(
-                    packet, for_us=(to_call.lower() == our_call),
+                    packet,
+                    for_us=(to_call.lower() == our_call),
                 )
         LOG.debug(f"Packet processing complete for pkt '{packet.key}'")
         return False
@@ -240,7 +265,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 +353,14 @@ 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/stats.py

@@ -2,20 +2,20 @@ import logging
 import threading
 import time
 
-from oslo_config import cfg
 import wrapt
+from oslo_config import cfg
 
 from aprsd.stats import collector
 from aprsd.threads import APRSDThread
 from aprsd.utils import objectstore
 
-
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
 
 class StatsStore(objectstore.ObjectStoreMixin):
     """Container to save the stats from the collector."""
+
     lock = threading.Lock()
     data = {}
 

aprsd/threads/tx.py

@@ -2,20 +2,18 @@ import logging
 import threading
 import time
 
+import wrapt
 from oslo_config import cfg
 from rush import quota, throttle
 from rush.contrib import decorator
 from rush.limiters import periodic
 from rush.stores import dictionary
-import wrapt
 
 from aprsd import conf  # noqa
 from aprsd import threads as aprsd_threads
 from aprsd.client import client_factory
-from aprsd.packets import collector, core
+from aprsd.packets import collector, core, tracker
 from aprsd.packets import log as packet_log
-from aprsd.packets import tracker
-
 
 CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
@@ -48,12 +46,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 +90,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 +154,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 +212,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)
@@ -213,6 +236,7 @@ class BeaconSendThread(aprsd_threads.APRSDThread):
 
     Settings are in the [DEFAULT] section of the config file.
     """
+
     _loop_cnt: int = 1
 
     def __init__(self):

aprsd/utils/__init__.py

@@ -13,11 +13,11 @@ import update_checker
 import aprsd
 
 from .fuzzyclock import fuzzy  # noqa: F401
+
 # Make these available by anyone importing
 # aprsd.utils
 from .ring_buffer import RingBuffer  # noqa: F401
 
-
 if sys.version_info.major == 3 and sys.version_info.minor >= 3:
     from collections.abc import MutableMapping
 else:
@@ -26,11 +26,13 @@ else:
 
 def singleton(cls):
     """Make a class a Singleton class (only one instance)"""
+
     @functools.wraps(cls)
     def wrapper_singleton(*args, **kwargs):
         if wrapper_singleton.instance is None:
             wrapper_singleton.instance = cls(*args, **kwargs)
         return wrapper_singleton.instance
+
     wrapper_singleton.instance = None
     return wrapper_singleton
 
@@ -170,23 +172,40 @@ def load_entry_points(group):
         try:
             ep.load()
         except Exception as e:
-            print(f"Extension {ep.name} of group {group} failed to load with {e}", file=sys.stderr)
+            print(
+                f"Extension {ep.name} of group {group} failed to load with {e}",
+                file=sys.stderr,
+            )
             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) - (
-        math.sin(lat1)
-        * math.cos(lat2) * math.cos(diff_long)
+        math.sin(lat1) * math.cos(lat2) * math.cos(diff_long)
     )
 
     initial_bearing = math.atan2(x, y)
@@ -203,15 +222,43 @@ def calculate_initial_compass_bearing(start, end):
 def degrees_to_cardinal(bearing, full_string=False):
     if full_string:
         directions = [
-            "North", "North-Northeast", "Northeast", "East-Northeast", "East", "East-Southeast",
-            "Southeast", "South-Southeast", "South", "South-Southwest", "Southwest", "West-Southwest",
-            "West", "West-Northwest", "Northwest", "North-Northwest", "North",
+            "North",
+            "North-Northeast",
+            "Northeast",
+            "East-Northeast",
+            "East",
+            "East-Southeast",
+            "Southeast",
+            "South-Southeast",
+            "South",
+            "South-Southwest",
+            "Southwest",
+            "West-Southwest",
+            "West",
+            "West-Northwest",
+            "Northwest",
+            "North-Northwest",
+            "North",
         ]
     else:
         directions = [
-            "N", "NNE", "NE", "ENE", "E", "ESE",
-            "SE", "SSE", "S", "SSW", "SW", "WSW",
-            "W", "WNW", "NW", "NNW", "N",
+            "N",
+            "NNE",
+            "NE",
+            "ENE",
+            "E",
+            "ESE",
+            "SE",
+            "SSE",
+            "S",
+            "SSW",
+            "SW",
+            "WSW",
+            "W",
+            "WNW",
+            "NW",
+            "NNW",
+            "N",
         ]
 
     cardinal = directions[round(bearing / 22.5)]

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

@@ -10,8 +10,13 @@ class EnhancedJSONEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, datetime.datetime):
             args = (
-                "year", "month", "day", "hour", "minute",
-                "second", "microsecond",
+                "year",
+                "month",
+                "day",
+                "hour",
+                "minute",
+                "second",
+                "microsecond",
             )
             return {
                 "__type__": "datetime.datetime",
@@ -63,10 +68,10 @@ class SimpleJSONEncoder(json.JSONEncoder):
 
 
 class EnhancedJSONDecoder(json.JSONDecoder):
-
     def __init__(self, *args, **kwargs):
         super().__init__(
-            *args, object_hook=self.object_hook,
+            *args,
+            object_hook=self.object_hook,
             **kwargs,
         )
 

aprsd/utils/keepalive_collector.py

@@ -0,0 +1,55 @@
+import logging
+from typing import Callable, Protocol, runtime_checkable
+
+from aprsd.utils import singleton
+
+LOG = logging.getLogger("APRSD")
+
+
+@runtime_checkable
+class KeepAliveProducer(Protocol):
+    """The KeepAliveProducer protocol is used to define the interface for running Keepalive checks."""
+
+    def keepalive_check(self) -> dict:
+        """Check for keepalive."""
+        ...
+
+    def keepalive_log(self):
+        """Log any keepalive information."""
+        ...
+
+
+@singleton
+class KeepAliveCollector:
+    """The Collector class is used to collect stats from multiple StatsProducer instances."""
+
+    def __init__(self):
+        self.producers: list[Callable] = []
+
+    def check(self) -> None:
+        """Do any keepalive checks."""
+        for name in self.producers:
+            cls = name()
+            try:
+                cls.keepalive_check()
+            except Exception as e:
+                LOG.error(f"Error in producer {name} (check): {e}")
+
+    def log(self) -> None:
+        """Log any relevant information during a KeepAlive check"""
+        for name in self.producers:
+            cls = name()
+            try:
+                cls.keepalive_log()
+            except Exception as e:
+                LOG.error(f"Error in producer {name} (check): {e}")
+
+    def register(self, producer_name: Callable):
+        if not isinstance(producer_name, KeepAliveProducer):
+            raise TypeError(f"Producer {producer_name} is not a KeepAliveProducer")
+        self.producers.append(producer_name)
+
+    def unregister(self, producer_name: Callable):
+        if not isinstance(producer_name, KeepAliveProducer):
+            raise TypeError(f"Producer {producer_name} is not a KeepAliveProducer")
+        self.producers.remove(producer_name)

aprsd/utils/trace.py

@@ -5,7 +5,6 @@ import logging
 import time
 import types
 
-
 VALID_TRACE_FLAGS = {"method", "api"}
 TRACE_API = False
 TRACE_METHOD = False
@@ -27,8 +26,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 +45,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,
                     },
                 )
 

aprsd-4.0.0.dist-info/AUTHORS

@@ -0,0 +1 @@
+waboring@hemna.com : 1