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

aprsd/cmds/listen.py

@@ -10,12 +10,13 @@ import sys
 import time
 
 import click
+from loguru import logger
 from oslo_config import cfg
 from rich.console import Console
 
 # local imports here
 import aprsd
-from aprsd import cli_helper, packets, plugin, threads
+from aprsd import cli_helper, packets, plugin, threads, utils
 from aprsd.client import client_factory
 from aprsd.main import cli
 from aprsd.packets import collector as packet_collector
@@ -24,12 +25,14 @@ from aprsd.packets import seen_list
 from aprsd.stats import collector
 from aprsd.threads import keep_alive, rx
 from aprsd.threads import stats as stats_thread
+from aprsd.threads.aprsd import APRSDThread
 
 
 # setup the global logger
 # log.basicConfig(level=log.DEBUG) # level=10
 LOG = logging.getLogger("APRSD")
 CONF = cfg.CONF
+LOGU = logger
 console = Console()
 
 
@@ -47,12 +50,16 @@ def signal_handler(sig, frame):
 
 
 class APRSDListenThread(rx.APRSDRXThread):
-    def __init__(self, packet_queue, packet_filter=None, plugin_manager=None):
+    def __init__(
+        self, packet_queue, packet_filter=None, plugin_manager=None,
+        enabled_plugins=[], log_packets=False,
+    ):
         super().__init__(packet_queue)
         self.packet_filter = packet_filter
         self.plugin_manager = plugin_manager
         if self.plugin_manager:
             LOG.info(f"Plugins {self.plugin_manager.get_message_plugins()}")
+        self.log_packets = log_packets
 
     def process_packet(self, *args, **kwargs):
         packet = self._client.decode_packet(*args, **kwargs)
@@ -73,13 +80,16 @@ class APRSDListenThread(rx.APRSDRXThread):
         if self.packet_filter:
             filter_class = filters[self.packet_filter]
             if isinstance(packet, filter_class):
-                packet_log.log(packet)
+                if self.log_packets:
+                    packet_log.log(packet)
                 if self.plugin_manager:
                     # Don't do anything with the reply
                     # This is the listen only command.
                     self.plugin_manager.run(packet)
         else:
-            packet_log.log(packet)
+            if self.log_packets:
+                LOG.error("PISS")
+                packet_log.log(packet)
             if self.plugin_manager:
                 # Don't do anything with the reply.
                 # This is the listen only command.
@@ -88,6 +98,42 @@ class APRSDListenThread(rx.APRSDRXThread):
         packet_collector.PacketCollector().rx(packet)
 
 
+class ListenStatsThread(APRSDThread):
+    """Log the stats from the PacketList."""
+
+    def __init__(self):
+        super().__init__("PacketStatsLog")
+        self._last_total_rx = 0
+
+    def loop(self):
+        if self.loop_count % 10 == 0:
+            # log the stats every 10 seconds
+            stats_json = collector.Collector().collect()
+            stats = stats_json["PacketList"]
+            total_rx = stats["rx"]
+            rx_delta = total_rx - self._last_total_rx
+            rate = rx_delta / 10
+
+            # Log summary stats
+            LOGU.opt(colors=True).info(
+                f"<green>RX Rate: {rate} pps</green>  "
+                f"<yellow>Total RX: {total_rx}</yellow> "
+                f"<red>RX Last 10 secs: {rx_delta}</red>",
+            )
+            self._last_total_rx = total_rx
+
+            # Log individual type stats
+            for k, v in stats["types"].items():
+                thread_hex = f"fg {utils.hex_from_name(k)}"
+                LOGU.opt(colors=True).info(
+                    f"<{thread_hex}>{k:<15}</{thread_hex}> "
+                    f"<blue>RX: {v['rx']}</blue> <red>TX: {v['tx']}</red>",
+                )
+
+        time.sleep(1)
+        return True
+
+
 @cli.command()
 @cli_helper.add_options(cli_helper.common_options)
 @click.option(
@@ -122,6 +168,11 @@ class APRSDListenThread(rx.APRSDRXThread):
     ),
     help="Filter by packet type",
 )
+@click.option(
+    "--enable-plugin",
+    multiple=True,
+    help="Enable a plugin.  This is the name of the file in the plugins directory.",
+)
 @click.option(
     "--load-plugins",
     default=False,
@@ -133,6 +184,18 @@ class APRSDListenThread(rx.APRSDRXThread):
     nargs=-1,
     required=True,
 )
