fprime-gds 4.0.0a3__tar.gz → 4.0.0a5__tar.gz

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a3
+Version: 4.0.0a5
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: 

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/src/fprime_gds/common/communication/adapters/ip.py

@@ -50,13 +50,11 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
     both. This data is concatenated and returned up the stack for processing.
     """
 
-    # Interval to send a KEEPALIVE packet. None will turn off KEEPALIVE.
-    KEEPALIVE_INTERVAL = 0.500
     # Data to send out as part of the KEEPALIVE packet. Should not be null nor empty.
     KEEPALIVE_DATA = b"sitting well"
     MAXIMUM_DATA_SIZE = 4096
 
-    def __init__(self, address, port, server=True):
+    def __init__(self, address, port, server=True, keepalive_interval=0.5):
         """
         Initialize this adapter by creating a handler for UDP and TCP. A thread for the KEEPALIVE application packets
         will be created, if the interval is not none. Handlers are servers unless server=False.
@@ -64,7 +62,8 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         self.address = address
         self.port = port
         self.stop = False
-        self.keepalive = None
+        self.keepalive_thread = None
+        self.keepalive_interval = keepalive_interval
         self.tcp = TcpHandler(address, port, server=server)
         self.udp = UdpHandler(address, port, server=server)
         self.thtcp = None
@@ -91,11 +90,11 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
             self.thudp.daemon = True
             self.thudp.start()
             # Start up a keep-alive ping if desired. This will hit the TCP uplink, and die if the connection is down
-            if IpAdapter.KEEPALIVE_INTERVAL is not None:
-                self.keepalive = threading.Thread(
-                    target=self.th_alive, name="KeepCommAliveThread", args=[float(self.KEEPALIVE_INTERVAL)]
+            if self.keepalive_interval > 0.0:
+                self.keepalive_thread = threading.Thread(
+                    target=self.th_alive, name="KeepCommAliveThread", args=[self.keepalive_interval]
                 )
-                self.keepalive.start()
+                self.keepalive_thread.start()
         except (ValueError, TypeError) as exc:
             LOGGER.error(
                 f"Failed to start keep-alive thread. {type(exc).__name__}: {str(exc)}"
@@ -186,6 +185,12 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "default": True,
                 "help": "Run the IP adapter as the client (connects to FSW running TcpServer)",
             },
+            ("--keepalive-interval",): {
+                "dest": "keepalive_interval",
+                "type": float,
+                "default": 0.5000,
+                "help": "Keep alive packet interval. 0.0 = off, default = 0.5",
+            },
         }
 
     @classmethod
@@ -195,7 +200,7 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         return cls
 
     @classmethod
