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

aprsd/cmds/listen.py

@@ -0,0 +1,231 @@
+#
+# License GPLv2
+#
+
+# python included libs
+import datetime
+import logging
+import signal
+import sys
+import time
+
+import click
+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.client import client_factory
+from aprsd.main import cli
+from aprsd.packets import collector as packet_collector
+from aprsd.packets import log as packet_log
+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
+
+
+# setup the global logger
+# log.basicConfig(level=log.DEBUG) # level=10
+LOG = logging.getLogger("APRSD")
+CONF = cfg.CONF
+console = Console()
+
+
+def signal_handler(sig, frame):
+    threads.APRSDThreadList().stop_all()
+    if "subprocess" not in str(frame):
+        LOG.info(
+            "Ctrl+C, Sending all threads exit! Can take up to 10 seconds {}".format(
+                datetime.datetime.now(),
+            ),
+        )
+        time.sleep(5)
+        # Last save to disk
+        collector.Collector().collect()
+
+
+class APRSDListenThread(rx.APRSDRXThread):
+    def __init__(self, packet_queue, packet_filter=None, plugin_manager=None):
+        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()}")
+
+    def process_packet(self, *args, **kwargs):
+        packet = self._client.decode_packet(*args, **kwargs)
+        filters = {
+            packets.Packet.__name__: packets.Packet,
+            packets.AckPacket.__name__: packets.AckPacket,
+            packets.BeaconPacket.__name__: packets.BeaconPacket,
+            packets.GPSPacket.__name__: packets.GPSPacket,
+            packets.MessagePacket.__name__: packets.MessagePacket,
+            packets.MicEPacket.__name__: packets.MicEPacket,
+            packets.ObjectPacket.__name__: packets.ObjectPacket,
+            packets.StatusPacket.__name__: packets.StatusPacket,
+            packets.ThirdPartyPacket.__name__: packets.ThirdPartyPacket,
+            packets.WeatherPacket.__name__: packets.WeatherPacket,
+            packets.UnknownPacket.__name__: packets.UnknownPacket,
+        }
+
+        if self.packet_filter:
+            filter_class = filters[self.packet_filter]
+            if isinstance(packet, filter_class):
+                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.plugin_manager:
+                # Don't do anything with the reply.
+                # This is the listen only command.
+                self.plugin_manager.run(packet)
+
+        packet_collector.PacketCollector().rx(packet)
+
+
+@cli.command()
+@cli_helper.add_options(cli_helper.common_options)
+@click.option(
+    "--aprs-login",
+    envvar="APRS_LOGIN",
+    show_envvar=True,
+    help="What callsign to send the message from.",
+)
+@click.option(
+    "--aprs-password",
+    envvar="APRS_PASSWORD",
+    show_envvar=True,
+    help="the APRS-IS password for APRS_LOGIN",
+)
+@click.option(
+    "--packet-filter",
+    type=click.Choice(
+        [
+            packets.AckPacket.__name__,
+            packets.BeaconPacket.__name__,
+            packets.GPSPacket.__name__,
+            packets.MicEPacket.__name__,
+            packets.MessagePacket.__name__,
+            packets.ObjectPacket.__name__,
+            packets.RejectPacket.__name__,
+            packets.StatusPacket.__name__,
+            packets.ThirdPartyPacket.__name__,
+            packets.UnknownPacket.__name__,
+            packets.WeatherPacket.__name__,
+        ],
+        case_sensitive=False,
+    ),
+    help="Filter by packet type",
+)
+@click.option(
+    "--load-plugins",
+    default=False,
+    is_flag=True,
+    help="Load plugins as enabled in aprsd.conf ?",
+)
+@click.argument(
+    "filter",
+    nargs=-1,
+    required=True,
+)
+@click.pass_context
+@cli_helper.process_standard_options
+def listen(
+    ctx,
+    aprs_login,
+    aprs_password,
+    packet_filter,
+    load_plugins,
+    filter,
+):
+    """Listen to packets on the APRS-IS Network based on FILTER.
+
+    FILTER is the APRS Filter to use.\n
+     see http://www.aprs-is.net/javAPRSFilter.aspx\n
+    r/lat/lon/dist - Range Filter Pass posits and objects within dist km from lat/lon.\n
+    p/aa/bb/cc... - Prefix Filter Pass traffic with fromCall that start with aa or bb or cc.\n
+    b/call1/call2... - Budlist Filter Pass all traffic from exact call: call1, call2, ... (* wild card allowed) \n
+    o/obj1/obj2... - Object Filter Pass all objects with the exact name of obj1, obj2, ... (* wild card allowed)\n
+
+    """
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    if not aprs_login:
+        click.echo(ctx.get_help())
+        click.echo("")
+        ctx.fail("Must set --aprs-login or APRS_LOGIN")
+        ctx.exit()
+
+    if not aprs_password:
+        click.echo(ctx.get_help())
+        click.echo("")
+        ctx.fail("Must set --aprs-password or APRS_PASSWORD")
+        ctx.exit()
+
+    # CONF.aprs_network.login = aprs_login
+    # config["aprs"]["password"] = aprs_password
+
+    LOG.info(f"APRSD Listen Started version: {aprsd.__version__}")
+
+    CONF.log_opt_values(LOG, logging.DEBUG)
+    collector.Collector()
+
+    # Try and load saved MsgTrack list
+    LOG.debug("Loading saved MsgTrack object.")
+
+    # Initialize the client factory and create
+    # The correct client object ready for use
+    # 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)
+
+    # Creates the client object
+    LOG.info("Creating client connection")
+    aprs_client = client_factory.create()
+    LOG.info(aprs_client)
+
+    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:
+        LOG.info("Loading plugins")
+        pm.setup_plugins(load_help_plugin=False)
+    else:
+        LOG.warning(
+            "Not Loading any plugins use --load-plugins to load what's "
+            "defined in the config file.",
+        )
+    stats = stats_thread.APRSDStatsStoreThread()
+    stats.start()
+
+    LOG.debug("Create APRSDListenThread")
+    listen_thread = APRSDListenThread(
+        packet_queue=threads.packet_queue,
+        packet_filter=packet_filter,
+        plugin_manager=pm,
+    )
+    LOG.debug("Start APRSDListenThread")
+    listen_thread.start()
+
+    keepalive.start()
+    LOG.debug("keepalive Join")
+    keepalive.join()
+    LOG.debug("listen_thread Join")
+    listen_thread.join()
+    stats.join()

