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

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()

fprime_gds/executables/run_deployment.py

@@ -13,6 +13,7 @@ from fprime_gds.executables.cli import (
     GdsParser,
     ParserBase,
     StandardPipelineParser,
+    PluginArgumentParser,
 )
 from fprime_gds.executables.utils import AppWrapperException, run_wrapped_application
 
@@ -20,14 +21,20 @@ BASE_MODULE_ARGUMENTS = [sys.executable, "-u", "-m"]
 
 
 def parse_args():
-    """ Parse command line arguments
+    """Parse command line arguments
     Gets an argument parsers to read the command line and process the arguments. Return
     the arguments in their namespace.
 
     :return: parsed argument namespace
     """
     # Get custom handlers for all executables we are running
-    arg_handlers = [StandardPipelineParser, GdsParser, BinaryDeployment, CommParser]
+    arg_handlers = [
+        StandardPipelineParser,
+        GdsParser,
+        BinaryDeployment,
+        CommParser,
+        PluginArgumentParser,
+    ]
     # Parse the arguments, and refine through all handlers
     args, parser = ParserBase.parse_args(arg_handlers, "Run F prime deployment and GDS")
     return args
@@ -63,7 +70,7 @@ def launch_process(cmd, logfile=None, name=None, env=None, launch_time=5):
 
 
 def launch_tts(parsed_args):
-    """ Launch the ThreadedTcpServer middleware application
+    """Launch the ThreadedTcpServer middleware application
 
 
     Args:
@@ -85,7 +92,7 @@ def launch_tts(parsed_args):
 
 
 def launch_html(parsed_args):
-    """ Launch the Flask application
+    """Launch the Flask application
 
     Args:
         parsed_args: parsed argument namespace
@@ -112,14 +119,18 @@ def launch_html(parsed_args):
         str(parsed_args.gui_port),
     ]
     ret = launch_process(gse_args, name="HTML GUI", env=flask_env, launch_time=2)
+    ui_url = f"http://{str(parsed_args.gui_addr)}:{str(parsed_args.gui_port)}/"
+    print(f"[INFO] Launched UI at: {ui_url}")
     webbrowser.open(
-        f"http://{str(parsed_args.gui_addr)}:{str(parsed_args.gui_port)}/", new=0, autoraise=True
+        ui_url,
+        new=0,
+        autoraise=True,
     )
     return ret
 
 
 def launch_app(parsed_args):
-    """ Launch the raw application
+    """Launch the raw application
 
     Args:
         parsed_args: parsed argument namespace
@@ -128,14 +139,20 @@ def launch_app(parsed_args):
     """
     app_path = parsed_args.app
     logfile = os.path.join(parsed_args.logs, f"{app_path.name}.log")
-    app_cmd = [app_path.absolute(), "-p", str(parsed_args.port), "-a", parsed_args.address]
+    app_cmd = [
+        app_path.absolute(),
+        "-p",
+        str(parsed_args.port),
+        "-a",
+        parsed_args.address,
+    ]
     return launch_process(
         app_cmd, name=f"{app_path.name} Application", logfile=logfile, launch_time=1
     )
 
 
 def launch_comm(parsed_args):
-    """ Launch the communication adapter process
+    """Launch the communication adapter process
 
     Args:
         parsed_args: parsed argument namespace
@@ -143,9 +160,27 @@ def launch_comm(parsed_args):
         launched process
     """
     arguments = CommParser().reproduce_cli_args(parsed_args)
-    arguments = arguments + ["--log-directly"] if "--log-directly" not in arguments else arguments
+    arguments = (
+        arguments + ["--log-directly"]
+        if "--log-directly" not in arguments
+        else arguments
+    )
     app_cmd = BASE_MODULE_ARGUMENTS + ["fprime_gds.executables.comm"] + arguments
-    return launch_process(app_cmd, name=f'comm[{parsed_args.adapter}] Application', launch_time=1)
+    return launch_process(
+        app_cmd,
+        name=f"comm[{parsed_args.communication_selection}] Application",
+        launch_time=1,
+    )
+
+
+def launch_plugin(plugin_class_instance):
+    """ Launch a plugin instance """
+    plugin_name = getattr(plugin_class_instance, "get_name", lambda: cls.__name__)()
+    return launch_process(
+        plugin_class_instance.get_process_invocation(),
+        name=f"{ plugin_name } Plugin App",
+        launch_time=1,
+    )
 
 
 def main():
@@ -155,20 +190,23 @@ def main():
     parsed_args = parse_args()
     launchers = []
 
-    # Launch a gui, if specified
+    # Launch middleware layer if not using ZMQ
     if not parsed_args.zmq:
         launchers.append(launch_tts)
 
     # Check if we are running with communications
-    if parsed_args.adapter != "none":
+    if parsed_args.communication_selection != "none":
         launchers.append(launch_comm)
 
     # Add app, if possible
     if parsed_args.app:
-        if parsed_args.adapter == "ip":
+        if parsed_args.communication_selection == "ip":
             launchers.append(launch_app)
         else:
-            print("[WARNING] App cannot be auto-launched without IP adapter", file=sys.stderr)
+            print(
+                "[WARNING] App cannot be auto-launched without IP adapter",
+                file=sys.stderr,
+            )
 
     # Launch the desired GUI package
     if parsed_args.gui == "html":
@@ -177,6 +215,9 @@ def main():
     # Launch launchers and wait for the last app to finish
     try:
         procs = [launcher(parsed_args) for launcher in launchers]
+        _ = [launch_plugin(cls) for cls in  parsed_args.gds_app_enabled_instances]
+        _ = [instance.run() for instance in parsed_args.gds_function_enabled_instances]
+
         print("[INFO] F prime is now running. CTRL-C to shutdown all components.")
         procs[-1].wait()
     except KeyboardInterrupt:

fprime_gds/executables/utils.py

@@ -118,7 +118,7 @@ def run_wrapped_application(arguments, logfile=None, env=None, launch_time=None)
         if launch_time is not None:
             time.sleep(launch_time)
             child.poll()
-            if child.returncode is not None:
+            if child.returncode is not None and child.returncode != 0:
                 raise ProcessNotStableException(
                     arguments[0], child.returncode, launch_time
                 )