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

aprsd/threads/keep_alive.py

@@ -5,7 +5,8 @@ import tracemalloc
 
 from oslo_config import cfg
 
-from aprsd import client, packets, stats, utils
+from aprsd import client, packets, utils
+from aprsd.stats import collector
 from aprsd.threads import APRSDThread, APRSDThreadList
 
 
@@ -24,61 +25,66 @@ class KeepAliveThread(APRSDThread):
         self.max_delta = datetime.timedelta(**max_timeout)
 
     def loop(self):
-        if self.cntr % 60 == 0:
-            pkt_tracker = packets.PacketTrack()
-            stats_obj = stats.APRSDStats()
+        if self.loop_count % 60 == 0:
+            stats_json = collector.Collector().collect()
             pl = packets.PacketList()
             thread_list = APRSDThreadList()
             now = datetime.datetime.now()
-            last_email = stats_obj.email_thread_time
-            if last_email:
-                email_thread_time = utils.strfdelta(now - last_email)
+
+            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"
 
-            last_msg_time = utils.strfdelta(now - stats_obj.aprsis_keepalive)
-
-            current, peak = tracemalloc.get_traced_memory()
-            stats_obj.set_memory(current)
-            stats_obj.set_memory_peak(peak)
-
-            login = CONF.callsign
+            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"])
+                else:
+                    last_msg_time = "N/A"
+            else:
+                last_msg_time = "N/A"
 
-            tracked_packets = len(pkt_tracker)
+            tracked_packets = stats_json["PacketTrack"]["total_tracked"]
+            tx_msg = 0
+            rx_msg = 0
+            if "PacketList" in stats_json:
+                msg_packets = stats_json["PacketList"].get("MessagePacket")
+                if msg_packets:
+                    tx_msg = msg_packets.get("tx", 0)
+                    rx_msg = msg_packets.get("rx", 0)
 
             keepalive = (
                 "{} - Uptime {} RX:{} TX:{} Tracker:{} Msgs TX:{} RX:{} "
                 "Last:{} Email: {} - RAM Current:{} Peak:{} Threads:{}"
             ).format(
-                login,
-                utils.strfdelta(stats_obj.uptime),
+                stats_json["APRSDStats"]["callsign"],
+                stats_json["APRSDStats"]["uptime"],
                 pl.total_rx(),
                 pl.total_tx(),
                 tracked_packets,
-                stats_obj._pkt_cnt["MessagePacket"]["tx"],
-                stats_obj._pkt_cnt["MessagePacket"]["rx"],
+                tx_msg,
+                rx_msg,
                 last_msg_time,
                 email_thread_time,
-                utils.human_size(current),
-                utils.human_size(peak),
+                stats_json["APRSDStats"]["memory_current_str"],
+                stats_json["APRSDStats"]["memory_peak_str"],
                 len(thread_list),
             )
             LOG.info(keepalive)
-            thread_out = []
-            thread_info = {}
-            for thread in thread_list.threads_list:
-                alive = thread.is_alive()
-                age = thread.loop_age()
-                key = thread.__class__.__name__
-                thread_out.append(f"{key}:{alive}:{age}")
-                if key not in thread_info:
-                    thread_info[key] = {}
-                thread_info[key]["alive"] = alive
-                thread_info[key]["age"] = age
-                if not alive:
-                    LOG.error(f"Thread {thread}")
-            LOG.info(",".join(thread_out))
-            stats_obj.set_thread_info(thread_info)
+            if "APRSDThreadList" in stats_json:
+                thread_list = stats_json["APRSDThreadList"]
+                for thread_name in thread_list:
+                    thread = thread_list[thread_name]
+                    alive = thread["alive"]
+                    age = thread["age"]
+                    key = thread["name"]
+                    if not alive:
+                        LOG.error(f"Thread {thread}")
+                    LOG.info(f"{key: <15} Alive? {str(alive): <5} {str(age): <20}")
 
             # check the APRS connection
             cl = client.factory.create()
@@ -90,18 +96,18 @@ class KeepAliveThread(APRSDThread):
             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()
