RuntimeManager Interface (UBC-Thunderbots#3573)

* interface completed

* cleanup

* [pre-commit.ci lite] apply automatic fixes

* cleanup

* [pre-commit.ci lite] apply automatic fixes

---------

Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>

Author: Andrewyx

environment_setup/setup_software.sh

@@ -143,9 +143,9 @@ sudo cp "$CURR_DIR/../src/software/autoref/DIV_B.txt" "/opt/tbotspython/autoRefe
 
 print_status_msg "Finished setting up AutoRef"
 
-# setup external_ai 
-sudo mkdir /opt/tbotspython/external_ai
-sudo chown -R $USER:$USER /opt/tbotspython/external_ai/
+# setup external_runtimes 
+sudo mkdir /opt/tbotspython/external_runtimes
+sudo chown -R $USER:$USER /opt/tbotspython/external_runtimes/
 
 # Install Bazel
 print_status_msg "Installing Bazel"

src/software/thunderscope/BUILD

@@ -20,6 +20,7 @@ py_binary(
         ":util",
         "//software/thunderscope/binary_context_managers:full_system",
         "//software/thunderscope/binary_context_managers:game_controller",
+        "//software/thunderscope/binary_context_managers:runtime_manager",
         "//software/thunderscope/binary_context_managers:simulator",
     ],
 )

src/software/thunderscope/binary_context_managers/BUILD

@@ -50,3 +50,12 @@ py_library(
         "//software/thunderscope:time_provider",
     ],
 )
+
+py_library(
+    name = "runtime_manager",
+    srcs = [
+        "runtime_installer.py",
+        "runtime_loader.py",
+        "runtime_manager.py",
+    ],
+)

src/software/thunderscope/binary_context_managers/runtime_installer.py

@@ -0,0 +1,20 @@
+# TODO: #3559
+class RuntimeInstaller:
+    """Delegate class for handling runtime installation and remote interfacing"""
+
+    def __init__(self):
+        pass
+
+    def fetch_remote_runtimes(self) -> list[str]:
+        """Requests a list of available runtimes from the remote. This is an expensive operation
+        and should only be called when necessary.
+        :return: A unique list of names for available runtimes
+        """
+        return []
+
+    def install_runtime(self, version: str) -> None:
+        """Installs the runtime of the specified version or throws an error upon failure.
+        Ensures that the runtime is compatible with the current platform
+        :param version: Version of the runtime hosted on the remote to install
+        """
+        pass

src/software/thunderscope/binary_context_managers/runtime_loader.py

@@ -0,0 +1,49 @@
+from software.thunderscope.constants import RuntimeManagerConstants
+
+
+# TODO: #3557
+class RuntimeLoader:
+    """Delegate class for handling local runtimes and managing runtime selection"""
+
+    def __init__(self):
+        self.cached_runtimes = None
+
+    def fetch_installed_runtimes(self) -> list[str]:
+        """Fetches the list of available runtimes from the local disk
+        :return: A list of names for available runtimes
+        """
+        if self.cached_runtimes:
+            return self.cached_runtimes.keys()
+        else:
+            return []
+
+    def load_existing_runtimes(self, yellow_runtime: str, blue_runtime: str) -> None:
+        """Loads the yellow and blue runtimes specified by saving them in the local disk.
+        :param blue_runtime: Unique name of the blue runtime to set
+        :param yellow_runtime: Unique name of the yellow runtime to set
+        """
+        config = {}
+        self._set_runtime_config(config)
+        pass
+
+    def fetch_runtime_config(self) -> dict[str, str]:
+        """Fetches the runtime configuration from the local disk.
+        :return: Returns the runtime configuration as a map
+        """
+        return {
+            RuntimeManagerConstants.RUNTIME_CONFIG_BLUE_KEY: RuntimeManagerConstants.DEFAULT_BINARY_PATH,
+            RuntimeManagerConstants.RUNTIME_CONFIG_YELLOW_KEY: RuntimeManagerConstants.DEFAULT_BINARY_PATH,
+        }
+
+    def _create_runtime_config(self) -> None:
+        """Creates the runtime configuration file on disk and throws an error upon failure."""
+        pass
+
+    def _set_runtime_config(self, config: dict[str, str]) -> None:
+        """Sets/persists the runtime configuration file on disk and creates the configuration
+        file if it doesn't exist.
+        :param config: The runtime configuration containing
+         - color_runtime : absolute path of external runtime, or
+         - color_runtime : relative path of DEFAULT_BINARY_PATH
+        """
+        pass

