fprime-gds 3.4.2__py3-none-any.whl → 3.4.4a1__py3-none-any.whl

fprime_gds/executables/apps.py

@@ -0,0 +1,150 @@
+""" fprime_gds.executables.apps: an implementation of start-up apps in fprime
+
+There are twp ways to approach start=up applications in fprime. First, is to implement a run method via a subclass of
+`GdsFunction`. This gives the implementor the ability to run anything within the run function that python offers,
+however; this comes with complexity of setting up a new thread/process/isolation to ensure that the plugin does not
+threaten the fprime-gds core functionality and processes.
+
+The second method is to inherit from `GdsApp` implementing the `get_process_invocation` function to return the necessary
+command line that will be spun into its own process.
+
+@author lestarch
+"""
+import subprocess
+from abc import ABC, abstractmethod
+from typing import List, Type
+
+from fprime_gds.plugin.definitions import gds_plugin_specification
+
+
+class GdsBaseFunction(ABC):
+    """ Base functionality for pluggable GDS start-up functions
+
+    GDS start-up functionality is pluggable. This class acts as a base for pluggable functionality supplies helpers to
+    the various start-up plugins.
+
+    Developers who intend to run in an isolated subprocess are strongly encouraged to use `GdsApp` (see below).
+    Developers who need flexibility may use GdsFunction.
+    """
+
+    @abstractmethod
+    def run(self):
+        """ Run the start-up function
+
+        Run the start-up function unconstrained by the limitations of running in a dedicated subprocess.
+
+        """
+        raise NotImplementedError()
+
+
+class GdsFunction(GdsBaseFunction, ABC):
+    """ Functionality for pluggable GDS start-up functions
+
+    GDS start-up functionality is pluggable. This class acts as a wide-open implementation of functionality via a single
+    `run` callback. Developers have complete control of the start-up functionality. However, this comes at the cost of
+    instability in that case of poorly designed functions.
+
+    Developers who intend to run in an isolated subprocess are strongly encouraged to use `GdsApp` (see below).
+
+    Plugin developers are required to implement a single function `run`, which must take care of setting up and running
+    the start-up function. Developers **must** handle the isolation of this functionality including spinning off a new
+    thread, subprocess, etc. Additionally, the developer must define the `register_gds_function_plugin` class method
+    annotated with the @gds_plugin_implementation annotation.
+
+    Standard plug-in functions (get_name, get_arguments) are available should the implementer desire these features.
+    Arguments will be supplied to the class's `__init__` function.
+    """
+
+    @classmethod
+    @gds_plugin_specification
+    def register_gds_function_plugin(cls) -> Type["GdsFunction"]:
+        """Register gds start-up functionality
+
+        Plugin hook for registering a plugin that supplies start-up functionality. This functionality will run on start-up
+        of the GDS network.
+
+        Note: users should return the class, not an instance of the class. Needed arguments for instantiation are
+        determined from class methods, solicited via the command line, and provided at construction time to the chosen
+        instantiation.
+
+        Returns:
+            GDSFunction subclass
+        """
+        raise NotImplementedError()
+
+
+class GdsApp(GdsBaseFunction):
+    """ GDS start-up process functionality
+
+    A pluggable base class used to start a new process as part of the GDS command line invocation. This allows
+    developers to add process-isolated functionality to the GDS network.
+
+    Plugin developers are required to implement the `get_process_invocation` function that returns a list of arguments
+    needed to invoke the process via python's `subprocess`. Additionally, the developer must define the
+    `register_gds_function_plugin` class method annotated with the @gds_plugin_implementation annotation.
+
+    Standard plug-in functions (get_name, get_arguments) are available should the implementer desire these features.
+    Arguments will be supplied to the class's `__init__` function.
+    """
+    def __init__(self, **arguments):
+        """ Construct the communication applications around the arguments
+
+        Command line arguments are passed in to match those returned from the `get_arguments` functions.
+
+        Args:
+            arguments: arguments from the command line
+        """
+        self.process = None
+        self.arguments = arguments
+
+    def run(self):
+        """ Run the application as an isolated process
+
+        GdsFunction objects require an implementation of the `run` command. This implementation will take the arguments
+        provided from `get_process_invocation` function and supplies them as an invocation of the isolated subprocess.
+        """
+        invocation_arguments = self.get_process_invocation()
+        self.process = subprocess.Popen(invocation_arguments)
+
+    def wait(self, timeout=None):
+        """ Wait for the app to complete then return the return code
+
+        Waits (blocking) for the process to complete. Then returns the return code of the underlying process. If timeout
+        is non-None then the process will be killed after waiting for the timeout and another wait of timeout will be
+        allowed for the killed process to exit.
+
+        Return:
+            return code of the underlying process
+        """
+        try:
+            _, _ = self.process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            self.process.kill()
+            _, _ = self.process.wait(timeout=timeout)
+        return self.process.returncode
+
+    @abstractmethod
+    def get_process_invocation(self) -> List[str]:
+        """ Run the start-up function
+
+        Run the start-up function unconstrained by the limitations of running in a dedicated subprocess.
+
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    @gds_plugin_specification
+    def register_gds_app_plugin(cls) -> Type["GdsApp"]:
+        """Register a gds start-up application
+
+        Plugin hook for registering a plugin that supplies start-up functionality. This functionality will run on start-up
+        of the GDS network isolated into a dedicated process.
+
+        Note: users should return the class, not an instance of the class. Needed arguments for instantiation are
+        determined from class methods, solicited via the command line, and provided at construction time to the chosen
+        instantiation.
+
+        Returns:
+            GdsApp subclass
+        """
+        raise NotImplementedError()

fprime_gds/executables/cli.py

@@ -7,6 +7,7 @@ code that they are importing.
 
 @author mstarch
 """