aprsd/cmds/send_message.py

@@ -0,0 +1,171 @@
+import logging
+import sys
+import time
+
+import aprslib
+from aprslib.exceptions import LoginError
+import click
+from oslo_config import cfg
+
+import aprsd
+from aprsd import cli_helper, packets
+from aprsd import conf  # noqa : F401
+from aprsd.client import client_factory
+from aprsd.main import cli
+import aprsd.packets  # noqa : F401
+from aprsd.packets import collector
+from aprsd.threads import tx
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+@cli.command()
+@cli_helper.add_options(cli_helper.common_options)
+@click.option(
+    "--aprs-login",
+    envvar="APRS_LOGIN",
+    show_envvar=True,
+    help="What callsign to send the message from. Defaults to config entry.",
+)
+@click.option(
+    "--aprs-password",
+    envvar="APRS_PASSWORD",
+    show_envvar=True,
+    help="the APRS-IS password for APRS_LOGIN. Defaults to config entry.",
+)
+@click.option(
+    "--no-ack",
+    "-n",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Don't wait for an ack, just sent it to APRS-IS and bail.",
+)
+@click.option(
+    "--wait-response",
+    "-w",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Wait for a response to the message?",
+)
+@click.option("--raw", default=None, help="Send a raw message.  Implies --no-ack")
+@click.argument("tocallsign", required=True)
+@click.argument("command", nargs=-1, required=True)
+@click.pass_context
+@cli_helper.process_standard_options
+def send_message(
+    ctx,
+    aprs_login,
+    aprs_password,
+    no_ack,
+    wait_response,
+    raw,
+    tocallsign,
+    command,
+):
+    """Send a message to a callsign via APRS_IS."""
+    global got_ack, got_response
+    quiet = ctx.obj["quiet"]
+
+    if not aprs_login:
+        if CONF.aprs_network.login == conf.client.DEFAULT_LOGIN:
+            click.echo("Must set --aprs_login or APRS_LOGIN")
+            ctx.exit(-1)
+            return
+        else:
+            aprs_login = CONF.aprs_network.login
+
+    if not aprs_password:
+        if not CONF.aprs_network.password:
+            click.echo("Must set --aprs-password or APRS_PASSWORD")
+            ctx.exit(-1)
+            return
+        else:
+            aprs_password = CONF.aprs_network.password
+
+    LOG.info(f"APRSD LISTEN Started version: {aprsd.__version__}")
+    if type(command) is tuple:
+        command = " ".join(command)
+    if not quiet:
+        if raw:
+            LOG.info(f"L'{aprs_login}' R'{raw}'")
+        else:
+            LOG.info(f"L'{aprs_login}' To'{tocallsign}' C'{command}'")
+
+    got_ack = False
+    got_response = False
+
+    def rx_packet(packet):
+        global got_ack, got_response
+        cl = client_factory.create()
+        packet = cl.decode_packet(packet)
+        collector.PacketCollector().rx(packet)
+        packet.log("RX")
+        # LOG.debug("Got packet back {}".format(packet))
+        if isinstance(packet, packets.AckPacket):
+            got_ack = True
+        else:
+            got_response = True
+            from_call = packet.from_call
+            our_call = CONF.callsign.lower()
+            tx.send(
+                packets.AckPacket(
+                    from_call=our_call,
+                    to_call=from_call,
+                    msgNo=packet.msgNo,
+                ),
+                direct=True,
+            )
+
+        if got_ack:
+            if wait_response:
+                if got_response:
+                    sys.exit(0)
+            else:
+                sys.exit(0)
+
+    try:
+        client_factory.create().client
+    except LoginError:
+        sys.exit(-1)
+
+    # Send a message
+    # then we setup a consumer to rx messages
+    # We should get an ack back as well as a new message
+    # we should bail after we get the ack and send an ack back for the
+    # message
+    if raw:
+        tx.send(
+            packets.Packet(from_call="", to_call="", raw=raw),
+            direct=True,
+        )
+        sys.exit(0)
+    else:
+        tx.send(
+            packets.MessagePacket(
+                from_call=aprs_login,
+                to_call=tocallsign,
+                message_text=command,
+            ),
+            direct=True,
+        )
+
+    if no_ack:
+        sys.exit(0)
+
+    try:
+        # This will register a packet consumer with aprslib
+        # When new packets come in the consumer will process
+        # the packet
+        aprs_client = client_factory.create().client
+        aprs_client.consumer(rx_packet, raw=False)
+    except aprslib.exceptions.ConnectionDrop:
+        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
+        aprs_client.reset()