src/software/thunderscope/binary_context_managers/runtime_manager.py

@@ -0,0 +1,46 @@
+from software.thunderscope.binary_context_managers.runtime_installer import (
+    RuntimeInstaller,
+)
+from software.thunderscope.binary_context_managers.runtime_loader import RuntimeLoader
+
+
+class RuntimeManager:
+    """Class for interfacing with AI runtimes/backends (full system or external) on the disk"""
+
+    def __init__(self):
+        self.runtime_installer = RuntimeInstaller()
+        self.runtime_loader = RuntimeLoader()
+
+    def fetch_remote_runtimes(self) -> list[str]:
+        """Requests a list of available runtimes from the remote. Includes DEFAULT_BINARY_NAME by default
+        :return: A unique list of names for available runtimes
+        """
+        return self.runtime_installer.fetch_remote_runtimes()
+
+    def install_runtime(self, version: str) -> None:
+        """Installs the runtime of the specified version or throws an error upon failure.
+        :param version: Version of the runtime hosted on the remote to install
+        """
+        self.runtime_installer.install_runtime(version)
+
+    def fetch_installed_runtimes(self) -> list[str]:
+        """Fetches the list of available runtimes from the local disk
+        :return: A list of names for available runtimes
+        """
+        return self.runtime_loader.fetch_installed_runtimes()
+
+    def load_existing_runtime(self, yellow_runtime: str, blue_runtime: str) -> None:
+        """Loads the runtimes of the specified name or throws an error upon failure.
+        :param blue_runtime: name of the blue runtime to load
+        :param yellow_runtime: name of the yellow runtime to load
+        """
+        self.runtime_loader.load_existing_runtimes(yellow_runtime, blue_runtime)
+
+    def fetch_runtime_config(self) -> dict[str, str]:
+        """Fetches the runtime configuration from the local disk
+        :return: Returns the runtime configuration as a map
+        """
+        return self.runtime_loader.fetch_runtime_config()
+
+
+runtime_manager_instance = RuntimeManager()

src/software/thunderscope/constants.py

@@ -386,3 +386,14 @@ class LogLevels(StrEnum):
     INFO = "INFO"
     WARNING = "WARNING"
     FATAL = "FATAL"
+
+
+class RuntimeManagerConstants:
+    """Constants for Runtime Manager"""
+
+    RUNTIME_CONFIG_BLUE_KEY = "blue_path_to_binary"
+    RUNTIME_CONFIG_YELLOW_KEY = "yellow_path_to_binary"
+    DEFAULT_BINARY_PATH = "software/unix_full_system"
+    DEFAULT_BINARY_NAME = "localhost"
+    EXTERNAL_RUNTIMES_PATH = "/opt/tbotspython/external_runtimes"
+    RUNTIME_CONFIG_PATH = f"{EXTERNAL_RUNTIMES_PATH}/runtime_config.toml"

src/software/thunderscope/gl/widgets/BUILD

@@ -6,6 +6,7 @@ py_library(
     name = "gl_runtime_installer",
     srcs = ["gl_runtime_installer.py"],
     deps = [
+        "//software/thunderscope/binary_context_managers:runtime_manager",
         requirement("pyqtgraph"),
     ],
 )

src/software/thunderscope/gl/widgets/gl_runtime_installer.py

@@ -7,6 +7,10 @@
     QVBoxLayout,
 )
 
+from software.thunderscope.binary_context_managers.runtime_manager import (
+    runtime_manager_instance,
+)
+
 
 class GLRuntimeInstallerDialog(QDialog):
     """Modal that displays selectable list of runtimes to install"""
