fprime-gds 3.3.3__py3-none-any.whl → 3.4.1__py3-none-any.whl

fastentrypoints.py

@@ -0,0 +1,115 @@
+# noqa: D300,D400
+# Copyright (c) 2016, Aaron Christianson
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+Monkey patch setuptools to write faster console_scripts with this format:
+
+    import sys
+    from mymodule import entry_function
+    sys.exit(entry_function())
+
+This is better.
+
+(c) 2016, Aaron Christianson
+https://github.com/ninjaaron/fast-entry_points
+"""
+import re
+
+from setuptools.command import easy_install
+
+TEMPLATE = r"""
+# -*- coding: utf-8 -*-
+# EASY-INSTALL-ENTRY-SCRIPT: '{3}','{4}','{5}'
+__requires__ = '{3}'
+import re
+import sys
+
+from {0} import {1}
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit({2}())
+""".lstrip()
+
+
+@classmethod
+def get_args(cls, dist, header=None):  # noqa: D205,D400
+    """
+    Yield write_script() argument tuples for a distribution's
+    console_scripts and gui_scripts entry points.
+    """
+    if header is None:
+        # pylint: disable=E1101
+        header = cls.get_header()
+    spec = str(dist.as_requirement())
+    for type_ in "console", "gui":
+        group = f'{type_}_scripts'
+        for name, ep in dist.get_entry_map(group).items():
+            # ensure_safe_name
+            if re.search(r"[\\/]", name):
+                raise ValueError("Path separators not allowed in script names")
+            script_text = TEMPLATE.format(
+                ep.module_name, ep.attrs[0], ".".join(ep.attrs), spec, group, name
+            )
+            # pylint: disable=E1101
+            args = cls._get_script_args(type_, name, header, script_text)
+            yield from args
+
+
+# pylint: disable=E1101
+easy_install.ScriptWriter.get_args = get_args
+
+
+def main():
+    import os
+    import shutil
+    import sys
+
+    dests = sys.argv[1:] or ["."]
+    filename = re.sub(r"\.pyc$", ".py", __file__)
+
+    for dst in dests:
+        shutil.copy(filename, dst)
+        manifest_path = os.path.join(dst, "MANIFEST.in")
+        setup_path = os.path.join(dst, "setup.py")
+
+        # Insert the include statement to MANIFEST.in if not present
+        with open(manifest_path, "a+") as manifest:
+            manifest.seek(0)
+            manifest_content = manifest.read()
+            if "include fastentrypoints.py" not in manifest_content:
+                manifest.write(
+                    ("\n" if manifest_content else "") + "include fastentrypoints.py"
+                )
+
+        # Insert the import statement to setup.py if not present
+        with open(setup_path, "a+") as setup:
+            setup.seek(0)
+            setup_content = setup.read()
+            if "import fastentrypoints" not in setup_content:
+                setup.seek(0)
+                setup.truncate()
+                setup.write("import fastentrypoints\n" + setup_content)

fprime_gds/common/communication/framing.py

@@ -40,13 +40,13 @@ class FramerDeframer(abc.ABC):
         """
         Deframes the incoming data from the specified format. Produces exactly one packet, and leftover bytes. Users
         wanting all packets to be deframed should call "deframe_all". If no full packet is available, this method
-        returns None. Expects incoming raw bytes to deframe, and returns a deframed packet or None, and the leftover
-        bytes that were unused. Will search and discard data up until a start token is found. Note: data will be
-        consumed up to the first start token found.
+        returns None. Expects incoming raw bytes to deframe, and returns a deframed packet or None, the leftover
+        bytes that were unused, and any bytes discarded from the existing data stream. Will search and discard data up
+        until a start token is found. Note: data will be consumed up to the first start token found.
 
         :param data: framed data bytes
         :param no_copy: (optional) will prevent extra copy if True, but "data" input will be destroyed.