+            # 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()
 
             # Check version every day
             delta = now - self.checker_time
@@ -110,6 +116,6 @@ class KeepAliveThread(APRSDThread):
                 level, msg = utils._check_version()
                 if level:
                     LOG.warning(msg)
-        self.cntr += 1
+            self.cntr += 1
         time.sleep(1)
         return True

aprsd/threads/log_monitor.py

@@ -1,25 +1,56 @@
+import datetime
 import logging
 import threading
 
+from oslo_config import cfg
+import requests
 import wrapt
 
 from aprsd import threads
 from aprsd.log import log
 
 
+CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
 
+def send_log_entries(force=False):
+    """Send all of the log entries to the web interface."""
+    if CONF.admin.web_enabled:
+        if force or LogEntries().is_purge_ready():
+            entries = LogEntries().get_all_and_purge()
+            print(f"Sending log entries {len(entries)}")
+            if entries:
+                try:
+                    requests.post(
+                        f"http://{CONF.admin.web_ip}:{CONF.admin.web_port}/log_entries",
+                        json=entries,
+                        auth=(CONF.admin.user, CONF.admin.password),
+                    )
+                except Exception as ex:
+                    LOG.warning(f"Failed to send log entries {len(entries)}")
+                    LOG.warning(ex)
+
+
 class LogEntries:
     entries = []
     lock = threading.Lock()
     _instance = None
+    last_purge = datetime.datetime.now()
+    max_delta = datetime.timedelta(
+        hours=0.0, minutes=0, seconds=2,
+    )
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
         return cls._instance
 
+    def stats(self) -> dict:
+        return {
+            "log_entries": self.entries,
+        }
+
     @wrapt.synchronized(lock)
     def add(self, entry):
         self.entries.append(entry)
@@ -28,8 +59,18 @@ class LogEntries:
     def get_all_and_purge(self):
         entries = self.entries.copy()
         self.entries = []
+        self.last_purge = datetime.datetime.now()
         return entries
 
+    def is_purge_ready(self):
+        now = datetime.datetime.now()
+        if (
+            now - self.last_purge > self.max_delta
+            and len(self.entries) > 1
+        ):
+            return True
+        return False
+
     @wrapt.synchronized(lock)
     def __len__(self):
         return len(self.entries)
@@ -40,6 +81,10 @@ class LogMonitorThread(threads.APRSDThread):
     def __init__(self):
         super().__init__("LogMonitorThread")
 
+    def stop(self):
+        send_log_entries(force=True)
+        super().stop()
+
     def loop(self):
         try:
             record = log.logging_queue.get(block=True, timeout=2)
@@ -54,6 +99,7 @@ class LogMonitorThread(threads.APRSDThread):
             # Just ignore thi
             pass
 
+        send_log_entries()
         return True
 
     def json_record(self, record):

aprsd/threads/rx.py

@@ -7,6 +7,8 @@ import aprslib
 from oslo_config import cfg
 
 from aprsd import client, packets, plugin
+from aprsd.packets import collector
+from aprsd.packets import log as packet_log
 from aprsd.threads import APRSDThread, tx
 
 
@@ -16,15 +18,20 @@ LOG = logging.getLogger("APRSD")
 
 class APRSDRXThread(APRSDThread):
     def __init__(self, packet_queue):
-        super().__init__("RX_MSG")
+        super().__init__("RX_PKT")
         self.packet_queue = packet_queue
         self._client = client.factory.create()
 
     def stop(self):
         self.thread_stop = True
-        client.factory.create().client.stop()
+        if self._client:
+            self._client.stop()
 
     def loop(self):
+        if not self._client:
+            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
@@ -36,23 +43,32 @@ class APRSDRXThread(APRSDThread):
             # and the aprslib developer didn't want to allow a PR to add
             # kwargs.  :(
             # https://github.com/rossengeorgiev/aprs-python/pull/56
