aprsd 1.0.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

aprsd/threads/keep_alive.py

@@ -0,0 +1,124 @@
+import datetime
+import logging
+import time
+import tracemalloc
+
+from oslo_config import cfg
+
+from aprsd import packets, utils
+from aprsd.client import client_factory
+from aprsd.log import log as aprsd_log
+from aprsd.stats import collector
+from aprsd.threads import APRSDThread, APRSDThreadList
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class KeepAliveThread(APRSDThread):
+    cntr = 0
+    checker_time = datetime.datetime.now()
+
+    def __init__(self):
+        tracemalloc.start()
+        super().__init__("KeepAlive")
+        max_timeout = {"hours": 0.0, "minutes": 2, "seconds": 0}
+        self.max_delta = datetime.timedelta(**max_timeout)
+
+    def loop(self):
+        if self.loop_count % 60 == 0:
+            stats_json = collector.Collector().collect()
+            pl = packets.PacketList()
+            thread_list = APRSDThreadList()
+            now = datetime.datetime.now()
+
+            if "EmailStats" in stats_json:
+                email_stats = stats_json["EmailStats"]
+                if email_stats.get("last_check_time"):
+                    email_thread_time = utils.strfdelta(now - email_stats["last_check_time"])
+                else:
+                    email_thread_time = "N/A"
+            else:
+                email_thread_time = "N/A"
+
+            if "APRSClientStats" in stats_json and stats_json["APRSClientStats"].get("transport") == "aprsis":
+                if 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 = 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:{} LoggingQueue:{}"
+            ).format(
+                stats_json["APRSDStats"]["callsign"],
+                stats_json["APRSDStats"]["uptime"],
+                pl.total_rx(),
+                pl.total_tx(),
+                tracked_packets,
+                tx_msg,
+                rx_msg,
+                last_msg_time,
+                email_thread_time,
+                stats_json["APRSDStats"]["memory_current_str"],
+                stats_json["APRSDStats"]["memory_peak_str"],
+                len(thread_list),
+                aprsd_log.logging_queue.qsize(),
+            )
+            LOG.info(keepalive)
+            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()
+            # Reset the connection if it's dead and this isn't our
+            # First time through the loop.
+            # The first time through the loop can happen at startup where
+            # The keepalive thread starts before the client has a chance
+            # to make it's connection the first time.
+            if not cl.is_alive() and self.cntr > 0:
+                LOG.error(f"{cl.__class__.__name__} is not alive!!! Resetting")
+                client_factory.create().reset()
+            # else:
+            #     # See if we should reset the aprs-is client
+            #     # Due to losing a keepalive from them
+            #     delta_dict = utils.parse_delta_str(last_msg_time)
+            #     delta = datetime.timedelta(**delta_dict)
+            #
+            #     if delta > self.max_delta:
+            #         #  We haven't gotten a keepalive from aprs-is in a while
+            #         # reset the connection.a
+            #         if not client.KISSClient.is_enabled():
+            #             LOG.warning(f"Resetting connection to APRS-IS {delta}")
+            #             client.factory.create().reset()
+
+            # Check version every day
+            delta = now - self.checker_time
+            if delta > datetime.timedelta(hours=24):
+                self.checker_time = now
+                level, msg = utils._check_version()
+                if level:
+                    LOG.warning(msg)
+            self.cntr += 1
+        time.sleep(1)
+        return True

aprsd/threads/log_monitor.py

@@ -0,0 +1,121 @@
+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()
+            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:
+                    LOG.warning(f"Failed to send log entries. len={len(entries)}")
+
+
+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)
+
+    @wrapt.synchronized(lock)
+    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)
+
+
+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)
+            if isinstance(record, list):
+                for item in record:
+                    entry = self.json_record(item)
+                    LogEntries().add(entry)
+            else:
+                entry = self.json_record(record)
+                LogEntries().add(entry)
+        except Exception:
+            # Just ignore thi
+            pass
+
+        send_log_entries()
+        return True
+
+    def json_record(self, record):
+        entry = {}
+        entry["filename"] = record.filename
+        entry["funcName"] = record.funcName
+        entry["levelname"] = record.levelname
+        entry["lineno"] = record.lineno
+        entry["module"] = record.module
+        entry["name"] = record.name
+        entry["pathname"] = record.pathname
+        entry["process"] = record.process
+        entry["processName"] = record.processName
+        if hasattr(record, "stack_info"):
+            entry["stack_info"] = record.stack_info
+        else:
+            entry["stack_info"] = None
+        entry["thread"] = record.thread
+        entry["threadName"] = record.threadName
+        entry["message"] = record.getMessage()
+        return entry

aprsd/threads/registry.py