-    def check_arguments(cls, address, port, server=True):
+    def check_arguments(cls, address, port, server=True, keepalive_interval=0.5):
         """
         Code that should check arguments of this adapter. If there is a problem with this code, then a "ValueError"
         should be raised describing the problem with these arguments.

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/src/fprime_gds/common/communication/ccsds/space_packet.py

@@ -15,7 +15,6 @@ from .apid import APID
 import logging
 
 LOGGER = logging.getLogger("framing")
-LOGGER.setLevel(logging.DEBUG)
 
 
 @gds_plugin(FramerDeframer)

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/src/fprime_gds/common/distributor/distributor.py

@@ -199,9 +199,10 @@ class Distributor(DataHandler):
             (length, data_desc, msg) = self.parse_raw_msg_api(raw_msg)
 
             data_desc_key = data_desc_type.DataDescType(data_desc).name
-
             for d in self.__decoders[data_desc_key]:
                 try:
                     d.data_callback(msg)
                 except DecodingException as dexc:
                     LOGGER.warning("Decoding error occurred: %s. Skipping.", dexc)
+            else:
+                LOGGER.warning("No decoder registered for: %s", data_desc_type.DataDescType(data_desc).name)

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/src/fprime_gds/common/loaders/pkt_json_loader.py

@@ -19,6 +19,10 @@ class PktJsonLoader(JsonLoader):
     SET_NAME = "name"
     MEMBERS = "members"
 
+    def get_packet_set_names(self, path):
+        """ Get the list of packet sets """
+        return [packet_set[self.SET_NAME] for packet_set in self.json_dict[self.PACKETS_FIELD]]
+
     def get_id_dict(self, path, packet_set_name: str, ch_name_dict: dict):
         if path in self.saved_dicts and packet_set_name in self.saved_dicts[path]:
             (id_dict, name_dict) = self.saved_dicts[path][packet_set_name]

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/src/fprime_gds/common/pipeline/dictionaries.py

@@ -128,8 +128,16 @@ class Dictionaries:
             msg = f"[ERROR] Dictionary '{dictionary}' does not exist."
             raise Exception(msg)
         # Check for packet specification
-        if self._metadata["dictionary_type"] == "json" and packet_set_name is not None:
+        if self._metadata["dictionary_type"] == "json":
             packet_loader = fprime_gds.common.loaders.pkt_json_loader.PktJsonLoader(dictionary)
+            if packet_set_name is None:
+                names = packet_loader.get_packet_set_names(None)
+                if len(names) == 0:
+                    self._packet_dict = None
+                    return
+                elif len(names) > 1:
+                    raise Exception("[ERROR] Multiple packet sets, must set --packet-set-name")
+                packet_set_name = names[0]
             self._packet_dict = packet_loader.get_id_dict(
                 None, packet_set_name, self._channel_name_dict
             )

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/src/fprime_gds/common/testing_fw/api.py

@@ -11,6 +11,7 @@ import signal
 import time
 from pathlib import Path
 import shutil
+import json
 
 from fprime.common.models.serialize.time_type import TimeType
 
@@ -30,15 +31,17 @@ class IntegrationTestAPI(DataHandler):
 
     NOW = "NOW"
 
-    def __init__(self, pipeline, logpath=None, fsw_order=True):
+    def __init__(self, pipeline, deployment_config=None, logpath=None, fsw_order=True):
         """
         Initializes API: constructs and registers test histories.
         Args:
             pipeline: a pipeline object providing access to basic GDS functionality
+            deployment_config: path to deployment configuration file
             logpath: an optional output destination for the api test log
             fsw_order: a flag to determine whether the API histories will maintain FSW time order.
         """
         self.pipeline = pipeline
+        self.deployment_config = deployment_config
 
         # these are owned by the GDS and will not be modified by the test API.
         self.aggregate_command_history = pipeline.histories.commands
@@ -228,11 +231,29 @@ class IntegrationTestAPI(DataHandler):
 
     def get_deployment(self):
         """
-        Get the deployment of the target using the loaded FSW dictionary path
+        Get the deployment of the target using the loaded FSW dictionary.
+
         Returns:
