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

aprsd/plugin.py

@@ -1,149 +1,190 @@
-# The base plugin class
+from __future__ import annotations
+
 import abc
-import fnmatch
-import imp
+import importlib
 import inspect
-import json
 import logging
-import os
 import re
-import subprocess
-import time
+import textwrap
+import threading
 
+from oslo_config import cfg
 import pluggy
-import requests
-import six
 
-from aprsd.fuzzyclock import fuzzy
+import aprsd
+from aprsd import client, packets, threads
+from aprsd.packets import watch_list
+
 
 # setup the global logger
+CONF = cfg.CONF
 LOG = logging.getLogger("APRSD")
 
+CORE_MESSAGE_PLUGINS = [
+    "aprsd.plugins.email.EmailPlugin",
+    "aprsd.plugins.fortune.FortunePlugin",
+    "aprsd.plugins.location.LocationPlugin",
+    "aprsd.plugins.ping.PingPlugin",
+    "aprsd.plugins.query.QueryPlugin",
+    "aprsd.plugins.time.TimePlugin",
+    "aprsd.plugins.weather.USWeatherPlugin",
+    "aprsd.plugins.version.VersionPlugin",
+]
+
+CORE_NOTIFY_PLUGINS = [
+    "aprsd.plugins.notify.NotifySeenPlugin",
+]
+
 hookspec = pluggy.HookspecMarker("aprsd")
 hookimpl = pluggy.HookimplMarker("aprsd")
 
-CORE_PLUGINS = [
-    "FortunePlugin",
-    "LocationPlugin",
-    "PingPlugin",
-    "TimePlugin",
-    "WeatherPlugin",
-]
 
+class APRSDPluginSpec:
+    """A hook specification namespace."""
 
-def setup_plugins(config):
-    """Create the plugin manager and register plugins."""
+    @hookspec
+    def filter(self, packet: type[packets.Packet]):
+        """My special little hook that you can customize."""
 
-    LOG.info("Loading Core APRSD Command Plugins")
-    enabled_plugins = config["aprsd"].get("enabled_plugins", None)
-    pm = pluggy.PluginManager("aprsd")
-    pm.add_hookspecs(APRSDCommandSpec)
-    for p_name in CORE_PLUGINS:
-        plugin_obj = None
-        if enabled_plugins:
-            if p_name in enabled_plugins:
-                plugin_obj = globals()[p_name](config)
-        else:
-            # Enabled plugins isn't set, so we default to loading all of
-            # the core plugins.
-            plugin_obj = globals()[p_name](config)
 