@@ -0,0 +1,56 @@
+import logging
+import time
+
+from oslo_config import cfg
+import requests
+
+import aprsd
+from aprsd import threads as aprsd_threads
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class APRSRegistryThread(aprsd_threads.APRSDThread):
+    """This sends service information to the configured APRS Registry."""
+    _loop_cnt: int = 1
+
+    def __init__(self):
+        super().__init__("APRSRegistryThread")
+        self._loop_cnt = 1
+        if not CONF.aprs_registry.enabled:
+            LOG.error(
+                "APRS Registry is not enabled.  ",
+            )
+            LOG.error(
+                "APRS Registry thread is STOPPING.",
+            )
+            self.stop()
+        LOG.info(
+            "APRS Registry thread is running and will send "
+            f"info every {CONF.aprs_registry.frequency_seconds} seconds "
+            f"to {CONF.aprs_registry.registry_url}.",
+        )
+
+    def loop(self):
+        # Only call the registry every N seconds
+        if self._loop_cnt % CONF.aprs_registry.frequency_seconds == 0:
+            info = {
+                "callsign": CONF.callsign,
+                "description": CONF.aprs_registry.description,
+                "service_website": CONF.aprs_registry.service_website,
+                "software": f"APRSD version {aprsd.__version__} "
+                            "https://github.com/craigerl/aprsd",
+            }
+            try:
+                requests.post(
+                    f"{CONF.aprs_registry.registry_url}",
+                    json=info,
+                )
+            except Exception as e:
+                LOG.error(f"Failed to send registry info: {e}")
+
+        time.sleep(1)
+        self._loop_cnt += 1
+        return True

aprsd/threads/rx.py