-            self._client.client.consumer(
-                self.process_packet, raw=False, blocking=False,
+            self._client.consumer(
+                self._process_packet, raw=False, blocking=False,
             )
-
         except (
             aprslib.exceptions.ConnectionDrop,
             aprslib.exceptions.ConnectionError,
         ):
             LOG.error("Connection dropped, reconnecting")
-            time.sleep(5)
             # Force the deletion of the client object connected to aprs
             # This will cause a reconnect, next time client.get_client()
             # is called
             self._client.reset()
+            time.sleep(5)
+        except Exception:
+            # LOG.exception(ex)
+            LOG.error("Resetting connection and trying again.")
+            self._client.reset()
+            time.sleep(5)
         # Continue to loop
         return True
 
+    def _process_packet(self, *args, **kwargs):
+        """Intermediate callback so we can update the keepalive time."""
+        # Now call the 'real' packet processing for a RX'x packet
+        self.process_packet(*args, **kwargs)
+
     @abc.abstractmethod
     def process_packet(self, *args, **kwargs):
         pass
@@ -80,7 +96,8 @@ class APRSDDupeRXThread(APRSDRXThread):
         """
         packet = self._client.decode_packet(*args, **kwargs)
         # LOG.debug(raw)
-        packet.log(header="RX")
+        packet_log.log(packet)
+        pkt_list = packets.PacketList()
 
         if isinstance(packet, packets.AckPacket):
             # We don't need to drop AckPackets, those should be
@@ -91,7 +108,6 @@ class APRSDDupeRXThread(APRSDRXThread):
             # For RF based APRS Clients we can get duplicate packets
             # So we need to track them and not process the dupes.
             found = False
-            pkt_list = packets.PacketList()
             try:
                 # Find the packet in the list of already seen packets
                 # Based on the packet.key
@@ -100,14 +116,11 @@ class APRSDDupeRXThread(APRSDRXThread):
                 found = False
 
             if not found:
-                # If we are in the process of already ack'ing
-                # a packet, we should drop the packet
-                # because it's a dupe within the time that
-                # we send the 3 acks for the packet.
-                pkt_list.rx(packet)
+                # We haven't seen this packet before, so we process it.
+                collector.PacketCollector().rx(packet)
                 self.packet_queue.put(packet)
             elif packet.timestamp - found.timestamp < CONF.packet_dupe_timeout:
-                # If the packet came in within 60 seconds of the
+                # 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.")
             else:
@@ -115,7 +128,7 @@ class APRSDDupeRXThread(APRSDRXThread):
                     f"Packet {packet.from_call}:{packet.msgNo} already tracked "
                     f"but older than {CONF.packet_dupe_timeout} seconds. processing.",
                 )
-                pkt_list.rx(packet)
+                collector.PacketCollector().rx(packet)
                 self.packet_queue.put(packet)
 
 
@@ -137,21 +150,24 @@ class APRSDProcessPacketThread(APRSDThread):
     def __init__(self, packet_queue):
         self.packet_queue = packet_queue
         super().__init__("ProcessPKT")
-        self._loop_cnt = 1
 
     def process_ack_packet(self, packet):
         """We got an ack for a message, no need to resend it."""
         ack_num = packet.msgNo
-        LOG.info(f"Got ack for message {ack_num}")
-        pkt_tracker = packets.PacketTrack()
-        pkt_tracker.remove(ack_num)
+        LOG.debug(f"Got ack for message {ack_num}")
+        collector.PacketCollector().rx(packet)
+
+    def process_piggyback_ack(self, packet):
+        """We got an ack embedded in a packet."""
+        ack_num = packet.ackMsgNo
+        LOG.debug(f"Got PiggyBackAck for message {ack_num}")
+        collector.PacketCollector().rx(packet)
 
     def process_reject_packet(self, packet):
         """We got a reject message for a packet.  Stop sending the message."""
         ack_num = packet.msgNo
-        LOG.info(f"Got REJECT for message {ack_num}")
-        pkt_tracker = packets.PacketTrack()
-        pkt_tracker.remove(ack_num)
+        LOG.debug(f"Got REJECT for message {ack_num}")
+        collector.PacketCollector().rx(packet)
 
     def loop(self):
         try:
@@ -160,12 +176,11 @@ class APRSDProcessPacketThread(APRSDThread):
                 self.process_packet(packet)
         except queue.Empty:
             pass
-        self._loop_cnt += 1
         return True
 
     def process_packet(self, packet):
         """Process a packet received from aprs-is server."""
-        LOG.debug(f"ProcessPKT-LOOP {self._loop_cnt}")
+        LOG.debug(f"ProcessPKT-LOOP {self.loop_count}")
         our_call = CONF.callsign.lower()
 
         from_call = packet.from_call
@@ -188,6 +203,10 @@ class APRSDProcessPacketThread(APRSDThread):
         ):
             self.process_reject_packet(packet)
         else:
+            if hasattr(packet, "ackMsgNo") and packet.ackMsgNo:
+                # we got an ack embedded in this packet
+                # we need to handle the ack
+                self.process_piggyback_ack(packet)
             # Only ack messages that were sent directly to us
             if isinstance(packet, packets.MessagePacket):
                 if to_call and to_call.lower() == our_call:

aprsd/threads/stats.py

@@ -0,0 +1,44 @@
+import logging
+import threading
+import time
+
+from oslo_config import cfg
+import wrapt
+
+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 = {}
+
+    @wrapt.synchronized(lock)
+    def add(self, stats: dict):
+        self.data = stats
+
+
+class APRSDStatsStoreThread(APRSDThread):
+    """Save APRSD Stats to disk periodically."""
+
+    # how often in seconds to write the file
+    save_interval = 10
+
+    def __init__(self):
+        super().__init__("StatsStore")
+
+    def loop(self):
+        if self.loop_count % self.save_interval == 0:
+            stats = collector.Collector().collect()
+            ss = StatsStore()
+            ss.add(stats)
+            ss.save()
+
+        time.sleep(1)
+        return True

aprsd/threads/tx.py

@@ -1,4 +1,5 @@
 import logging
+import threading
 import time
 
 from oslo_config import cfg
@@ -6,11 +7,14 @@ 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 client
 from aprsd import conf  # noqa
 from aprsd import threads as aprsd_threads
-from aprsd.packets import core, tracker
+from aprsd.packets import collector, core
+from aprsd.packets import log as packet_log
+from aprsd.packets import tracker
 
 
 CONF = cfg.CONF
@@ -35,14 +39,19 @@ ack_t = throttle.Throttle(
 
 msg_throttle_decorator = decorator.ThrottleDecorator(throttle=msg_t)
 ack_throttle_decorator = decorator.ThrottleDecorator(throttle=ack_t)
+s_lock = threading.Lock()
 
 
+@wrapt.synchronized(s_lock)
 @msg_throttle_decorator.sleep_and_retry
 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()
+    # 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)
     else:
@@ -74,8 +83,12 @@ def _send_direct(packet, aprs_client=None):
         cl = client.factory.create()
 
     packet.update_timestamp()
-    packet.log(header="TX")
-    cl.send(packet)
+    packet_log.log(packet, tx=True)
+    try:
+        cl.send(packet)
+    except Exception as e:
+        LOG.error(f"Failed to send packet: {packet}")
+        LOG.error(e)
 
 
 class SendPacketThread(aprsd_threads.APRSDThread):
@@ -83,10 +96,7 @@ class SendPacketThread(aprsd_threads.APRSDThread):
 
     def __init__(self, packet):
         self.packet = packet
-        name = self.packet.raw[:5]
-        super().__init__(f"TXPKT-{self.packet.msgNo}-{name}")
-        pkt_tracker = tracker.PacketTrack()
-        pkt_tracker.add(packet)
+        super().__init__(f"TX-{packet.to_call}-{self.packet.msgNo}")
 
     def loop(self):
         """Loop until a message is acked or it gets delayed.
@@ -112,7 +122,7 @@ class SendPacketThread(aprsd_threads.APRSDThread):
             return False
         else:
             send_now = False
-            if packet.send_count == packet.retry_count:
+            if packet.send_count >= packet.retry_count:
                 # we reached the send limit, don't send again
                 # TODO(hemna) - Need to put this in a delayed queue?
                 LOG.info(
@@ -121,8 +131,7 @@ class SendPacketThread(aprsd_threads.APRSDThread):
                     "Message Send Complete. Max attempts reached"
                     f" {packet.retry_count}",
                 )
-                if not packet.allow_delay:
-                    pkt_tracker.remove(packet.msgNo)
+                pkt_tracker.remove(packet.msgNo)
                 return False
 
             # Message is still outstanding and needs to be acked.
@@ -141,7 +150,7 @@ 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(packet, direct=True)
+                _send_direct(packet)
                 packet.send_count += 1
 
             time.sleep(1)
@@ -152,22 +161,24 @@ class SendPacketThread(aprsd_threads.APRSDThread):
 
 class SendAckThread(aprsd_threads.APRSDThread):
     loop_count: int = 1
+    max_retries = 3
 
     def __init__(self, packet):
         self.packet = packet
-        super().__init__(f"SendAck-{self.packet.msgNo}")
+        super().__init__(f"TXAck-{packet.to_call}-{self.packet.msgNo}")
+        self.max_retries = CONF.default_ack_send_count
 
     def loop(self):
         """Separate thread to send acks with retries."""
         send_now = False
-        if self.packet.send_count == self.packet.retry_count:
+        if self.packet.send_count == self.max_retries:
             # we reached the send limit, don't send again
             # TODO(hemna) - Need to put this in a delayed queue?
-            LOG.info(
+            LOG.debug(
                 f"{self.packet.__class__.__name__}"
                 f"({self.packet.msgNo}) "
                 "Send Complete. Max attempts reached"
-                f" {self.packet.retry_count}",
+                f" {self.max_retries}",
             )
             return False
 
@@ -188,7 +199,7 @@ class SendAckThread(aprsd_threads.APRSDThread):
             send_now = True
 
         if send_now:
-            send(self.packet, direct=True)
+            _send_direct(self.packet)
             self.packet.send_count += 1
             self.packet.last_send_time = int(round(time.time()))
 
@@ -230,7 +241,15 @@ class BeaconSendThread(aprsd_threads.APRSDThread):
                 comment="APRSD GPS Beacon",
                 symbol=CONF.beacon_symbol,
             )
-            send(pkt, direct=True)
+            try:
+                # Only send it once
+                pkt.retry_count = 1
+                send(pkt, direct=True)
+            except Exception as e:
+                LOG.error(f"Failed to send beacon: {e}")
+                client.factory.create().reset()
+                time.sleep(5)
+
         self._loop_cnt += 1
         time.sleep(1)
         return True

aprsd/utils/__init__.py

@@ -1,6 +1,7 @@
 """Utilities and helper functions."""
 
 import errno
+import functools
 import os
 import re
 import sys
@@ -22,6 +23,17 @@ else:
     from collections.abc import MutableMapping
 
 
+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
+
+
 def env(*vars, **kwargs):
     """This returns the first environment variable set.
     if none are non-empty, defaults to '' or keyword arg default

aprsd/utils/counter.py

@@ -1,9 +1,13 @@
 from multiprocessing import RawValue
+import random
 import threading
 
 import wrapt
 
 
+MAX_PACKET_ID = 9999
+
+
 class PacketCounter:
     """
     Global Packet id counter class.
@@ -17,19 +21,18 @@ class PacketCounter:
     """
 
     _instance = None
-    max_count = 9999
     lock = threading.Lock()
 
     def __new__(cls, *args, **kwargs):
         """Make this a singleton class."""
         if cls._instance is None:
             cls._instance = super().__new__(cls, *args, **kwargs)
-            cls._instance.val = RawValue("i", 1)
+            cls._instance.val = RawValue("i", random.randint(1, MAX_PACKET_ID))
         return cls._instance
 
     @wrapt.synchronized(lock)
     def increment(self):
-        if self.val.value == self.max_count:
+        if self.val.value == MAX_PACKET_ID:
             self.val.value = 1
         else:
             self.val.value += 1