+@click.option(
+    "--log-packets",
+    default=False,
+    is_flag=True,
+    help="Log incoming packets.",
+)
+@click.option(
+    "--enable-packet-stats",
+    default=False,
+    is_flag=True,
+    help="Enable packet stats periodic logging.",
+)
 @click.pass_context
 @cli_helper.process_standard_options
 def listen(
@@ -140,8 +203,11 @@ def listen(
     aprs_login,
     aprs_password,
     packet_filter,
+    enable_plugin,
     load_plugins,
     filter,
+    log_packets,
+    enable_packet_stats,
 ):
     """Listen to packets on the APRS-IS Network based on FILTER.
 
@@ -190,27 +256,43 @@ def listen(
     LOG.info("Creating client connection")
     aprs_client = client_factory.create()
     LOG.info(aprs_client)
+    if not aprs_client.login_success:
+        # We failed to login, will just quit!
+        msg = f"Login Failure: {aprs_client.login_failure}"
+        LOG.error(msg)
+        print(msg)
+        sys.exit(-1)
 
     LOG.debug(f"Filter by '{filter}'")
     aprs_client.set_filter(filter)
 
     keepalive = keep_alive.KeepAliveThread()
-    # keepalive.start()
 
     if not CONF.enable_seen_list:
         # just deregister the class from the packet collector
         packet_collector.PacketCollector().unregister(seen_list.SeenList)
 
     pm = None
-    pm = plugin.PluginManager()
     if load_plugins:
+        pm = plugin.PluginManager()
         LOG.info("Loading plugins")
         pm.setup_plugins(load_help_plugin=False)
+    elif enable_plugin:
+        pm = plugin.PluginManager()
+        pm.setup_plugins(
+            load_help_plugin=False,
+            plugin_list=enable_plugin,
+        )
     else:
         LOG.warning(
             "Not Loading any plugins use --load-plugins to load what's "
             "defined in the config file.",
         )
+
+    if pm:
+        for p in pm.get_plugins():
+            LOG.info("Loaded plugin %s", p.__class__.__name__)
+
     stats = stats_thread.APRSDStatsStoreThread()
     stats.start()
 
@@ -219,9 +301,14 @@ def listen(
         packet_queue=threads.packet_queue,
         packet_filter=packet_filter,
         plugin_manager=pm,
+        enabled_plugins=enable_plugin,
+        log_packets=log_packets,
     )
     LOG.debug("Start APRSDListenThread")
     listen_thread.start()
+    if enable_packet_stats:
+        listen_stats = ListenStatsThread()
+        listen_stats.start()
 
     keepalive.start()
     LOG.debug("keepalive Join")

aprsd/cmds/send_message.py

@@ -14,6 +14,7 @@ from aprsd.client import client_factory
 from aprsd.main import cli
 import aprsd.packets  # noqa : F401
 from aprsd.packets import collector
+from aprsd.packets import log as packet_log
 from aprsd.threads import tx
 
 
@@ -103,7 +104,7 @@ def send_message(
         cl = client_factory.create()
         packet = cl.decode_packet(packet)
         collector.PacketCollector().rx(packet)
-        packet.log("RX")
+        packet_log.log(packet, tx=False)
         # LOG.debug("Got packet back {}".format(packet))
         if isinstance(packet, packets.AckPacket):
             got_ack = True

aprsd/cmds/server.py

@@ -54,10 +54,27 @@ def server(ctx, flush):
         LOG.error("No Clients are enabled in config.")
         sys.exit(-1)
 
+    # Make sure we have 1 client transport enabled
+    if not client_factory.is_client_enabled():
+        LOG.error("No Clients are enabled in config.")
+        sys.exit(-1)
+
+    if not client_factory.is_client_configured():
+        LOG.error("APRS client is not properly configured in config file.")
+        sys.exit(-1)
+
     # Creates the client object
     LOG.info("Creating client connection")
     aprs_client = client_factory.create()
     LOG.info(aprs_client)
+    if not aprs_client.login_success:
+        # We failed to login, will just quit!
+        msg = f"Login Failure: {aprs_client.login_failure}"
+        LOG.error(msg)
+        print(msg)
+        sys.exit(-1)
+
+    # Check to make sure the login worked.
 
     # Create the initial PM singleton and Register plugins
     # We register plugins first here so we can register each
@@ -65,7 +82,7 @@ def server(ctx, flush):
     # log file output.
     LOG.info("Loading Plugin Manager and registering plugins")
     plugin_manager = plugin.PluginManager()
-    plugin_manager.setup_plugins()
+    plugin_manager.setup_plugins(load_help_plugin=CONF.load_help_plugin)
 
     # Dump all the config options now.
     CONF.log_opt_values(LOG, logging.DEBUG)
@@ -78,15 +95,6 @@ def server(ctx, flush):
     for p in watchlist_plugins:
         LOG.info(p)
 
-    # Make sure we have 1 client transport enabled
-    if not client_factory.is_client_enabled():
-        LOG.error("No Clients are enabled in config.")
-        sys.exit(-1)
-
-    if not client_factory.is_client_configured():
-        LOG.error("APRS client is not properly configured in config file.")
-        sys.exit(-1)
-
     if not CONF.enable_seen_list:
         # just deregister the class from the packet collector
         packet_collector.PacketCollector().unregister(seen_list.SeenList)

aprsd/cmds/webchat.py

@@ -1,7 +1,6 @@
 import datetime
 import json
 import logging
-import math
 import signal
 import sys
 import threading
@@ -14,17 +13,20 @@ from flask_httpauth import HTTPBasicAuth
 from flask_socketio import Namespace, SocketIO
 from geopy.distance import geodesic
 from oslo_config import cfg
+import timeago
 from werkzeug.security import check_password_hash, generate_password_hash
 import wrapt
 
 import aprsd
-from aprsd import (
-    cli_helper, client, packets, plugin_utils, stats, threads, utils,
-)
+from aprsd import cli_helper, client, packets, plugin_utils, stats, threads
+from aprsd import utils
+from aprsd import utils as aprsd_utils
 from aprsd.client import client_factory, kiss
 from aprsd.main import cli
 from aprsd.threads import aprsd as aprsd_threads
-from aprsd.threads import keep_alive, rx, tx
+from aprsd.threads import keep_alive, rx
+from aprsd.threads import stats as stats_thread
+from aprsd.threads import tx
 from aprsd.utils import trace
 
 
@@ -36,7 +38,7 @@ socketio = None
 
 # List of callsigns that we don't want to track/fetch their location
 callsign_no_track = [
-    "REPEAT", "WB4BOR-11", "APDW16", "WXNOW", "WXBOT", "BLN0", "BLN1", "BLN2",
+    "APDW16", "BLN0", "BLN1", "BLN2",
     "BLN3", "BLN4", "BLN5", "BLN6", "BLN7", "BLN8", "BLN9",
 ]
 
@@ -131,47 +133,6 @@ def verify_password(username, password):
         return username
 
 
-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) is not tuple) or (type(point_b) is not tuple):
-        raise TypeError("Only tuples are supported as arguments")
-
-    lat1 = math.radians(point_a[0])
-    lat2 = math.radians(point_b[0])
-
-    diff_long = math.radians(point_b[1] - 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)
-    )
-
-    initial_bearing = math.atan2(x, y)
-
-    # Now we have the initial bearing but math.atan2 return values
-    # from -180° to + 180° which is not what we want for a compass bearing
-    # The solution is to normalize the initial bearing as shown below
-    initial_bearing = math.degrees(initial_bearing)
-    compass_bearing = (initial_bearing + 360) % 360
-
-    return compass_bearing
-
-
 def _build_location_from_repeat(message):
     # This is a location message Format is
     # ^ld^callsign:latitude,longitude,altitude,course,speed,timestamp
@@ -188,16 +149,19 @@ def _build_location_from_repeat(message):
             course = float(b[3])
             speed = float(b[4])
             time = int(b[5])
+            compass_bearing = aprsd_utils.degrees_to_cardinal(course)
             data = {
                 "callsign": callsign,
                 "lat": lat,
                 "lon": lon,
                 "altitude": alt,
                 "course": course,
+                "compass_bearing": compass_bearing,
                 "speed": speed,
                 "lasttime": time,
+                "timeago": timeago.format(time),
             }
-            LOG.warning(f"Location data from REPEAT {data}")
+            LOG.debug(f"Location data from REPEAT {data}")
             return data
 
 
@@ -208,25 +172,32 @@ def _calculate_location_data(location_data):
     alt = location_data["altitude"]
     speed = location_data["speed"]
     lasttime = location_data["lasttime"]
+    timeago_str = location_data.get(
+        "timeago",
+        timeago.format(lasttime),
+    )
     # now calculate distance from our own location
     distance = 0
     if CONF.webchat.latitude and CONF.webchat.longitude:
         our_lat = float(CONF.webchat.latitude)
         our_lon = float(CONF.webchat.longitude)
         distance = geodesic((our_lat, our_lon), (lat, lon)).kilometers
-        bearing = calculate_initial_compass_bearing(
+        bearing = aprsd_utils.calculate_initial_compass_bearing(
             (our_lat, our_lon),
             (lat, lon),
         )
+        compass_bearing = aprsd_utils.degrees_to_cardinal(bearing)
     return {
         "callsign": location_data["callsign"],
         "lat": lat,
         "lon": lon,
         "altitude": alt,
         "course": f"{bearing:0.1f}",
+        "compass_bearing": compass_bearing,
         "speed": speed,
         "lasttime": lasttime,
-        "distance": f"{distance:0.3f}",
+        "timeago": timeago_str,
+        "distance": f"{distance:0.1f}",
     }
 
 
@@ -348,6 +319,7 @@ class WebChatProcessPacketThread(rx.APRSDProcessPacketThread):
         elif (
             from_call not in callsign_locations
             and from_call not in callsign_no_track
+            and client_factory.create().transport() in [client.TRANSPORT_APRSIS, client.TRANSPORT_FAKE]
         ):
             # We have to ask aprs for the location for the callsign
             # We send a message packet to wb4bor-11 asking for location.
@@ -406,7 +378,8 @@ def _get_transport(stats):
 @flask_app.route("/location/<callsign>", methods=["POST"])
 def location(callsign):
     LOG.debug(f"Fetch location for callsign {callsign}")
-    populate_callsign_location(callsign)
+    if not callsign in callsign_no_track:
+        populate_callsign_location(callsign)
 
 
 @auth.login_required
@@ -527,8 +500,8 @@ class SendMessageNamespace(Namespace):
         pkt.prepare()
         self.msg = pkt
         msgs = SentMessages()
-        msgs.add(pkt)
         tx.send(pkt)
+        msgs.add(pkt)
         msgs.set_status(pkt.msgNo, "Sending")
         obj = msgs.get(pkt.msgNo)
         socketio.emit(
@@ -571,7 +544,8 @@ class SendMessageNamespace(Namespace):
 
     def on_get_callsign_location(self, data):
         LOG.debug(f"on_callsign_location {data}")
-        populate_callsign_location(data["callsign"])
+        if data["callsign"] not in callsign_no_track:
+            populate_callsign_location(data["callsign"])
 
 
 @trace.trace
@@ -645,10 +619,24 @@ def webchat(ctx, flush, port):
         LOG.error("APRS client is not properly configured in config file.")
         sys.exit(-1)
 
+    # Creates the client object
+    LOG.info("Creating client connection")
+    aprs_client = client_factory.create()
+    LOG.info(aprs_client)
+    if not aprs_client.login_success:
+        # We failed to login, will just quit!
+        msg = f"Login Failure: {aprs_client.login_failure}"
+        LOG.error(msg)
+        print(msg)
+        sys.exit(-1)
+
     keepalive = keep_alive.KeepAliveThread()
     LOG.info("Start KeepAliveThread")
     keepalive.start()
 
+    stats_store_thread = stats_thread.APRSDStatsStoreThread()
+    stats_store_thread.start()
+
     socketio = init_flask(loglevel, quiet)
     rx_thread = rx.APRSDPluginRXThread(
         packet_queue=threads.packet_queue,

aprsd/conf/common.py

@@ -136,6 +136,17 @@ aprsd_opts = [
         default=True,
         help="Set this to False, to disable logging of packets to the log file.",
     ),
+    cfg.BoolOpt(
+        "load_help_plugin",
+        default=True,
+        help="Set this to False to disable the help plugin.",
+    ),
+    cfg.BoolOpt(
+        "enable_sending_ack_packets",
+        default=True,
+        help="Set this to False, to disable sending of ack packets. This will entirely stop"
+             "APRSD from sending ack packets.",
+    ),
 ]
 
 watch_list_opts = [

aprsd/main.py

@@ -54,7 +54,7 @@ def cli(ctx):
 
 def load_commands():
     from .cmds import (  # noqa
-        completion, dev, fetch_stats, healthcheck, list_plugins, listen,
+        admin, completion, dev, fetch_stats, healthcheck, list_plugins, listen,
         send_message, server, webchat,
     )
 
@@ -79,11 +79,15 @@ def signal_handler(sig, frame):
             ),
         )
         time.sleep(1.5)
-        packets.PacketTrack().save()
-        packets.WatchList().save()
-        packets.SeenList().save()
-        packets.PacketList().save()
-        collector.Collector().collect()
+        try:
+            packets.PacketTrack().save()
+            packets.WatchList().save()
+            packets.SeenList().save()
+            packets.PacketList().save()
+            collector.Collector().collect()
+        except Exception as e:
+            LOG.error(f"Failed to save data: {e}")
+            sys.exit(0)
         # signal.signal(signal.SIGTERM, sys.exit(0))
         # sys.exit(0)
 

aprsd/packets/core.py

@@ -12,7 +12,7 @@ from dataclasses_json import (
 )
 from loguru import logger
 
-from aprsd.utils import counter
+from aprsd.utils import counter, trace
 
 
 # For mypy to be happy
@@ -63,15 +63,11 @@ def _init_msgNo():    # noqa: N802
 
 
 def _translate_fields(raw: dict) -> dict:
-    translate_fields = {
-        "from": "from_call",
-        "to": "to_call",
-    }
-    # First translate some fields
-    for key in translate_fields:
-        if key in raw:
-            raw[translate_fields[key]] = raw[key]
-            del raw[key]
+    # Direct key checks instead of iteration
+    if "from" in raw:
+        raw["from_call"] = raw.pop("from")
+    if "to" in raw:
+        raw["to_call"] = raw.pop("to")
 
     # addresse overrides to_call
     if "addresse" in raw:
@@ -103,6 +99,8 @@ class Packet:
     send_count: int = field(repr=False, default=0, compare=False, hash=False)
     retry_count: int = field(repr=False, default=3, compare=False, hash=False)
     last_send_time: float = field(repr=False, default=0, compare=False, hash=False)
+    # Was the packet acked?
+    acked: bool = field(repr=False, default=False, compare=False, hash=False)
 
     # Do we allow this packet to be saved to send later?
     allow_delay: bool = field(repr=False, default=True, compare=False, hash=False)
@@ -110,11 +108,7 @@ class Packet:
     via: Optional[str] = field(default=None, compare=False, hash=False)
 
     def get(self, key: str, default: Optional[str] = None):
-        """Emulate a getter on a dict."""
-        if hasattr(self, key):
-            return getattr(self, key)
-        else:
-            return default
+        return getattr(self, key, default)
 
     @property
     def key(self) -> str:
@@ -135,10 +129,11 @@ class Packet:
         msg = self._filter_for_send(self.raw).rstrip("\n")
         return msg
 
-    def prepare(self) -> None:
+    @trace.trace
+    def prepare(self, create_msg_number=False) -> None:
         """Do stuff here that is needed prior to sending over the air."""
         # now build the raw message for sending
-        if not self.msgNo:
+        if not self.msgNo and create_msg_number:
             self.msgNo = _init_msgNo()
         self._build_payload()
         self._build_raw()
@@ -252,11 +247,17 @@ class MessagePacket(Packet):
         return self._filter_for_send(self.message_text).rstrip("\n")
 
     def _build_payload(self):
-        self.payload = ":{}:{}{{{}".format(
-            self.to_call.ljust(9),
-            self._filter_for_send(self.message_text).rstrip("\n"),
-            str(self.msgNo),
-        )
+        if self.msgNo:
+            self.payload = ":{}:{}{{{}".format(
+                self.to_call.ljust(9),
+                self._filter_for_send(self.message_text).rstrip("\n"),
+                str(self.msgNo),
+            )
+        else:
+            self.payload = ":{}:{}".format(
+                self.to_call.ljust(9),
+                self._filter_for_send(self.message_text).rstrip("\n"),
+            )
 
 
 @dataclass_json
@@ -393,7 +394,7 @@ class BeaconPacket(GPSPacket):
         if self.raw_timestamp:
             return f"{self.from_call}:{self.raw_timestamp}"
         else:
-            return f"{self.from_call}:{self.human_info.replace(' ','')}"
+            return f"{self.from_call}:{self.human_info.replace(' ', '')}"
 
     @property
     def human_info(self) -> str:
@@ -449,7 +450,7 @@ class TelemetryPacket(GPSPacket):
         if self.raw_timestamp:
             return f"{self.from_call}:{self.raw_timestamp}"
         else:
-            return f"{self.from_call}:{self.human_info.replace(' ','')}"
+            return f"{self.from_call}:{self.human_info.replace(' ', '')}"
 
     @property
     def human_info(self) -> str:
@@ -628,11 +629,11 @@ class WeatherPacket(GPSPacket, DataClassJsonMixin):
             # Temperature in degrees F
             f"t{self.temperature:03.0f}",
             # Rainfall (in hundredths of an inch) in the last hour
-            f"r{self.rain_1h*100:03.0f}",
+            f"r{self.rain_1h * 100:03.0f}",
             # Rainfall (in hundredths of an inch) in last 24 hours
-            f"p{self.rain_24h*100:03.0f}",
+            f"p{self.rain_24h * 100:03.0f}",
             # Rainfall (in hundredths of an inch) since midnigt
-            f"P{self.rain_since_midnight*100:03.0f}",
+            f"P{self.rain_since_midnight * 100:03.0f}",
             # Humidity
             f"h{self.humidity:02d}",
             # Barometric pressure (in tenths of millibars/tenths of hPascal)