+
 import argparse
 import datetime
 import errno
@@ -23,12 +24,13 @@ from typing import Any, Dict, List, Tuple
 # Required to set the checksum as a module variable
 import fprime_gds.common.communication.checksum
 import fprime_gds.common.logger
-from fprime_gds.common.communication.adapters.base import BaseAdapter
 from fprime_gds.common.communication.adapters.ip import check_port
 from fprime_gds.common.pipeline.standard import StandardPipeline
 from fprime_gds.common.transport import ThreadedTCPSocketClient
 from fprime_gds.common.utils.config_manager import ConfigManager
 from fprime_gds.executables.utils import find_app, find_dict, get_artifacts_root
+from fprime_gds.plugin.definitions import PluginType
+from fprime_gds.plugin.system import Plugins
 
 # Optional import: ZeroMQ. Requires package: pyzmq
 try:
@@ -45,7 +47,6 @@ try:
 except ImportError:
     SerialAdapter = None
 
-
 GUIS = ["none", "html"]
 
 
@@ -85,11 +86,31 @@ class ParserBase(ABC):
         Return:
             argparse parser for supplied arguments
         """
-        parser = argparse.ArgumentParser(description=self.description, add_help=True)
-        for flags, keywords in self.get_arguments().items():
-            parser.add_argument(*flags, **keywords)
+        parser = argparse.ArgumentParser(
+            description=self.description,
+            add_help=True,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        )
+        self.fill_parser(parser)
         return parser
 
+    def fill_parser(self, parser):
+        """ Fill supplied parser with arguments
+
+        Fills the supplied parser with the arguments returned via the `get_arguments` method invocation. This
+        implementation add the arguments directly to the parser.
+
+        Args:
+            parser: parser to fill with arguments
+
+        """
+        for flags, keywords in self.get_arguments().items():
+            try:
+                parser.add_argument(*flags, **keywords)
+            except argparse.ArgumentError:
+                # flag has already been added, pass
+                pass
+
     def reproduce_cli_args(self, args_ns):
         """Reproduce the list of arguments needed on the command line"""
 
@@ -176,6 +197,7 @@ class ParserBase(ABC):
             sys.exit(-1)
         except Exception as exc:
             print(f"[ERROR] {exc}", file=sys.stderr)
+            raise
             sys.exit(-1)
         return args_ns, parser
 
@@ -245,6 +267,162 @@ class DetectionParser(ParserBase):
         return args
 
 
+class PluginArgumentParser(ParserBase):
+    """Parser for arguments coming from plugins"""
+
+    DESCRIPTION = "Plugin options"
+    FPRIME_CHOICES = {
+        "framing": "fprime",
+        "communication": "ip",
+    }
+
+    def __init__(self):
+        """Initialize the plugin information for this parser"""
+        self._plugin_map = {
+            category: Plugins.system().get_plugins(category)
+            for category in Plugins.system().get_categories()
+        }
+
+    @staticmethod
+    def safe_add_argument(parser, *flags, **keywords):
+        """ Add an argument allowing duplicates
+
+        Add arguments to the parser (passes through *flags and **keywords) to the supplied parser. This method traps
+        errors to prevent duplicates.
+
+        Args:
+            parser: parser or argument group to add arguments to
+            *flags: positional arguments passed to `add_argument`
+            **keywords: key word arguments passed to `add_argument`
+        """
+        try:
+            parser.add_argument(*flags, **keywords)
+        except argparse.ArgumentError:
+            # flag has already been added, pass
+            pass
+
+    def fill_parser(self, parser):
+        """ File supplied parser with grouped arguments
+
+        Fill the supplied parser with arguments from the `get_arguments` method invocation. This implementation groups
+        arguments based on the constituent that sources the argument.
+
+        Args:
+            parser: parser to fill
+        """
+        for category, plugins in self._plugin_map.items():
+            argument_group = parser.add_argument_group(title=f"{category.title()} Plugin Options")
+            for flags, keywords in self.get_category_arguments(category).items():
+                self.safe_add_argument(argument_group, *flags, **keywords)
+
+            for plugin in plugins:
+                argument_group = parser.add_argument_group(title=f"{category.title()} Plugin '{plugin.get_name()}' Options")
+                if plugin.type == PluginType.FEATURE:
+                    self.safe_add_argument(argument_group,
+                                           f"--disable-{plugin.get_name()}",
+                                           action="store_true",
+                                           default=False,
+                                           help=f"Disable the {category} plugin '{plugin.get_name()}'")
+                for flags, keywords in plugin.get_arguments().items():
+                    self.safe_add_argument(argument_group, *flags, **keywords)
+
+    def get_category_arguments(self, category):
+        """ Get arguments for a plugin category """
+        arguments: Dict[Tuple[str, ...], Dict[str, Any]] = {}
+        plugins = self._plugin_map[category]
+        # Add category options: SELECTION plugins add a selection flag
+        plugin_type = Plugins.get_category_plugin_type(category)
+        if plugin_type == PluginType.SELECTION:
+            arguments.update(
+                {
+                    (f"--{category}-selection",): {
+                        "choices": [choice.get_name() for choice in plugins],
+                        "help": f"Select {category} implementer.",
+                        "default": self.FPRIME_CHOICES.get(
+                            category, list(plugins)[0].get_name()
+                        ),
+                    }
+                }
+            )
+        return arguments
+
+    def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
+        """Return arguments to used in plugins"""
+        arguments: Dict[Tuple[str, ...], Dict[str, Any]] = {}
+        for category, plugins in self._plugin_map.items():
+            arguments.update(self.get_category_arguments(category))
+            for plugin in plugins:
+                # Add disable flags for feature type plugins
+                if plugin.type == PluginType.FEATURE:
+                    arguments.update({
+                        (f"--disable-{plugin.get_name()}", ): {
+                            "action": "store_true",
+                            "default": False,
+                            "help": f"Disable the {category} plugin '{plugin.get_name()}'"
+                        }
+                    })
+                arguments.update(plugin.get_arguments())
+        return arguments
+
+    def handle_arguments(self, args, **kwargs):
+        """Handles the arguments"""
+        for category, plugins in self._plugin_map.items():
+            plugin_type = Plugins.get_category_plugin_type(category)
+
+            # Selection plugins choose one plugin and instantiate it
+            if plugin_type == PluginType.SELECTION:
+                selection_string = getattr(args, f"{category}_selection")
+                matching_plugins = [plugin for plugin in plugins if plugin.get_name() == selection_string]
+                assert len(matching_plugins) == 1, "Plugin selection system failed"
+                selection_class = matching_plugins[0].plugin_class
+                filled_arguments = self.extract_plugin_arguments(args, selection_class)
+                selection_instance = selection_class(**filled_arguments)
+                setattr(args, f"{category}_selection_instance", selection_instance)
+            # Feature plugins instantiate all enabled plugins
+            elif plugin_type == PluginType.FEATURE:
+                enabled_plugins = [
+                    plugin for plugin in plugins
+                    if not getattr(args, f"disable_{plugin.get_name().replace('-', '_')}", False)
+                ]
+                plugin_instantiations = [
+                    plugin.plugin_class(**self.extract_plugin_arguments(args, plugin))
+                    for plugin in enabled_plugins
+                ]
+                setattr(args, f"{category}_enabled_instances", plugin_instantiations)
+        return args
+
+    @staticmethod
+    def extract_plugin_arguments(args, plugin) -> Dict[str, Any]:
+        """Extract plugin argument values from the args namespace into a map
+
+        Plugin arguments will be supplied to the `__init__` function of the plugin via a keyword argument dictionary.
+        This function maps from the argument namespace from parsing back into that dictionary.
+
+        Args:
+            args: argument namespace from argparse
+            plugin: plugin to extract arguments for
+        Return:
+            filled arguments dictionary
+        """
+        expected_args = plugin.get_arguments()
+        argument_destinations = [
+            (
+                value["dest"]
+                if "dest" in value
+                else key[0].replace("--", "").replace("-", "_")
+            )
+            for key, value in expected_args.items()
+        ]
+        filled_arguments = {
+            destination: getattr(args, destination)
+            for destination in argument_destinations
+        }
+        # Check arguments or yield a Value error
+        if hasattr(plugin, "check_arguments"):
+            plugin.check_arguments(**filled_arguments)
+        return filled_arguments
+
+
 class CompositeParser(ParserBase):
     """Composite parser handles parsing as a composition of multiple other parsers"""
 
@@ -258,6 +436,22 @@ class CompositeParser(ParserBase):
         ]
         self.constituent_parsers = {*itertools.chain.from_iterable(flattened)}
 
+    def fill_parser(self, parser):
+        """ File supplied parser with grouped arguments
+
+        Fill the supplied parser with arguments from the `get_arguments` method invocation. This implementation groups
+        arguments based on the constituent that sources the argument.
+
+        Args:
+            parser: parser to fill
+        """
+        for constituent in sorted(self.constituents, key=lambda x: x.description):
+            if isinstance(constituent, (PluginArgumentParser, CompositeParser)):
+                constituent.fill_parser(parser)
+            else:
+                argument_group = parser.add_argument_group(title=constituent.description)
+                constituent.fill_parser(argument_group)
+
     @property
     def constituents(self):
         """Get constituent"""
@@ -286,49 +480,14 @@ class CompositeParser(ParserBase):
         return args
 
 
-class CommAdapterParser(ParserBase):
-    """
-    Handles parsing of all of the comm-layer arguments. This means selecting a comm adapter, and passing the arguments
-    required to setup that comm adapter. In addition, this parser uses the import parser to import modules such that a
-    user may import other adapter implementation files.
-    """
+class CommExtraParser(ParserBase):
+    """Parses extra communication arguments"""
 
-    DESCRIPTION = "Process arguments needed to specify a comm-adapter"
+    DESCRIPTION = "Communications options"
 
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Get arguments for the comm-layer parser"""
-        adapter_definition_dictionaries = BaseAdapter.get_adapters()
-        adapter_arguments = {}
-        for name, adapter in adapter_definition_dictionaries.items():
-            adapter_arguments_callable = getattr(adapter, "get_arguments", None)
-            if not callable(adapter_arguments_callable):
-                print(
-                    f"[WARNING] '{name}' does not have 'get_arguments' method, skipping.",
-                    file=sys.stderr,
-                )
-                continue
-            adapter_arguments.update(adapter.get_arguments())
         com_arguments = {
-            ("--comm-adapter",): {
-                "dest": "adapter",
-                "action": "store",
-                "type": str,
-                "help": "Adapter for communicating to flight deployment. [default: %(default)s]",
-                "choices": ["none"] + list(adapter_definition_dictionaries),
-                "default": "ip",
-            },
-            ("--comm-checksum-type",): {
-                "dest": "checksum_type",
-                "action": "store",
-                "type": str,
-                "help": "Setup the checksum algorithm. [default: %(default)s]",
-                "choices": [
-                    item
-                    for item in fprime_gds.common.communication.checksum.CHECKSUM_MAPPING.keys()
-                    if item != "default"
-                ],
-                "default": fprime_gds.common.communication.checksum.CHECKSUM_SELECTION,
-            },
             ("--output-unframed-data",): {
                 "dest": "output_unframed_data",
                 "action": "store",
@@ -339,17 +498,9 @@ class CommAdapterParser(ParserBase):
                 "required": False,
             },
         }