-            The name of the deployment (str)
-        """
-        return Path(self.pipeline.dictionary_path).parent.parent.name
+            The name of the deployment (str) or None if not found
+        """
+        dictionary = str(self.pipeline.dictionary_path)
+
+        try:
+            with open(dictionary, 'r') as file:
+                data = json.load(file)
+            return data['metadata'].get("deploymentName")
+        except FileNotFoundError:
+            msg = f"Error: File not found at path: {dictionary}"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
+        except json.JSONDecodeError as e:
+            msg = f"Error decoding JSON: {e}"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
+        except Exception as e:
+            msg = f"An unexpected error occurred: {e} is an unknown key"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
 
     def wait_for_dataflow(self, count=1, channels=None, start=None, timeout=120):
         """
@@ -257,6 +278,90 @@ class IntegrationTestAPI(DataHandler):
             assert False, msg
         self.remove_telemetry_subhistory(history)
 
+    def get_config_file_path(self):
+        """
+        Accessor for IntegrationTestAPI's deployment configuration file.
+
+        Returns:
+            path to user-specified deployment configuration file (str) or None if not defined
+        """
+        if self.deployment_config:
+            return self.deployment_config
+        else:
+            return None
+
+    def load_config_file(self):
+        """
+        Load user-specified deployment configuration JSON file.
+
+        Returns:
+            JSON object as a dictionary
+        """
+        config_file = self.get_config_file_path()
+
+        try:
+            with open(config_file, 'r') as file:
+                result = json.load(file)
+            return result
+        except FileNotFoundError:
+            msg = f"Error: File not found at path {config_file}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+        except json.JSONDecodeError as e:
+            msg = f"Error decoding JSON: {e}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+        except Exception as e:
+            msg = f"An unexpected error occurred: {e}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+
+    def get_mnemonic(self, comp=None, name=None):
+        """
+        Get deployment mnemonic of specified item from user-specified deployment
+        configuration file.
+
+        Args:
+            comp: qualified name of the component instance (str), i.e. "<component>.<instance>"
+            name: command, channel, or event name (str) [optional]
+        Returns:
+            deployment mnemonic of specified item (str) or native mnemonic (str) if not found
+        """
+        data = self.load_config_file()
+
+        if data:
+            try:
+                mnemonic = data[comp]
+                return f"{mnemonic}.{name}" if name else f"{mnemonic}"
+            except KeyError:
+                self.__log(f"Error: {comp} not found", TestLogger.YELLOW)
+                return f"{comp}.{name}" if name else f"{comp}"
+        else:
+            return f"{comp}.{name}" if name else f"{comp}"
+
+    def get_prm_db_path(self) -> str:
+        """
+        Get file path to parameter db from user-specified deployment configuration file.
+
+        Returns:
+            file path to parameter db (str) or None if not found
+        """
+        data = self.load_config_file()
+
+        if data:
+            try:
+                filepath = data["Svc.PrmDb.filename"]
+                if filepath.startswith('/'):
+                    return filepath
+                else:
+                    msg = f"Error: {filepath} did not start with a forward slash"
+                    self.__log(msg, TestLogger.RED)
+                    assert False, msg
+            except KeyError:
+                return None
+        else:
+            return None
+
     ######################################################################################
     #   History Functions
     ######################################################################################

{fprime_gds-4.0.0a3 → fprime_gds-4.0.0a5}/src/fprime_gds/common/testing_fw/pytest_integration.py

@@ -52,6 +52,12 @@ def pytest_addoption(parser):
         action="store_true",
         help="Enable JUnitXML report generation to a specified location"
     )
+    # Add an option to specify a json config file that maps components
+    parser.addoption(
+        "--deployment-config",
+        action="store",
+        help="Path to JSON configuration file for mapping deployment components"
+    )
 
 def pytest_configure(config):
     """ This is a hook to allow plugins and conftest files to perform initial configuration
@@ -85,6 +91,7 @@ def fprime_test_api_session(request):
     pipeline_parser = StandardPipelineParser()
     pipeline = None
     api = None
+    deployment_config = None
     try:
         # Parse the command line arguments into a client connection
         arg_ns = pipeline_parser.handle_arguments(request.config.known_args_namespace, client=True)
@@ -92,8 +99,12 @@ def fprime_test_api_session(request):
         # Build a new pipeline with the parsed and processed arguments
         pipeline = pipeline_parser.pipeline_factory(arg_ns, pipeline)
 
+        # Get deployment configuration from command line arguments
+        if request.config.option.deployment_config:
+            deployment_config = request.config.option.deployment_config
+
         # Build and set up the integration test api
-        api = IntegrationTestAPI(pipeline, arg_ns.logs)
+        api = IntegrationTestAPI(pipeline, deployment_config, arg_ns.logs)
         api.setup()
 
         # Return the API. Note: the second call here-in will begin after the yield and clean-up after the test