aprsd/cmds/server.py

@@ -0,0 +1,137 @@
+import logging
+import signal
+import sys
+
+import click
+from oslo_config import cfg
+
+import aprsd
+from aprsd import cli_helper
+from aprsd import main as aprsd_main
+from aprsd import plugin, threads, utils
+from aprsd.client import client_factory
+from aprsd.main import cli
+from aprsd.packets import collector as packet_collector
+from aprsd.packets import seen_list
+from aprsd.threads import keep_alive, log_monitor, registry, rx
+from aprsd.threads import stats as stats_thread
+from aprsd.threads import tx
+
+
+CONF = cfg.CONF
+LOG = logging.getLogger("APRSD")
+
+
+# main() ###
+@cli.command()
+@cli_helper.add_options(cli_helper.common_options)
+@click.option(
+    "-f",
+    "--flush",
+    "flush",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Flush out all old aged messages on disk.",
+)
+@click.pass_context
+@cli_helper.process_standard_options
+def server(ctx, flush):
+    """Start the aprsd server gateway process."""
+    signal.signal(signal.SIGINT, aprsd_main.signal_handler)
+    signal.signal(signal.SIGTERM, aprsd_main.signal_handler)
+
+    level, msg = utils._check_version()
+    if level:
+        LOG.warning(msg)
+    else:
+        LOG.info(msg)
+    LOG.info(f"APRSD Started version: {aprsd.__version__}")
+
+    # Initialize the client factory and create
+    # The correct client object ready for use
+    if not client_factory.is_client_enabled():
+        LOG.error("No Clients are enabled in config.")
+        sys.exit(-1)
+
+    # Creates the client object
+    LOG.info("Creating client connection")
+    aprs_client = client_factory.create()
+    LOG.info(aprs_client)
+
+    # Create the initial PM singleton and Register plugins
+    # We register plugins first here so we can register each
+    # plugins config options, so we can dump them all in the
+    # log file output.
+    LOG.info("Loading Plugin Manager and registering plugins")
+    plugin_manager = plugin.PluginManager()
+    plugin_manager.setup_plugins()
+
+    # Dump all the config options now.
+    CONF.log_opt_values(LOG, logging.DEBUG)
+    message_plugins = plugin_manager.get_message_plugins()
+    watchlist_plugins = plugin_manager.get_watchlist_plugins()
+    LOG.info("Message Plugins enabled and running:")
+    for p in message_plugins:
+        LOG.info(p)
+    LOG.info("Watchlist Plugins enabled and running:")
+    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)
+
+    # Now load the msgTrack from disk if any
+    if flush:
+        LOG.debug("Flushing All packet tracking objects.")
+        packet_collector.PacketCollector().flush()
+    else:
+        # Try and load saved MsgTrack list
+        LOG.debug("Loading saved packet tracking data.")
+        packet_collector.PacketCollector().load()
+
+    # Now start all the main processing threads.
+
+    keepalive = keep_alive.KeepAliveThread()
+    keepalive.start()
+
+    stats_store_thread = stats_thread.APRSDStatsStoreThread()
+    stats_store_thread.start()
+
+    rx_thread = rx.APRSDPluginRXThread(
+        packet_queue=threads.packet_queue,
+    )
+    process_thread = rx.APRSDPluginProcessPacketThread(
+        packet_queue=threads.packet_queue,
+    )
+    rx_thread.start()
+    process_thread.start()
+
+    if CONF.enable_beacon:
+        LOG.info("Beacon Enabled.  Starting Beacon thread.")
+        bcn_thread = tx.BeaconSendThread()
+        bcn_thread.start()
+
+    if CONF.aprs_registry.enabled:
+        LOG.info("Registry Enabled.  Starting Registry thread.")
+        registry_thread = registry.APRSRegistryThread()
+        registry_thread.start()
+
+    if CONF.admin.web_enabled:
+        log_monitor_thread = log_monitor.LogMonitorThread()
+        log_monitor_thread.start()
+
+    rx_thread.join()
+    process_thread.join()
+
+    return 0