-        return {**adapter_arguments, **com_arguments}
+        return com_arguments
 
     def handle_arguments(self, args, **kwargs):
-        """
-        Handle the input arguments for the parser. This will help setup the adapter with its expected arguments.
-
-        :param args: parsed arguments in namespace format
-        :return: namespace with "comm_adapter" value added
-        """
-        args.comm_adapter = BaseAdapter.construct_adapter(args.adapter, args)
-        fprime_gds.common.communication.checksum.CHECKSUM_SELECTION = args.checksum_type
         return args
 
 
@@ -360,7 +511,7 @@ class LogDeployParser(ParserBase):
     to end up in the proper place.
     """
 
-    DESCRIPTION = "Process arguments needed to specify a logging"
+    DESCRIPTION = "Logging options"
 
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Return arguments to parse logging options"""
@@ -423,7 +574,7 @@ class MiddleWareParser(ParserBase):
     however; it should be close enough.
     """
 
-    DESCRIPTION = "Process arguments needed to specify a tool using the middleware"
+    DESCRIPTION = "Middleware options"
 
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Return arguments necessary to run a and connect to the GDS middleware"""
@@ -437,12 +588,6 @@ class MiddleWareParser(ParserBase):
                     "help": "Switch to using the ZMQ transportation layer",
                     "default": False,
                 },