-        if plugin_obj:
-            LOG.info(
-                "Registering Command plugin '{}'({})  '{}'".format(
-                    p_name, plugin_obj.version, plugin_obj.command_regex
-                )
-            )
-            pm.register(plugin_obj)
-
-    plugin_dir = config["aprsd"].get("plugin_dir", None)
-    if plugin_dir:
-        LOG.info("Trying to load custom plugins from '{}'".format(plugin_dir))
-        cpm = PluginManager(config)
-        plugins_list = cpm.load_plugins(plugin_dir)
-        LOG.info("Discovered {} modules to load".format(len(plugins_list)))
-        for o in plugins_list:
-            plugin_obj = None
-            if enabled_plugins:
-                if o["name"] in enabled_plugins:
-                    plugin_obj = o["obj"]
-                else:
-                    LOG.info(
-                        "'{}' plugin not listed in config aprsd:enabled_plugins".format(
-                            o["name"]
+class APRSDPluginBase(metaclass=abc.ABCMeta):
+    """The base class for all APRSD Plugins."""
+
+    config = None
+    rx_count = 0
+    tx_count = 0
+    version = aprsd.__version__
+
+    # Holds the list of APRSDThreads that the plugin creates
+    threads = []
+    # Set this in setup()
+    enabled = False
+
+    def __init__(self):
+        self.message_counter = 0
+        self.setup()
+        self.threads = self.create_threads() or []
+        self.start_threads()
+
+    def start_threads(self) -> None:
+        if self.enabled and self.threads:
+            if not isinstance(self.threads, list):
+                self.threads = [self.threads]
+
+            try:
+                for thread in self.threads:
+                    if isinstance(thread, threads.APRSDThread):
+                        thread.start()
+                    else:
+                        LOG.error(
+                            "Can't start thread {}:{}, Must be a child "
+                            "of aprsd.threads.APRSDThread".format(
+                                self,
+                                thread,
+                            ),
                         )
-                    )
-            else:
-                # not setting enabled plugins means load all?
-                plugin_obj = o["obj"]
-
-            if plugin_obj:
-                LOG.info(
-                    "Registering Command plugin '{}'({}) '{}'".format(
-                        o["name"], o["obj"].version, o["obj"].command_regex
-                    )
+            except Exception:
+                LOG.error(
+                    "Failed to start threads for plugin {}".format(
+                        self,
+                    ),
                 )
-                pm.register(o["obj"])
 
-    else:
-        LOG.info("Skipping Custom Plugins.")
+    @property
+    def message_count(self) -> int:
+        return self.message_counter
 
-    LOG.info("Completed Plugin Loading.")
-    return pm
+    def help(self) -> str:
+        return "Help!"
 
+    @abc.abstractmethod
+    def setup(self):
+        """Do any plugin setup here."""
+        self.enabled = True
 
-class PluginManager(object):
-    def __init__(self, config):
-        self.obj_list = []
-        self.config = config
+    def create_threads(self):
+        """Gives the plugin writer the ability start a background thread."""
+        return []
 
-    def load_plugins(self, module_path):
-        dir_path = os.path.dirname(os.path.realpath(module_path))
-        pattern = "*.py"
+    def rx_inc(self):
+        self.rx_count += 1
 
-        self.obj_list = []
+    def tx_inc(self):
+        self.tx_count += 1
 
-        for path, subdirs, files in os.walk(dir_path):
-            for name in files:
-                if fnmatch.fnmatch(name, pattern):
-                    found_module = imp.find_module(name[:-3], [path])
-                    module = imp.load_module(
-                        name, found_module[0], found_module[1], found_module[2]
-                    )
-                    for mem_name, obj in inspect.getmembers(module):
-                        if (
-                            inspect.isclass(obj)
-                            and inspect.getmodule(obj) is module
-                            and self.is_plugin(obj)
-                        ):
-                            self.obj_list.append(
-                                {"name": mem_name, "obj": obj(self.config)}
-                            )
-
-        return self.obj_list
+    def stop_threads(self):
+        """Stop any threads this plugin might have created."""
+        for thread in self.threads:
+            if isinstance(thread, threads.APRSDThread):
+                thread.stop()
 
-    def is_plugin(self, obj):
-        for c in inspect.getmro(obj):
-            if issubclass(c, APRSDPluginBase):
-                return True
+    @abc.abstractmethod
+    def filter(self, packet: type[packets.Packet]) -> str | packets.MessagePacket:
+        pass
 
-        return False
+    @abc.abstractmethod
+    def process(self, packet: type[packets.Packet]):
+        """This is called when the filter passes."""
+
+
+class APRSDWatchListPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
+    """Base plugin class for all notification APRSD plugins.
+
+    All these plugins will get every packet seen by APRSD's
+    registered list of HAM callsigns in the config file's
+    watch_list.
+
+    When you want to 'notify' something when a packet is seen
+    by a particular HAM callsign, write a plugin based off of
+    this class.
+    """
+
+    def setup(self):
+        # if we have a watch list enabled, we need to add filtering
+        # to enable seeing packets from the watch list.
+        if CONF.watch_list.enabled:
+            # watch list is enabled
+            self.enabled = True
+            watch_list = CONF.watch_list.callsigns
+            # make sure the timeout is set or this doesn't work
+            if watch_list:
+                aprs_client = client.client_factory.create().client
+                filter_str = "b/{}".format("/".join(watch_list))
+                aprs_client.set_filter(filter_str)
+            else:
+                LOG.warning("Watch list enabled, but no callsigns set.")
 
+    @hookimpl
+    def filter(self, packet: type[packets.Packet]) -> str | packets.MessagePacket:
+        result = packets.NULL_MESSAGE
+        if self.enabled:
+            wl = watch_list.WatchList()
+            if wl.callsign_in_watchlist(packet.from_call):
+                # packet is from a callsign in the watch list
+                self.rx_inc()
+                try:
+                    result = self.process(packet)
+                except Exception as ex:
+                    LOG.error(
+                        "Plugin {} failed to process packet {}".format(
+                            self.__class__, ex,
+                        ),
+                    )
+                if result:
+                    self.tx_inc()
+        else:
+            LOG.warning(f"{self.__class__} plugin is not enabled")
 
-class APRSDCommandSpec:
-    """A hook specification namespace."""
+        return result
 
-    @hookspec
-    def run(self, fromcall, message, ack):
-        """My special little hook that you can customize."""
-        pass
 
+class APRSDRegexCommandPluginBase(APRSDPluginBase, metaclass=abc.ABCMeta):
+    """Base Message plugin class.
 
-@six.add_metaclass(abc.ABCMeta)
-class APRSDPluginBase(object):
-    def __init__(self, config):
-        """The aprsd config object is stored."""
-        self.config = config
+    When you want to search for a particular command in an
+    APRSD message and send a direct reply, write a plugin
+    based off of this class.
+    """
 
     @property
     def command_name(self):
@@ -155,196 +196,346 @@ class APRSDPluginBase(object):
         """The regex to match from the caller"""
         raise NotImplementedError
 
-    @property
-    def version(self):
-        """Version"""
-        raise NotImplementedError
-
-    @hookimpl
-    def run(self, fromcall, message, ack):
-        if re.search(self.command_regex, message):
-            return self.command(fromcall, message, ack)
+    def help(self):
+        return "{}: {}".format(
+            self.command_name.lower(),
+            self.command_regex,
+        )
 
-    @abc.abstractmethod
-    def command(self, fromcall, message, ack):
-        """This is the command that runs when the regex matches.
+    def setup(self):
+        """Do any plugin setup here."""
+        self.enabled = True
 
-        To reply with a message over the air, return a string
-        to send.
-        """
-        pass
+    @hookimpl
+    def filter(self, packet: packets.MessagePacket) -> str | packets.MessagePacket:
+        LOG.debug(f"{self.__class__.__name__} called")
+        if not self.enabled:
+            result = f"{self.__class__.__name__} isn't enabled"
+            LOG.warning(result)
+            return result
+
+        if not isinstance(packet, packets.MessagePacket):
+            LOG.warning(f"{self.__class__.__name__} Got a {packet.__class__.__name__} ignoring")
+            return packets.NULL_MESSAGE
+
+        result = None
+
+        message = packet.message_text
+        tocall = packet.to_call
+
+        # Only process messages destined for us
+        # and is an APRS message format and has a message.
+        if (
+            tocall == CONF.callsign
+            and isinstance(packet, packets.MessagePacket)
+            and message
+        ):
+            if re.search(self.command_regex, message, re.IGNORECASE):
+                self.rx_inc()
+                try:
+                    result = self.process(packet)
+                except Exception as ex:
+                    LOG.error(
+                        "Plugin {} failed to process packet {}".format(
+                            self.__class__, ex,
+                        ),
+                    )
+                    LOG.exception(ex)
+                if result:
+                    self.tx_inc()
 
+        return result
 
-class FortunePlugin(APRSDPluginBase):
-    """Fortune."""
 
-    version = "1.0"
-    command_regex = "^[fF]"
-    command_name = "fortune"
+class APRSFIKEYMixin:
+    """Mixin class to enable checking the existence of the aprs.fi apiKey."""
 
-    def command(self, fromcall, message, ack):
-        LOG.info("FortunePlugin")
-        reply = None
-        try:
-            process = subprocess.Popen(
-                ["/usr/games/fortune", "-s", "-n 60"], stdout=subprocess.PIPE
+    def ensure_aprs_fi_key(self):
+        if not CONF.aprs_fi.apiKey:
+            LOG.error("Config aprs_fi.apiKey is not set")
+            self.enabled = False
+        else:
+            self.enabled = True
+
+
+class HelpPlugin(APRSDRegexCommandPluginBase):
+    """Help Plugin that is always enabled.
+
+    This plugin is in this file to prevent a circular import.
+    """
+
+    command_regex = "^[hH]"
+    command_name = "help"
+
+    def help(self):
+        return "Help: send APRS help or help <plugin>"
+
+    def process(self, packet: packets.MessagePacket):
+        LOG.info("HelpPlugin")
+        # fromcall = packet.get("from")
+        message = packet.message_text
+        # ack = packet.get("msgNo", "0")
+        a = re.search(r"^.*\s+(.*)", message)
+        command_name = None
+        if a is not None:
+            command_name = a.group(1).lower()
+
+        pm = PluginManager()
+
+        if command_name and "?" not in command_name:
+            # user wants help for a specific plugin
+            reply = None
+            for p in pm.get_plugins():
+                if (
+                    p.enabled and isinstance(p, APRSDRegexCommandPluginBase)
+                    and p.command_name.lower() == command_name
+                ):
+                    reply = p.help()
+
+            if reply:
+                return reply
+
+        list = []
+        for p in pm.get_plugins():
+            LOG.debug(p)
+            if p.enabled and isinstance(p, APRSDRegexCommandPluginBase):
+                name = p.command_name.lower()
+                if name not in list and "help" not in name:
+                    list.append(name)
+
+        list.sort()
+        reply = " ".join(list)
+        lines = textwrap.wrap(reply, 60)
+        replies = ["Send APRS MSG of 'help' or 'help <plugin>'"]
+        for line in lines:
+            replies.append(f"plugins: {line}")
+
+        for entry in replies:
+            LOG.debug(f"{len(entry)} {entry}")
+
+        LOG.debug(f"{replies}")
+        return replies
+
+
+class PluginManager:
+    # The singleton instance object for this class
+    _instance = None
+
+    # the pluggy PluginManager for all Message plugins
+    _pluggy_pm = None
+    # the pluggy PluginManager for all WatchList plugins
+    _watchlist_pm = None
+
+    lock = None
+
+    def __new__(cls, *args, **kwargs):
+        """This magic turns this into a singleton."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            # Put any initialization here.
+            cls._instance.lock = threading.Lock()
+            cls._instance._init()
+        return cls._instance
+
+    def _init(self):
+        self._pluggy_pm = pluggy.PluginManager("aprsd")
+        self._pluggy_pm.add_hookspecs(APRSDPluginSpec)
+        # For the watchlist plugins
+        self._watchlist_pm = pluggy.PluginManager("aprsd")
+        self._watchlist_pm.add_hookspecs(APRSDPluginSpec)
+
+    def stats(self, serializable=False) -> dict:
+        """Collect and return stats for all plugins."""
+        def full_name_with_qualname(obj):
+            return "{}.{}".format(
+                obj.__class__.__module__,
+                obj.__class__.__qualname__,
             )
-            reply = process.communicate()[0]
-            # send_message(fromcall, reply.rstrip())
-            reply = reply.decode(errors="ignore").rstrip()
-        except Exception as ex:
-            reply = "Fortune command failed '{}'".format(ex)
-            LOG.error(reply)
 
-        return reply
+        plugin_stats = {}
+        plugins = self.get_plugins()
+        if plugins:
 
+            for p in plugins:
+                plugin_stats[full_name_with_qualname(p)] = {
+                    "enabled": p.enabled,
+                    "rx": p.rx_count,
+                    "tx": p.tx_count,
+                    "version": p.version,
+                }
 
-class LocationPlugin(APRSDPluginBase):
-    """Location!"""
+        return plugin_stats
 
-    version = "1.0"
-    command_regex = "^[lL]"
-    command_name = "location"
+    def is_plugin(self, obj):
+        for c in inspect.getmro(obj):
+            if issubclass(c, APRSDPluginBase):
+                return True
+
+        return False
 
-    def command(self, fromcall, message, ack):
-        LOG.info("Location Plugin")
-        # get last location of a callsign, get descriptive name from weather service
+    def _create_class(
+        self,
+        module_class_string,
+        super_cls: type = None,
+        **kwargs,
+    ):
+        """
+        Method to create a class from a fqn python string.
+        :param module_class_string: full name of the class to create an object
+        :param super_cls: expected super class for validity, None if bypass
+        :param kwargs: parameters to pass
+        :return:
+        """
+        module_name = None
+        class_name = None
         try:
-            a = re.search(
-                r"^.*\s+(.*)", message
-            )  # optional second argument is a callsign to search
-            if a is not None:
-                searchcall = a.group(1)
-                searchcall = searchcall.upper()
+            module_name, class_name = module_class_string.rsplit(".", 1)
+            module = importlib.import_module(module_name)
+            # Commented out because the email thread starts in a different context
+            # and hence gives a different singleton for the EmailStats
+            # module = importlib.reload(module)
+        except Exception as ex:
+            if not module_name:
+                LOG.error(f"Failed to load Plugin {module_class_string}")
             else:
-                searchcall = (
-                    fromcall  # if no second argument, search for calling station
-                )
-            url = (
-                "http://api.aprs.fi/api/get?name="
-                + searchcall
-                + "&what=loc&apikey=104070.f9lE8qg34L8MZF&format=json"
-            )
-            response = requests.get(url)
-            # aprs_data = json.loads(response.read())
-            aprs_data = json.loads(response.text)
-            lat = aprs_data["entries"][0]["lat"]
-            lon = aprs_data["entries"][0]["lng"]
-            try:  # altitude not always provided
-                alt = aprs_data["entries"][0]["altitude"]
-            except Exception:
-                alt = 0
-            altfeet = int(alt * 3.28084)
-            aprs_lasttime_seconds = aprs_data["entries"][0]["lasttime"]
-            aprs_lasttime_seconds = aprs_lasttime_seconds.encode(
-                "ascii", errors="ignore"
-            )  # unicode to ascii
-            delta_seconds = time.time() - int(aprs_lasttime_seconds)
-            delta_hours = delta_seconds / 60 / 60
-            url2 = (
-                "https://forecast.weather.gov/MapClick.php?lat="
-                + str(lat)
-                + "&lon="
-                + str(lon)
-                + "&FcstType=json"
-            )
-            response2 = requests.get(url2)
-            wx_data = json.loads(response2.text)
-
-            reply = "{}: {} {}' {},{} {}h ago".format(
-                searchcall,
-                wx_data["location"]["areaDescription"],
-                str(altfeet),
-                str(alt),
-                str(lon),
-                str("%.1f" % round(delta_hours, 1)),
-            ).rstrip()
-        except Exception as e:
-            LOG.debug("Locate failed with:  " + "%s" % str(e))
-            reply = "Unable to find station " + searchcall + ".  Sending beacons?"
-
-        return reply
-
-
-class PingPlugin(APRSDPluginBase):
-    """Ping."""
-
-    version = "1.0"
-    command_regex = "^[pP]"
-    command_name = "ping"
-
-    def command(self, fromcall, message, ack):
-        LOG.info("PINGPlugin")
-        stm = time.localtime()
-        h = stm.tm_hour
-        m = stm.tm_min
-        s = stm.tm_sec
-        reply = (
-            "Pong! " + str(h).zfill(2) + ":" + str(m).zfill(2) + ":" + str(s).zfill(2)
-        )
-        return reply.rstrip()
+                LOG.error(f"Failed to load Plugin '{module_name}' : '{ex}'")
+            return
 
-
-class TimePlugin(APRSDPluginBase):
-    """Time command."""
-
-    version = "1.0"
-    command_regex = "^[tT]"
-    command_name = "time"
-
-    def command(self, fromcall, message, ack):
-        LOG.info("TIME COMMAND")
-        stm = time.localtime()
-        h = stm.tm_hour
-        m = stm.tm_min
-        cur_time = fuzzy(h, m, 1)
-        reply = "{} ({}:{} PDT) ({})".format(
-            cur_time, str(h), str(m).rjust(2, "0"), message.rstrip()
+        assert hasattr(module, class_name), "class {} is not in {}".format(
+            class_name,
+            module_name,
         )
-        return reply
+        # click.echo('reading class {} from module {}'.format(
+        #     class_name, module_name))
+        cls = getattr(module, class_name)
+        if super_cls is not None:
+            assert issubclass(cls, super_cls), "class {} should inherit from {}".format(
+                class_name,
+                super_cls.__name__,
+            )
+        # click.echo('initialising {} with params {}'.format(class_name, kwargs))
+        obj = cls(**kwargs)
+        return obj
 
+    def _load_plugin(self, plugin_name):
+        """
+        Given a python fully qualified class path.name,
+        Try importing the path, then creating the object,
+        then registering it as a aprsd Command Plugin
+        """
+        plugin_obj = None
+        try:
+            plugin_obj = self._create_class(
+                plugin_name,
+                APRSDPluginBase,
+            )
+            if plugin_obj:
+                if isinstance(plugin_obj, APRSDWatchListPluginBase):
+                    if plugin_obj.enabled:
+                        LOG.info(
+                            "Registering WatchList plugin '{}'({})".format(
+                                plugin_name,
+                                plugin_obj.version,
+                            ),
+                        )
+                        self._watchlist_pm.register(plugin_obj)
+                    else:
+                        LOG.warning(f"Plugin {plugin_obj.__class__.__name__} is disabled")
+                elif isinstance(plugin_obj, APRSDRegexCommandPluginBase):
+                    if plugin_obj.enabled:
+                        LOG.info(
+                            "Registering Regex plugin '{}'({}) -- {}".format(
+                                plugin_name,
+                                plugin_obj.version,
+                                plugin_obj.command_regex,
+                            ),
+                        )
+                        self._pluggy_pm.register(plugin_obj)
+                    else:
+                        LOG.warning(f"Plugin {plugin_obj.__class__.__name__} is disabled")
+                elif isinstance(plugin_obj, APRSDPluginBase):
+                    if plugin_obj.enabled:
+                        LOG.info(
+                            "Registering Base plugin '{}'({})".format(
+                                plugin_name,
+                                plugin_obj.version,
+                            ),
+                        )
+                        self._pluggy_pm.register(plugin_obj)
+                    else:
+                        LOG.warning(f"Plugin {plugin_obj.__class__.__name__} is disabled")
+        except Exception as ex:
+            LOG.error(f"Couldn't load plugin '{plugin_name}'")
+            LOG.exception(ex)
 
-class WeatherPlugin(APRSDPluginBase):
-    """Weather Command"""
+    def reload_plugins(self):
+        with self.lock:
+            del self._pluggy_pm
+            self.setup_plugins()
 
-    version = "1.0"
-    command_regex = "^[wW]"
-    command_name = "weather"
+    def setup_plugins(self, load_help_plugin=True):
+        """Create the plugin manager and register plugins."""
 
-    def command(self, fromcall, message, ack):
-        LOG.info("Weather Plugin")
-        try:
-            url = (
-                "http://api.aprs.fi/api/get?"
-                "&what=loc&apikey=104070.f9lE8qg34L8MZF&format=json"
-                "&name=%s" % fromcall
-            )
-            response = requests.get(url)
-            # aprs_data = json.loads(response.read())
-            aprs_data = json.loads(response.text)
-            lat = aprs_data["entries"][0]["lat"]
-            lon = aprs_data["entries"][0]["lng"]
-            url2 = (
-                "https://forecast.weather.gov/MapClick.php?lat=%s"
-                "&lon=%s&FcstType=json" % (lat, lon)
-            )
-            response2 = requests.get(url2)
-            # wx_data = json.loads(response2.read())
-            wx_data = json.loads(response2.text)
-            reply = (
-                "%sF(%sF/%sF) %s. %s, %s."
-                % (
-                    wx_data["currentobservation"]["Temp"],
-                    wx_data["data"]["temperature"][0],
-                    wx_data["data"]["temperature"][1],
-                    wx_data["data"]["weather"][0],
-                    wx_data["time"]["startPeriodName"][1],
-                    wx_data["data"]["weather"][1],
-                ).rstrip()
-            )
-            LOG.debug("reply: '{}' ".format(reply))
-        except Exception as e:
-            LOG.debug("Weather failed with:  " + "%s" % str(e))
-            reply = "Unable to find you (send beacon?)"
+        LOG.info("Loading APRSD Plugins")
+        # Help plugin is always enabled.
+        if load_help_plugin:
+            _help = HelpPlugin()
+            self._pluggy_pm.register(_help)
 
-        return reply
+        enabled_plugins = CONF.enabled_plugins
+        if enabled_plugins:
+            for p_name in enabled_plugins:
+                self._load_plugin(p_name)
+        else:
+            # Enabled plugins isn't set, so we default to loading all of
+            # the core plugins.
+            for p_name in CORE_MESSAGE_PLUGINS:
+                self._load_plugin(p_name)
+
+        LOG.info("Completed Plugin Loading.")
+
+    def run(self, packet: packets.MessagePacket):
+        """Execute all the plugins run method."""
+        with self.lock:
+            return self._pluggy_pm.hook.filter(packet=packet)
+
+    def run_watchlist(self, packet: packets.Packet):
+        with self.lock:
+            return self._watchlist_pm.hook.filter(packet=packet)
+
+    def stop(self):
+        """Stop all threads created by all plugins."""
+        with self.lock:
+            for p in self.get_plugins():
+                if hasattr(p, "stop_threads"):
+                    p.stop_threads()
+
+    def register_msg(self, obj):
+        """Register the plugin."""
+        with self.lock:
+            self._pluggy_pm.register(obj)
+
+    def get_plugins(self):
+        plugin_list = []
+        if self._pluggy_pm:
+            for plug in self._pluggy_pm.get_plugins():
+                plugin_list.append(plug)
+        if self._watchlist_pm:
+            for plug in self._watchlist_pm.get_plugins():
+                plugin_list.append(plug)
+
+        return plugin_list
+
+    def get_watchlist_plugins(self):
+        pl = []
+        if self._watchlist_pm:
+            for plug in self._watchlist_pm.get_plugins():
+                pl.append(plug)
+        return pl
+
+    def get_message_plugins(self):
+        pl = []
+        if self._pluggy_pm:
+            for plug in self._pluggy_pm.get_plugins():
+                pl.append(plug)
+        return pl