@@ -0,0 +1,354 @@
+import abc
+import logging
+import queue
+import time
+
+import aprslib
+from oslo_config import cfg
+
+from aprsd import packets, plugin
+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
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+class APRSDRXThread(APRSDThread):
+    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
+        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
+            # When new packets come in the consumer will process
+            # the packet
+
+            # Do a partial here because the consumer signature doesn't allow
+            # For kwargs to be passed in to the consumer func we declare
+            # and the aprslib developer didn't want to allow a PR to add
+            # kwargs.  :(
+            # https://github.com/rossengeorgiev/aprs-python/pull/56
+            self._client.consumer(
+                self._process_packet, raw=False, blocking=False,
+            )
+        except (
+            aprslib.exceptions.ConnectionDrop,
+            aprslib.exceptions.ConnectionError,
+        ):
+            LOG.error("Connection dropped, reconnecting")
+            # 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
+
+
+class APRSDDupeRXThread(APRSDRXThread):
+    """Process received packets.
+
+    This is the main APRSD Server command thread that
+    receives packets and makes sure the packet
+    hasn't been seen previously before sending it on
+    to be processed.
+    """
+
+    def process_packet(self, *args, **kwargs):
+        """This handles the processing of an inbound packet.
+
+        When a packet is received by the connected client object,
+        it sends the raw packet into this function.  This function then
+        decodes the packet via the client, and then processes the packet.
+        Ack Packets are sent to the PluginProcessPacketThread for processing.
+        All other packets have to be checked as a dupe, and then only after
+        we haven't seen this packet before, do we send it to the
+        PluginProcessPacketThread for processing.
+        """
+        packet = self._client.decode_packet(*args, **kwargs)
+        # LOG.debug(raw)
+        packet_log.log(packet)
+        pkt_list = packets.PacketList()
+
+        if isinstance(packet, packets.AckPacket):
+            # We don't need to drop AckPackets, those should be
+            # processed.
+            self.packet_queue.put(packet)
+        else:
+            # Make sure we aren't re-processing the same packet
+            # For RF based APRS Clients we can get duplicate packets
+            # So we need to track them and not process the dupes.
+            found = False
+            try:
+                # Find the packet in the list of already seen packets
+                # Based on the packet.key
+                found = pkt_list.find(packet)
+            except KeyError:
+                found = False
+
+            if not found:
+                # 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 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:
+                LOG.warning(
+                    f"Packet {packet.from_call}:{packet.msgNo} already tracked "
+                    f"but older than {CONF.packet_dupe_timeout} seconds. processing.",
+                )
+                collector.PacketCollector().rx(packet)
+                self.packet_queue.put(packet)
+
+
+class APRSDPluginRXThread(APRSDDupeRXThread):
+    """"Process received packets.
+
+    For backwards compatibility, we keep the APRSDPluginRXThread.
+    """
+
+
+class APRSDProcessPacketThread(APRSDThread):
+    """Base class for processing received packets.
+
+    This is the base class for processing packets coming from
+    the consumer.  This base class handles sending ack packets and
+    will ack a message before sending the packet to the subclass
+    for processing."""
+
+    def __init__(self, packet_queue):
+        self.packet_queue = packet_queue
+        super().__init__("ProcessPKT")
+
+    def process_ack_packet(self, packet):
+        """We got an ack for a message, no need to resend it."""
+        ack_num = packet.msgNo
+        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.debug(f"Got REJECT for message {ack_num}")
+        collector.PacketCollector().rx(packet)
+
+    def loop(self):
+        try:
+            packet = self.packet_queue.get(timeout=1)
+            if packet:
+                self.process_packet(packet)
+        except queue.Empty:
+            pass
+        return True
+
+    def process_packet(self, packet):
+        """Process a packet received from aprs-is server."""
+        LOG.debug(f"ProcessPKT-LOOP {self.loop_count}")
+        our_call = CONF.callsign.lower()
+
+        from_call = packet.from_call
+        if packet.addresse:
+            to_call = packet.addresse
+        else:
+            to_call = packet.to_call
+        msg_id = packet.msgNo
+
+        # We don't put ack packets destined for us through the
+        # plugins.
+        if (
+            isinstance(packet, packets.AckPacket)
+            and packet.addresse.lower() == our_call
+        ):
+            self.process_ack_packet(packet)
+        elif (
+            isinstance(packet, packets.RejectPacket)
+            and packet.addresse.lower() == our_call
+        ):
+            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:
+                    # 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,
+                        ),
+                    )
+
+                    self.process_our_message_packet(packet)
+                else:
+                    # Packet wasn't meant for us!
+                    self.process_other_packet(packet, for_us=False)
+            else:
+                self.process_other_packet(
+                    packet, for_us=(to_call.lower() == our_call),
+                )
+        LOG.debug(f"Packet processing complete for pkt '{packet.key}'")
+        return False
+
+    @abc.abstractmethod
+    def process_our_message_packet(self, packet):
+        """Process a MessagePacket destined for us!"""
+
+    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.")
+        else:
+            LOG.info("Got a non AckPacket/MessagePacket")
+
+
+class APRSDPluginProcessPacketThread(APRSDProcessPacketThread):
+    """Process the packet through the plugin manager.
+
+    This is the main aprsd server plugin processing thread."""
+
+    def process_other_packet(self, packet, for_us=False):
+        pm = plugin.PluginManager()
+        try:
+            results = pm.run_watchlist(packet)
+            for reply in results:
+                if isinstance(reply, list):
+                    for subreply in reply:
+                        LOG.debug(f"Sending '{subreply}'")
+                        if isinstance(subreply, packets.Packet):
+                            tx.send(subreply)
+                        else:
+                            wl = CONF.watch_list
+                            to_call = wl["alert_callsign"]
+                            tx.send(
+                                packets.MessagePacket(
+                                    from_call=CONF.callsign,
+                                    to_call=to_call,
+                                    message_text=subreply,
+                                ),
+                            )
+                elif isinstance(reply, packets.Packet):
+                    # We have a message based object.
+                    tx.send(reply)
+        except Exception as ex:
+            LOG.error("Plugin failed!!!")
+            LOG.exception(ex)
+
+    def process_our_message_packet(self, packet):
+        """Send the packet through the plugins."""
+        from_call = packet.from_call
+        if packet.addresse:
+            to_call = packet.addresse
+        else:
+            to_call = None
+
+        pm = plugin.PluginManager()
+        try:
+            results = pm.run(packet)
+            replied = False
+            for reply in results:
+                if isinstance(reply, list):
+                    # one of the plugins wants to send multiple messages
+                    replied = True
+                    for subreply in reply:
+                        LOG.debug(f"Sending '{subreply}'")
+                        if isinstance(subreply, packets.Packet):
+                            tx.send(subreply)
+                        else:
+                            tx.send(
+                                packets.MessagePacket(
+                                    from_call=CONF.callsign,
+                                    to_call=from_call,
+                                    message_text=subreply,
+                                ),
+                            )
+                elif isinstance(reply, packets.Packet):
+                    # We have a message based object.
+                    tx.send(reply)
+                    replied = True
+                else:
+                    replied = True
+                    # A plugin can return a null message flag which signals
+                    # us that they processed the message correctly, but have
+                    # nothing to reply with, so we avoid replying with a
+                    # usage string
+                    if reply is not packets.NULL_MESSAGE:
+                        LOG.debug(f"Sending '{reply}'")
+                        tx.send(
+                            packets.MessagePacket(
+                                from_call=CONF.callsign,
+                                to_call=from_call,
+                                message_text=reply,
+                            ),
+                        )
+
+            # 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"
+                tx.send(
+                    packets.MessagePacket(
+                        from_call=CONF.callsign,
+                        to_call=from_call,
+                        message_text=message_text,
+                    ),
+                )
+        except Exception as ex:
+            LOG.error("Plugin failed!!!")
+            LOG.exception(ex)
+            # Do we need to send a reply?
+            if to_call == CONF.callsign:
+                reply = "A Plugin failed! try again?"
+                tx.send(
+                    packets.MessagePacket(
+                        from_call=CONF.callsign,
+                        to_call=from_call,
+                        message_text=reply,
+                    ),
+                )
+
+        LOG.debug("Completed process_our_message_packet")

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