-        :return: (packet as array of bytes or None, leftover bytes)
+        :return: (packet as array of bytes or None, leftover bytes, any discarded data)
         """
 
     def deframe_all(self, data, no_copy):
@@ -56,16 +56,18 @@ class FramerDeframer(abc.ABC):
 
         :param data: framed data bytes
         :param no_copy: (optional) will prevent extra copy if True, but "data" input will be destroyed.
-        :return:
+        :return: list of packets, remaining data, discarded/unframed/garbage data
         """
         packets = []
         if not no_copy:
             data = copy.copy(data)
+        discarded_aggregate = b""
         while True:
             # Deframe and return only on None
-            (packet, data) = self.deframe(data, no_copy=True)
+            (packet, data, discarded) = self.deframe(data, no_copy=True)
+            discarded_aggregate += discarded
             if packet is None:
-                return packets, data
+                return packets, data, discarded_aggregate
             packets.append(packet)
 
 
@@ -147,6 +149,7 @@ class FpFramerDeframer(FramerDeframer):
         :param no_copy: (optional) will prevent extra copy if True, but "data" input will be destroyed.
         :return: (packet as array of bytes or None, leftover bytes)
         """
+        discarded = b""
         if not no_copy:
             data = copy.copy(data)
         # Continue until there is not enough data for the header, or until a packet is found (return)
@@ -163,6 +166,7 @@ class FpFramerDeframer(FramerDeframer):
                 start != FpFramerDeframer.START_TOKEN
                 or data_size >= FpFramerDeframer.MAXIMUM_DATA_SIZE
             ):
+                discarded += data[0:1]
                 data = data[1:]
                 continue
             # If the pool is large enough to read the whole frame, then read it
@@ -175,17 +179,18 @@ class FpFramerDeframer(FramerDeframer):
                     data[: data_size + FpFramerDeframer.HEADER_SIZE]
                 ):
                     data = data[total_size:]
-                    return deframed, data
+                    return deframed, data, discarded
                 print(
                     "[WARNING] Checksum validation failed. Have you correctly set '--comm-checksum-type'",
                     file=sys.stderr,
                 )
                 # Bad checksum, rotate 1 and keep looking for non-garbage
+                discarded += data[0:1]
                 data = data[1:]
                 continue
             # Case of not enough data for a full packet, return hoping for more later
-            return None, data
-        return None, data
+            return None, data, discarded
+        return None, data, discarded
 
 
 class TcpServerFramerDeframer(FramerDeframer):
@@ -237,11 +242,11 @@ class TcpServerFramerDeframer(FramerDeframer):
             data = data[1:]
         # Break out of data when not enough
         if len(data) < 8:
-            return None, data
+            return None, data, b""
         # Read the length and break if not enough data
         (data_len,) = struct.unpack_from(">I", data, 4)
         if len(data) < data_len + 8:
-            return None, data
+            return None, data, b""
         packet = data[8 : data_len + 8]
         data = data[data_len + 8 :]
-        return packet, data
+        return packet, data, b""

fprime_gds/common/communication/ground.py

@@ -91,7 +91,7 @@ class TCPGround(GroundHandler):
         :return: list deframed packets
         """
         self.data += self.tcp.read()
-        (frames, self.data) = self.deframer.deframe_all(self.data, no_copy=True)
+        (frames, self.data, _) = self.deframer.deframe_all(self.data, no_copy=True)
         return frames
 
     def send_all(self, frames):

fprime_gds/common/communication/updown.py

@@ -36,16 +36,23 @@ class Downlinker:
     """
 
     def __init__(
-        self, adapter: BaseAdapter, ground: GroundHandler, deframer: FramerDeframer
+        self,
+        adapter: BaseAdapter,
+        ground: GroundHandler,
+        deframer: FramerDeframer,
+        discarded=None,
     ):
         """Initialize the downlinker
 
-        Constructs a new downlinker object used to run the downlink and deframing operation.
+        Constructs a new downlinker object used to run the downlink and deframing operation. This downlinker will log
+        discarded (unframed) data when discarded is a writable data object. When discarded is None the discarded data is
+        dropped.
 
         Args:
             adapter: adapter used to read raw data from the hardware connection
             ground: handles the ground side connection
             deframer: deframer used to deframe data from the communication format