@@ -19,8 +23,7 @@ def __init__(self, parent: QWidget):
         """
         super().__init__(parent)
 
-        # TODO (#3559): get list of runtimes from GET request
-        runtimes = [f"runtime_{i}" for i in range(10)]
+        runtimes = runtime_manager_instance.fetch_remote_runtimes()
 
         self.setWindowTitle("Install runtimes")
         self.setModal(True)

src/software/thunderscope/thunderscope_main.py

@@ -8,22 +8,29 @@
 import google.protobuf
 from google.protobuf.internal import api_implementation
 
+from software.thunderscope.binary_context_managers.runtime_manager import (
+    runtime_manager_instance,
+)
+
 protobuf_impl_type = api_implementation.Type()
 assert protobuf_impl_type == "upb", (
     f"Trying to use the {protobuf_impl_type} protobuf implementation. "
     "Please use the upb implementation, available in python protobuf version 4.21.0 and above."
     f"The current version of protobuf is {google.protobuf.__version__}"
 )
 
-
 from software.thunderscope.thunderscope import Thunderscope
 from software.thunderscope.constants import LogLevels
 from software.thunderscope.binary_context_managers import *
 from proto.import_all_protos import *
 from software.py_constants import *
 from software.thunderscope.robot_communication import RobotCommunication
 from software.thunderscope.wifi_communication_manager import WifiCommunicationManager
-from software.thunderscope.constants import EstopMode, ProtoUnixIOTypes
+from software.thunderscope.constants import (
+    EstopMode,
+    ProtoUnixIOTypes,
+    RuntimeManagerConstants,
+)
 from software.thunderscope.estop_helpers import get_estop_config
 from software.thunderscope.proto_unix_io import ProtoUnixIO
 import software.thunderscope.thunderscope_config as config
@@ -432,31 +439,16 @@ def __ticker(tick_rate_ms: int) -> None:
                     tick_rate_ms, tscope.proto_unix_io_map[ProtoUnixIOTypes.SIM], tscope
                 )
 
-        # Libraries to use for yellow
-
-        # TODO (#3557) Set external_ai variables to follow toml file in /opt/tbotspython/external_ai/ai_config.toml
-        blue_external_ai = None
-        yellow_external_ai = None
-
-        # If ai selected is default, use the unix full system generated by the current branch build in the bazel sand blue_full_system_proto_unix_io
-        # Else, find the unix full system in opt
-        blue_path_to_binary = (
-            "software/unix_full_system"
-            if not blue_external_ai
-            else "/opt/tbotspython/external_ai/{}".format(blue_external_ai)
-        )
-
-        yellow_path_to_binary = (
-            "software/unix_full_system"
-            if not yellow_external_ai
-            else "/opt/tbotspython/external_ai/{}".format(yellow_external_ai)
-        )
+        # Fetch the AI runtime/backends
+        runtime_config = runtime_manager_instance.fetch_runtime_config()
 
         # Launch all binaries
         with Simulator(
             args.simulator_runtime_dir, args.debug_simulator, args.enable_realism
         ) as simulator, FullSystem(
-            path_to_binary=blue_path_to_binary,
+            path_to_binary=runtime_config[
+                RuntimeManagerConstants.RUNTIME_CONFIG_BLUE_KEY
+            ],
             full_system_runtime_dir=args.blue_full_system_runtime_dir,
             debug_full_system=args.debug_blue_full_system,
             friendly_colour_yellow=False,
@@ -465,7 +457,9 @@ def __ticker(tick_rate_ms: int) -> None:
             running_in_realtime=(not args.ci_mode),
             log_level=args.log_level,
         ) as blue_fs, FullSystem(
-            path_to_binary=yellow_path_to_binary,
+            path_to_binary=runtime_config[
+                RuntimeManagerConstants.RUNTIME_CONFIG_YELLOW_KEY
+            ],
             full_system_runtime_dir=args.yellow_full_system_runtime_dir,
             debug_full_system=args.debug_yellow_full_system,
             friendly_colour_yellow=True,