-                ("--zmq-server",): {
-                    "dest": "zmq_server",
-                    "action": "store_true",
-                    "help": "Sets the ZMQ connection to be a server. Default: false (client)",
-                    "default": False,
-                },
                 ("--zmq-transport",): {
                     "dest": "zmq_transport",
                     "nargs": 2,
@@ -501,6 +646,8 @@ class MiddleWareParser(ParserBase):
 class DictionaryParser(DetectionParser):
     """Parser for deployments"""
 
+    DESCRIPTION = "Dictionary options"
+
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Arguments to handle deployments"""
         return {
@@ -540,6 +687,8 @@ class DictionaryParser(DetectionParser):
 class FileHandlingParser(ParserBase):
     """Parser for deployments"""
 
+    DESCRIPTION = "File handling options"
+
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Arguments to handle deployments"""
 
@@ -618,7 +767,12 @@ class StandardPipelineParser(CompositeParser):
 class CommParser(CompositeParser):
     """Comm Executable Parser"""
 
-    CONSTITUENTS = [CommAdapterParser, MiddleWareParser, LogDeployParser]
+    CONSTITUENTS = [
+        CommExtraParser,
+        MiddleWareParser,
+        LogDeployParser,
+        PluginArgumentParser,
+    ]
 
     def __init__(self):
         """Initialization"""
@@ -639,7 +793,7 @@ class GdsParser(ParserBase):
     Note: deployment can help in setting both dictionary and logs, but isn't strictly required.
     """
 
-    DESCRIPTION = "Process arguments needed to specify a tool using the GDS"
+    DESCRIPTION = "GUI options"
 
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Return arguments necessary to run a binary deployment via the GDS"""
@@ -686,7 +840,7 @@ class BinaryDeployment(DetectionParser):
     and represents the flight-side of the equation.
     """
 
-    DESCRIPTION = "Process arguments needed for running F prime binary"
+    DESCRIPTION = "FPrime binary options"
 
     def get_arguments(self) -> Dict[Tuple[str, ...], Dict[str, Any]]:
         """Return arguments necessary to run a binary deployment via the GDS"""
@@ -732,7 +886,7 @@ class SearchArgumentsParser(ParserBase):
     """Parser for search arguments"""
 
     DESCRIPTION = (
-        "Process arguments relevant to searching/filtering Channels/Events/Commands"
+        "Searching and filtering options"
     )
 
     def __init__(self, command_name: str) -> None:
@@ -778,7 +932,7 @@ class SearchArgumentsParser(ParserBase):
 class RetrievalArgumentsParser(ParserBase):
     """Parser for retrieval arguments"""
 
-    DESCRIPTION = "Process arguments relevant to retrieving Channels/Events"
+    DESCRIPTION = "Data retrieval options"
 
     def __init__(self, command_name: str) -> None:
         self.command_name = command_name

fprime_gds/executables/comm.py

@@ -16,7 +16,6 @@ Note: assuming the module containing the ground adapter has been imported, then
 @author lestarch
 """
 
-
 import logging
 import signal
 import sys
@@ -30,11 +29,9 @@ except ImportError:
     ZmqGround = None
 import fprime_gds.common.communication.adapters.base
 import fprime_gds.common.communication.adapters.ip
-import fprime_gds.common.communication.checksum
 import fprime_gds.common.communication.ground
 import fprime_gds.common.logger
 import fprime_gds.executables.cli
-from fprime_gds.common.communication.framing import FpFramerDeframer
 from fprime_gds.common.communication.updown import Downlinker, Uplinker
 
 # Uses non-standard PIP package pyserial, so test the waters before getting a hard-import crash
@@ -58,13 +55,16 @@ def main():
             fprime_gds.executables.cli.LogDeployParser,
             fprime_gds.executables.cli.MiddleWareParser,
             fprime_gds.executables.cli.CommParser,
+            fprime_gds.executables.cli.PluginArgumentParser,
         ],
         description="F prime communications layer.",
         client=True,
     )