+            discarded: file to write discarded data to. None to drop the data.
         """
         self.running = True
         self.th_ground = None
@@ -54,13 +61,18 @@ class Downlinker:
         self.ground = ground
         self.deframer = deframer
         self.outgoing = Queue()
+        self.discarded = discarded
 
     def start(self):
         """Starts the downlink pipeline"""
-        self.th_ground = threading.Thread(target=self.sending, name="DownlinkTTSGroundThread")
+        self.th_ground = threading.Thread(
+            target=self.sending, name="DownlinkTTSGroundThread"
+        )
         self.th_ground.daemon = True
         self.th_ground.start()
-        self.th_data = threading.Thread(target=self.deframing, name="DownLinkDeframingThread")
+        self.th_data = threading.Thread(
+            target=self.deframing, name="DownLinkDeframingThread"
+        )
         self.th_data.daemon = True
         self.th_data.start()
 
@@ -74,12 +86,20 @@ class Downlinker:
         while self.running:
             # Blocks until data is available, but may still return b"" if timeout
             pool += self.adapter.read()
-            frames, pool = self.deframer.deframe_all(pool, no_copy=True)
+            frames, pool, discarded_data = self.deframer.deframe_all(pool, no_copy=True)
             try:
                 for frame in frames:
                     self.outgoing.put_nowait(frame)
             except Full:
                 DW_LOGGER.warning("GDS ground queue full, dropping frame")
+            try:
+                if self.discarded is not None:
+                    self.discarded.write(discarded_data)
+                    self.discarded.flush()
+            # Failure to write discarded data should never stop the GDS. Log it and move on.
+            except Exception as exc:
+                DW_LOGGER.warning("Cannot write discarded data %s", exc)
+                self.discarded = None  # Give up on logging further data
 
     def sending(self):
         """Outgoing stage of downlink
@@ -107,6 +127,7 @@ class Downlinker:
         for thread in [self.th_data, self.th_ground]:
             if thread is not None:
                 thread.join()
+        self.discarded = None
 
     def add_loopback_frame(self, frame):
         """Adds a frame to loopback to ground

fprime_gds/common/files/downlinker.py

@@ -52,7 +52,6 @@ class FileDownlinker(fprime_gds.common.handlers.DataHandler):
         self.sequence = 0  # Keeps track of what the current sequence ID should be
         self.timer = fprime_gds.common.files.helpers.Timeout()
         self.timer.setup(self.timeout, timeout)
-        os.makedirs(self.__directory, exist_ok=True)
 
     def data_callback(self, data, sender=None):
         """
@@ -96,7 +95,15 @@ class FileDownlinker(fprime_gds.common.handlers.DataHandler):
             size,
             self.__log_dir,
         )
-        self.active.open(TransmitFileState.WRITE)
+        try:
+            self.active.open(TransmitFileState.WRITE)
+        except PermissionError as exc:
+            self.state = FileStates.ERROR
+            LOGGER.warning(
+                "Unable to open file for writing. Discarding subsequent downlink packets. "
+                + str(exc)
+            )
+            return
         LOGGER.addHandler(self.active.log_handler)
         message = "Received START packet with metadata:\n"
         message += "\tSize: %d\n"
@@ -116,7 +123,10 @@ class FileDownlinker(fprime_gds.common.handlers.DataHandler):
         # Initialize all relevant DATA packet attributes into variables from file_data
         offset = data.offset
         if self.state != FileStates.RUNNING:
-            LOGGER.warning("Received unexpected data packet for offset: %d", offset)
+            # ERROR state means GDS is not ready to receive data packets (permission error)
+            # No need to log this, as it is already logged in handle_start and would only spam logs
+            if self.state != FileStates.ERROR:
+                LOGGER.warning("Received unexpected data packet for offset: %d", offset)
         else:
             if data.seqID != self.sequence:
                 LOGGER.warning(
@@ -156,9 +166,10 @@ class FileDownlinker(fprime_gds.common.handlers.DataHandler):
         """
         # Initialize all relevant END packet attributes into variables from file_data
         # hashValue attribute is not relevant right now, but might be in the future
-        if self.state != FileStates.RUNNING:
-            LOGGER.warning("Received unexpected END packet")
-        else:
+        if self.state == FileStates.ERROR:
+            LOGGER.info("Received END packet for discarded downlink")
+            self.finish()
+        elif self.state == FileStates.RUNNING:
             if data.seqID != self.sequence:
                 LOGGER.warning(
                     "End packet has unexpected sequence id. Expected: %d got %d",
@@ -167,6 +178,8 @@ class FileDownlinker(fprime_gds.common.handlers.DataHandler):
                 )
             LOGGER.info("Received END packet, finishing downlink")
             self.finish()
+        else:
+            LOGGER.warning("Received unexpected END packet")
 
     def timeout(self):
         """Timeout the current downlink"""

fprime_gds/common/files/helpers.py

@@ -77,6 +77,7 @@ class FileStates(enum.Enum):
     RUNNING = 1
     CANCELED = 2
     END_WAIT = 3  # Waiting for the handshake for CANCEL or END packet
+    ERROR = 4
 
 
 class CFDPChecksum:

fprime_gds/common/loaders/xml_loader.py

@@ -117,23 +117,6 @@ class XmlLoader(dict_loader.DictLoader):
             # Parse xml and get element tree object we can retrieve data from
             element_tree = etree.parse(fd, parser=xml_parser)
         root = element_tree.getroot()
-
-        # Check version of the XML before continuing. Versions weren't published before 1.5.4.  Only check major minor
-        # and point versions to allow for development versions to be allowed.
-        dict_version_string = root.attrib.get("framework_version", "1.5.4")
-        digits = []
-        # Process through the tokens of the version until we hit something that is not an int
-        for token in dict_version_string.split("."):
-            try:
-                digits.append(int(token))
-            except ValueError:
-                break
-        dict_version = tuple(digits)
-        if (
-            dict_version < MINIMUM_SUPPORTED_FRAMEWORK_VERSION
-            or dict_version > MAXIMUM_SUPPORTED_FRAMEWORK_VERSION
-        ):
-            raise UnsupportedDictionaryVersionException(dict_version)
         return root
 
     @staticmethod
@@ -401,22 +384,3 @@ class XmlLoader(dict_loader.DictLoader):
         raise exceptions.GseControllerParsingException(
             msg
         )
-
-
-class UnsupportedDictionaryVersionException(Exception):
-    """Dictionary is of unsupported version"""
-
-    def __init__(self, version):
-        """Create a dictionary of a specific version"""
-
-        def pretty(version_tuple):
-            """Pretty print version"""
-            return ".".join([str(item) for item in version_tuple])
-
-        super().__init__(
-            "Dictionary version {} is not in supported range: {}-{}. Please upgrade fprime-gds.".format(
-                pretty(version),
-                pretty(MINIMUM_SUPPORTED_FRAMEWORK_VERSION),
-                pretty(MAXIMUM_SUPPORTED_FRAMEWORK_VERSION),
-            )
-        )

fprime_gds/common/logger/__init__.py

@@ -10,6 +10,8 @@ import logging
 import os
 import sys
 
+INITIALIZED = False
+
 
 def configure_py_log(directory=None, filename=sys.argv[0], mirror_to_stdout=False):
     """
@@ -21,7 +23,14 @@ def configure_py_log(directory=None, filename=sys.argv[0], mirror_to_stdout=Fals
     :param mode: of file to write
     :param mirror_to_stdout: mirror the log output to standard our
     """
-    handlers = [logging.StreamHandler(sys.stdout)] if directory is None or mirror_to_stdout else []
+    global INITIALIZED
+    if INITIALIZED:
+        return
+    handlers = (
+        [logging.StreamHandler(sys.stdout)]
+        if directory is None or mirror_to_stdout
+        else []
+    )
     if directory is not None:
         log_file = os.path.join(directory, os.path.basename(filename))
         log_file = log_file if log_file.endswith(".log") else f"{log_file}.log"
@@ -33,4 +42,4 @@ def configure_py_log(directory=None, filename=sys.argv[0], mirror_to_stdout=Fals
         logging.getLogger().addHandler(handler)
     logging.getLogger().setLevel(logging.INFO)
     logging.info("Logging system initialized!")
-
+    INITIALIZED = True

fprime_gds/common/pipeline/files.py

@@ -7,6 +7,7 @@ communications layer.
 
 @author mstarch
 """
+import os
 import fprime_gds.common.files.downlinker
 import fprime_gds.common.files.uplinker
 
@@ -27,7 +28,8 @@ class Filing:
         self, down_store, file_encoder, file_decoder, distributor, log_dir
     ):
         """
-        Sets up the file handling (uplink and downlink) from a pair of encoders and decoders
+        Sets up the file handling (uplink and downlink) from a pair of encoders and decoders.
+        Raises a PermissionError if the down_store is not writable.
 
         :param down_store: downlink storage directory
         :param file_encoder: file encoder for uplink
@@ -41,6 +43,11 @@ class Filing:
         )
         file_decoder.register(self.__downlinker)
         distributor.register("FW_PACKET_HAND", self.__uplinker)
+        if not os.access(down_store, os.W_OK):
+            raise PermissionError(
+                f"{down_store} is not writable. Downlinker not be able to save files. "
+                "Fix permissions or change storage directory with --file-storage-directory."
+            )
 
     @property
     def uplinker(self):

fprime_gds/executables/cli.py

@@ -226,12 +226,16 @@ class DetectionParser(ParserBase):
         if likely_deployment.exists():
             args.deployment = likely_deployment
             return args
-        child_directories = [child for child in detected_toolchain.iterdir() if child.is_dir()]
+        child_directories = [
+            child for child in detected_toolchain.iterdir() if child.is_dir()
+        ]
         if not child_directories:
             msg = f"No deployments found in {detected_toolchain}. Specify deployment with: --deployment"
             raise Exception(msg)
         # Works for the old structure where the bin, lib, and dict directories live immediately under the platform
-        elif len(child_directories) == 3 and set([path.name for path in child_directories]) == {"bin", "lib", "dict"}:
+        elif len(child_directories) == 3 and set(
+            [path.name for path in child_directories]
+        ) == {"bin", "lib", "dict"}:
             args.deployment = detected_toolchain
             return args
         elif len(child_directories) > 1:
@@ -310,8 +314,7 @@ class CommAdapterParser(ParserBase):
                 "action": "store",
                 "type": str,
                 "help": "Adapter for communicating to flight deployment. [default: %(default)s]",
-                "choices": ["none"]
-                + list(adapter_definition_dictionaries),
+                "choices": ["none"] + list(adapter_definition_dictionaries),
                 "default": "ip",
             },
             ("--comm-checksum-type",): {
@@ -326,6 +329,15 @@ class CommAdapterParser(ParserBase):
                 ],
                 "default": fprime_gds.common.communication.checksum.CHECKSUM_SELECTION,
             },
+            ("--output-unframed-data",): {
+                "dest": "output_unframed_data",
+                "action": "store",
+                "nargs": "?",
+                "help": "Log unframed data to supplied file relative to log directory. Use '-' for standard out.",
+                "default": None,
+                "const": "unframed.log",
+                "required": False,
+            },
         }
         return {**adapter_arguments, **com_arguments}
 
@@ -699,9 +711,7 @@ class BinaryDeployment(DetectionParser):
         args.app = Path(args.app) if args.app else Path(find_app(args.deployment))
         if not args.app.is_file():
             msg = f"F prime binary '{args.app}' does not exist or is not a file"
-            raise ValueError(
-                msg
-            )
+            raise ValueError(msg)
         return args
 
 
@@ -728,7 +738,7 @@ class SearchArgumentsParser(ParserBase):
                 "action": "store",
                 "required": False,
                 "type": int,
-                "nargs":'+',
+                "nargs": "+",
                 "help": f"only show {self.command_name} matching the given type ID(s) 'ID'; can provide multiple IDs to show all given types",
                 "metavar": "ID",
             },

fprime_gds/executables/comm.py

@@ -21,6 +21,8 @@ import logging
 import signal
 import sys
 
+from pathlib import Path
+
 # Required adapters built on standard tools
 try:
     from fprime_gds.common.zmq_transport import ZmqGround
@@ -84,34 +86,59 @@ def main():
     # Set the framing class used and pass it to the uplink and downlink component constructions giving each a separate
     # instantiation
     framer_class = FpFramerDeframer
-    LOGGER.info("Starting uplinker/downlinker connecting to FSW using %s with %s", adapter, framer_class.__name__)
-    downlinker = Downlinker(adapter, ground, framer_class())
-    uplinker = Uplinker(adapter, ground, framer_class(), downlinker)
-
-    # Open resources for the handlers on either side, this prepares the resources needed for reading/writing data
-    ground.open()
-    adapter.open()
-
-    # Finally start the processing of uplink and downlink
-    downlinker.start()
-    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.
-    def shutdown(*_):
-        """Shutdown function for signals"""
-        uplinker.stop()
-        downlinker.stop()
+    LOGGER.info(
+        "Starting uplinker/downlinker connecting to FSW using %s with %s",
+        adapter,
+        framer_class.__name__,
+    )
+    discarded_file_handle = None
+    try:
+        if args.output_unframed_data == "-":
+            discarded_file_handle = sys.stdout.buffer
+        elif args.output_unframed_data is not None:
+            discarded_file_handle_path = (
+                Path(args.logs) / Path(args.output_unframed_data)
+            ).resolve()
+            try:
+                discarded_file_handle = open(discarded_file_handle_path, "wb")
+                LOGGER.info("Logging unframed data to %s", discarded_file_handle_path)
+            except OSError:
+                LOGGER.warning(
+                    "Failed to open %s. Unframed data will be discarded.",
+                    discarded_file_handle_path,
+                )
+        downlinker = Downlinker(
+            adapter, ground, framer_class(), discarded=discarded_file_handle
+        )
+        uplinker = Uplinker(adapter, ground, framer_class(), downlinker)
+
+        # Open resources for the handlers on either side, this prepares the resources needed for reading/writing data
+        ground.open()
+        adapter.open()
+
+        # Finally start the processing of uplink and downlink
+        downlinker.start()
+        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.
+        def shutdown(*_):
+            """Shutdown function for signals"""
+            uplinker.stop()
+            downlinker.stop()
+            uplinker.join()
+            downlinker.join()
+            ground.close()
+            adapter.close()
+
+        signal.signal(signal.SIGTERM, shutdown)
+        signal.signal(signal.SIGINT, shutdown)
         uplinker.join()
         downlinker.join()
-        ground.close()
-        adapter.close()
-
-    signal.signal(signal.SIGTERM, shutdown)
-    signal.signal(signal.SIGINT, shutdown)
-    uplinker.join()
-    downlinker.join()
+    finally:
+        if discarded_file_handle is not None and args.output_unframed_data != "-":
+            discarded_file_handle.close()
     return 0
 
 

fprime_gds/flask/static/js/datastore.js

@@ -121,7 +121,18 @@ class FullListHistory extends ListHistory {
      * @param new_items: new items being to be process
      */
     send(new_items) {
-        this.store.splice(0, this.store.length, ...new_items);
+        // When the lists are not the same, update the stored list otherwise keep the list to prevent unnecessary bound
+        // data re-rendering.
+        if (this.store.length !== new_items.length) {
+            this.store.splice(0, this.store.length, ...new_items);
+            return;
+        }
+        for (let i = 0; i < Math.min(this.store.length, new_items.length); i++) {
+            if (this.store[i] !== new_items[i]) {
+                this.store.splice(0, this.store.length, ...new_items);
+                return;
+            }
+        }
     }
 }