90 refactor aw scenario runner

Dockerfile

@@ -23,15 +23,18 @@ RUN mkdir /ros_workspace/ &&  \
 ENV AUTOWARE_MSG_PKG="/ros_workspace/autoware_msgs/install/setup.bash"
 ENV ROS_PKG="/opt/ros/${ROS_DISTRO}/setup.bash"
 
-# install the autoware_carla_interface package
-RUN source ${AUTOWARE_MSG_PKG} && \
-    mkdir -p /ros_workspace/autoware_carla_interface && mv /autoware_scenario_runner/docker/autoware_carla_interface /ros_workspace/autoware_carla_interface && \
-    source /opt/ros/humble/setup.bash && \
-    rosdep install -i --from-path /ros_workspace/autoware_carla_interface --rosdistro humble -y && cd /ros_workspace/autoware_carla_interface && \
-    colcon build
-
-ENV AUTOWARE_CARLA_INTERFACE_PKG="/ros_workspace/autoware_carla_interface/install/setup.bash"
-ENV AUTOWARE_CARLA_INTERFACE_LOC="/ros_workspace/autoware_carla_interface"
+# install docker inside container
+RUN apt-get update -y\
+    apt-get install ca-certificates curl -y\
+    install -m 0755 -d /etc/apt/keyrings \
+    curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc \
+    chmod a+r /etc/apt/keyrings/docker.asc \
+    echo \
+        "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
+        $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
+        tee /etc/apt/sources.list.d/docker.list > /dev/null \
+    apt-get update -y\
+    apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
 
 # install pip requirements and carla
 # NETWORKX has issues with collections.abc

aw_scenario_runner.py

@@ -23,12 +23,9 @@
 from srunner.scenarioconfigs.route_scenario_configuration import (
     RouteScenarioConfiguration,
 )
-
-
 from srunner.objects.ego_vehicle import EgoVehicle
-
 from srunner.tools.log import LogUtil
-
+from srunner.tools.CARLA_manager import CARLAManager
 
 logger = logging.getLogger("scenario-runner")
 
@@ -58,21 +55,13 @@ def __init__(self, config: dict) -> None:
         self._tm_config = config["traffic_manager"]
         self._scenario_config = config["scenario_runner"]
 
-        self.carla_client = carla.Client(
-            self._carla_config["host"], int(self._carla_config["port"])
-        )
-
-        self.carla_client.set_timeout(self._carla_config["timeout"])
-
         # Flags
         self.DEV_MODE = self._scenario_config["dev_mode"]
         self.DEBUG = self._scenario_config["debug"]
 
         self.curr_iteration = 0
         self.iterations = int(self._scenario_config["algorithm"]["iterations"])
 
-        CarlaDataProvider.set_client(self.carla_client)
-
         if not self.DEV_MODE:  # only load agents and algorithms in non-dev mode
             autoware_agent_path = self._scenario_config["agent"]
             module_name = os.path.basename(autoware_agent_path).split(".")[0]
@@ -228,6 +217,17 @@ def run(self) -> None:
         )
 
         for iteration in range(self.iterations):
+            logger.info("Starting CARLA container....")
+            CARLAManager.start_carla()
+
+            logger.info("Connecting to CARLA...")
+            self.carla_client = carla.Client(
+                self._carla_config["host"], int(self._carla_config["port"])
+            )
+
+            self.carla_client.set_timeout(self._carla_config["timeout"])
+            CarlaDataProvider.set_client(self.carla_client)
+
             self.curr_iteration = iteration
             logger.info(f"Starting algorithm iteration number {self.curr_iteration}")
 
@@ -252,18 +252,48 @@ def run(self) -> None:
                 f"Scenario iteration {self.curr_iteration} has concluded with the status of {'Success' if scenario_status else 'Failure'}"
             )
 
-            # run the metric manager with the recorded file to calculate the driving score
-            driving_score = 0.0
+            criteria = self._output_criteria(
+                self.scenario_manager.scenario.get_criteria(),  # type: ignore
+                f"{self.results_manager.last_scenario}/{scenario_name}.json",
+            )
+
+            driving_score = self._calculate_driving_score(criteria)
 
             # read the scenario definition
             self.json_definition = self.algorithm._scenario_callback(
                 self.json_definition, driving_score
             )
 
-            # destroy the agent to be loaded again
-            if self.aw_agent:
-                self.aw_agent.destroy()
-                self.aw_agent = None
+    def _output_criteria(
+        self, criteria, file_name: str, save_file: bool = True
+    ) -> dict:
+        # Filter the attributes that aren't JSON serializable
+        with open("temp.json", "w", encoding="utf-8") as fp:
+            criteria_dict = {}
+            for criterion in criteria:
+                criterion_dict = criterion.__dict__
+                criteria_dict[criterion.name] = {}
+
+                for key in criterion_dict:
+                    if key != "name":
+                        try:
+                            key_dict = {key: criterion_dict[key]}
+                            json.dump(key_dict, fp, sort_keys=False, indent=4)
+                            criteria_dict[criterion.name].update(key_dict)
+                        except TypeError:
+                            pass
+
+        os.remove("temp.json")
+
+        # Save the criteria dictionary into a .json file
+        if save_file:
+            with open(file_name, "w", encoding="utf-8") as fp:
+                json.dump(criteria_dict, fp, sort_keys=False, indent=4)
+        return criteria_dict
+
+    def _calculate_driving_score(self, criteria: dict) -> float:
+        # to be implemented
+        return 0.0
 
     def destroy(self) -> None:
         """Deletes instances of all classes related to CARLA"""