-    fprime_gds.common.communication.checksum = args.checksum_type
-    if args.comm_adapter == "none":
-        print("[ERROR] Comm adapter set to 'none'. Nothing to do but exit.", file=sys.stderr)
+    if args.communication_selection == "none":
+        print(
+            "[ERROR] Comm adapter set to 'none'. Nothing to do but exit.",
+            file=sys.stderr,
+        )
         sys.exit(-1)
 
     # Create the handling components for either side of this script, adapter for hardware, and ground for the GDS side
@@ -73,23 +73,20 @@ def main():
         sys.exit(-1)
     elif args.zmq:
         ground = fprime_gds.common.zmq_transport.ZmqGround(args.zmq_transport)
-        # Check for need to make this a server
-        if args.zmq_server:
-            ground.make_server()
     else:
         ground = fprime_gds.common.communication.ground.TCPGround(
             args.tts_addr, args.tts_port
         )
 
-    adapter = args.comm_adapter
+    adapter = args.communication_selection_instance
 
     # Set the framing class used and pass it to the uplink and downlink component constructions giving each a separate
     # instantiation
-    framer_class = FpFramerDeframer
+    framer_instance = args.framing_selection_instance
     LOGGER.info(
         "Starting uplinker/downlinker connecting to FSW using %s with %s",
-        adapter,
-        framer_class.__name__,
+        args.communication_selection,
+        args.framing_selection,
     )
     discarded_file_handle = None
     try:
@@ -108,9 +105,9 @@ def main():
                     discarded_file_handle_path,
                 )
         downlinker = Downlinker(
-            adapter, ground, framer_class(), discarded=discarded_file_handle
+            adapter, ground, framer_instance, discarded=discarded_file_handle
         )
-        uplinker = Uplinker(adapter, ground, framer_class(), downlinker)
+        uplinker = Uplinker(adapter, ground, framer_instance, downlinker)
 
         # Open resources for the handlers on either side, this prepares the resources needed for reading/writing data
         ground.open()
@@ -121,8 +118,8 @@ def main():
         uplinker.start()
         LOGGER.debug("Uplinker and downlinker running")
 
-        # Wait for shutdown event in the form of a KeyboardInterrupt then stop the processing, close resources, and wait for
-        # everything to terminate as expected.
+        # Wait for shutdown event in the form of a KeyboardInterrupt then stop the processing, close resources,
+        # and wait for everything to terminate as expected.
         def shutdown(*_):
             """Shutdown function for signals"""
             uplinker.stop()