Merge 'origin/dev-game-layer' into feature/1924-Agent-Interface

src/primaite/simulator/system/services/service.py

@@ -3,7 +3,7 @@ from typing import Dict, Optional
 
 from primaite import getLogger
 from primaite.simulator.core import RequestManager, RequestType
-from primaite.simulator.system.software import IOSoftware
+from primaite.simulator.system.software import IOSoftware, SoftwareHealthState
 
 _LOGGER = getLogger(__name__)
 
@@ -34,21 +34,29 @@ class Service(IOSoftware):
 
     operating_state: ServiceOperatingState = ServiceOperatingState.STOPPED
     "The current operating state of the Service."
+
     restart_duration: int = 5
     "How many timesteps does it take to restart this service."
-    _restart_countdown: Optional[int] = None
+    restart_countdown: Optional[int] = None
     "If currently restarting, how many timesteps remain until the restart is finished."
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.health_state_visible = SoftwareHealthState.UNUSED
+        self.health_state_actual = SoftwareHealthState.UNUSED
+
     def _init_request_manager(self) -> RequestManager:
-        am = super()._init_request_manager()
-        am.add_request("stop", RequestType(func=lambda request, context: self.stop()))
-        am.add_request("start", RequestType(func=lambda request, context: self.start()))
-        am.add_request("pause", RequestType(func=lambda request, context: self.pause()))
-        am.add_request("resume", RequestType(func=lambda request, context: self.resume()))
-        am.add_request("restart", RequestType(func=lambda request, context: self.restart()))
-        am.add_request("disable", RequestType(func=lambda request, context: self.disable()))
-        am.add_request("enable", RequestType(func=lambda request, context: self.enable()))
-        return am
+        rm = super()._init_request_manager()
+        rm.add_request("scan", RequestType(func=lambda request, context: self.scan()))
+        rm.add_request("stop", RequestType(func=lambda request, context: self.stop()))
+        rm.add_request("start", RequestType(func=lambda request, context: self.start()))
+        rm.add_request("pause", RequestType(func=lambda request, context: self.pause()))
+        rm.add_request("resume", RequestType(func=lambda request, context: self.resume()))
+        rm.add_request("restart", RequestType(func=lambda request, context: self.restart()))
+        rm.add_request("disable", RequestType(func=lambda request, context: self.disable()))
+        rm.add_request("enable", RequestType(func=lambda request, context: self.enable()))
+        return rm
 
     def describe_state(self) -> Dict:
         """
@@ -60,7 +68,9 @@ class Service(IOSoftware):
         :rtype: Dict
         """
         state = super().describe_state()
-        state.update({"operating_state": self.operating_state.value})
+        state["operating_state"] = self.operating_state.value
+        state["health_state_actual"] = self.health_state_actual
+        state["health_state_visible"] = self.health_state_visible
         return state
 
     def reset_component_for_episode(self, episode: int):
@@ -72,47 +82,59 @@ class Service(IOSoftware):
         """
         pass
 
+    def scan(self) -> None:
+        """Update the service visible states."""
+        # update the visible operating state
+        self.health_state_visible = self.health_state_actual
+
     def stop(self) -> None:
         """Stop the service."""
         if self.operating_state in [ServiceOperatingState.RUNNING, ServiceOperatingState.PAUSED]:
             self.sys_log.info(f"Stopping service {self.name}")
             self.operating_state = ServiceOperatingState.STOPPED
+            self.health_state_actual = SoftwareHealthState.UNUSED
 
     def start(self, **kwargs) -> None:
         """Start the service."""
         if self.operating_state == ServiceOperatingState.STOPPED:
             self.sys_log.info(f"Starting service {self.name}")
             self.operating_state = ServiceOperatingState.RUNNING
+            self.health_state_actual = SoftwareHealthState.GOOD
 
     def pause(self) -> None:
         """Pause the service."""
         if self.operating_state == ServiceOperatingState.RUNNING:
             self.sys_log.info(f"Pausing service {self.name}")
             self.operating_state = ServiceOperatingState.PAUSED
+            self.health_state_actual = SoftwareHealthState.OVERWHELMED
 
     def resume(self) -> None:
         """Resume paused service."""
         if self.operating_state == ServiceOperatingState.PAUSED:
             self.sys_log.info(f"Resuming service {self.name}")
             self.operating_state = ServiceOperatingState.RUNNING
+            self.health_state_actual = SoftwareHealthState.GOOD
 
     def restart(self) -> None:
         """Restart running service."""
         if self.operating_state in [ServiceOperatingState.RUNNING, ServiceOperatingState.PAUSED]:
             self.sys_log.info(f"Pausing service {self.name}")
             self.operating_state = ServiceOperatingState.RESTARTING
-            self.restart_countdown = self.restarting_duration
+            self.health_state_actual = SoftwareHealthState.OVERWHELMED
+            self.restart_countdown = self.restart_duration
 
     def disable(self) -> None:
         """Disable the service."""
         self.sys_log.info(f"Disabling Application {self.name}")
         self.operating_state = ServiceOperatingState.DISABLED
+        self.health_state_actual = SoftwareHealthState.OVERWHELMED
 
     def enable(self) -> None:
         """Enable the disabled service."""
         if self.operating_state == ServiceOperatingState.DISABLED:
             self.sys_log.info(f"Enabling Application {self.name}")
             self.operating_state = ServiceOperatingState.STOPPED
+            self.health_state_actual = SoftwareHealthState.OVERWHELMED
 
     def apply_timestep(self, timestep: int) -> None:
         """
@@ -129,4 +151,5 @@ class Service(IOSoftware):
             if self.restart_countdown <= 0:
                 _LOGGER.debug(f"Restarting finished for service {self.name}")
                 self.operating_state = ServiceOperatingState.RUNNING
+                self.health_state_actual = SoftwareHealthState.GOOD
             self.restart_countdown -= 1

src/primaite/simulator/system/software.py

@@ -31,6 +31,8 @@ class SoftwareType(Enum):
 class SoftwareHealthState(Enum):
     """Enumeration of the Software Health States."""
 
+    UNUSED = 0
+    "Unused state."
     GOOD = 1
     "The software is in a good and healthy condition."
     COMPROMISED = 2
@@ -88,15 +90,15 @@ class Software(SimComponent):
     "The folder on the file system the Software uses."
 
     def _init_request_manager(self) -> RequestManager:
-        am = super()._init_request_manager()
-        am.add_request(
+        rm = super()._init_request_manager()
+        rm.add_request(
             "compromise",
             RequestType(
                 func=lambda request, context: self.set_health_state(SoftwareHealthState.COMPROMISED),
             ),
         )
-        am.add_request("scan", RequestType(func=lambda request, context: self.scan()))
-        return am
+        rm.add_request("scan", RequestType(func=lambda request, context: self.scan()))
+        return rm
 
     def _get_session_details(self, session_id: str) -> Session:
         """
@@ -241,6 +243,7 @@ class IOSoftware(Software):
             payload=payload, dest_ip_address=dest_ip_address, dest_port=dest_port, session_id=session_id
         )
 
+    @abstractmethod
     def receive(self, payload: Any, session_id: str, **kwargs) -> bool:
         """
         Receives a payload from the SessionManager.