Merge branch 'dev' into bugfix/2676_NMNE_var_access

src/primaite/simulator/__init__.py

@@ -34,10 +34,14 @@ class _SimOutput:
         path = PRIMAITE_PATHS.user_sessions_path / self.date_str / self.time_str
 
         self._path = path
+        self._agent_behaviour_path = path
         self._save_pcap_logs: bool = False
         self._save_sys_logs: bool = False
+        self._save_agent_logs: bool = False
         self._write_sys_log_to_terminal: bool = False
+        self._write_agent_log_to_terminal: bool = False
         self._sys_log_level: LogLevel = LogLevel.WARNING  # default log level is at WARNING
+        self._agent_log_level: LogLevel = LogLevel.WARNING
 
     @property
     def path(self) -> Path:
@@ -61,6 +65,28 @@ class _SimOutput:
         self._path = new_path
         self._path.mkdir(exist_ok=True, parents=True)
 
+    @property
+    def agent_behaviour_path(self) -> Path:
+        if is_dev_mode():
+            # if dev mode is enabled, if output dir is not set, print to primaite repo root
+            path: Path = _PRIMAITE_ROOT.parent.parent / "sessions" / self.date_str / self.time_str / "agent_behaviour"
+            # otherwise print to output dir
+            if PRIMAITE_CONFIG["developer_mode"]["output_dir"]:
+                path: Path = (
+                    Path(PRIMAITE_CONFIG["developer_mode"]["output_dir"])
+                    / "sessions"
+                    / self.date_str
+                    / self.time_str
+                    / "agent_behaviour"
+                )
+            self._agent_behaviour_path = path
+        return self._agent_behaviour_path
+
+    @agent_behaviour_path.setter
+    def agent_behaviour_path(self, new_path: Path) -> None:
+        self._agent_behaviour_path = new_path
+        self._agent_behaviour_path.mkdir(exist_ok=True, parents=True)
+
     @property
     def save_pcap_logs(self) -> bool:
         if is_dev_mode():
@@ -81,6 +107,16 @@ class _SimOutput:
     def save_sys_logs(self, save_sys_logs: bool) -> None:
         self._save_sys_logs = save_sys_logs
 
+    @property
+    def save_agent_logs(self) -> bool:
+        if is_dev_mode():
+            return PRIMAITE_CONFIG.get("developer_mode").get("output_agent_logs")
+        return self._save_agent_logs
+
+    @save_agent_logs.setter
+    def save_agent_logs(self, save_agent_logs: bool) -> None:
+        self._save_agent_logs = save_agent_logs
+
     @property
     def write_sys_log_to_terminal(self) -> bool:
         if is_dev_mode():
@@ -91,6 +127,17 @@ class _SimOutput:
     def write_sys_log_to_terminal(self, write_sys_log_to_terminal: bool) -> None:
         self._write_sys_log_to_terminal = write_sys_log_to_terminal
 
+    # Should this be separate from sys_log?
+    @property
+    def write_agent_log_to_terminal(self) -> bool:
+        if is_dev_mode():
+            return PRIMAITE_CONFIG.get("developer_mode").get("output_to_terminal")
+        return self._write_agent_log_to_terminal
+
+    @write_agent_log_to_terminal.setter
+    def write_agent_log_to_terminal(self, write_agent_log_to_terminal: bool) -> None:
+        self._write_agent_log_to_terminal = write_agent_log_to_terminal
+
     @property
     def sys_log_level(self) -> LogLevel:
         if is_dev_mode():
@@ -101,5 +148,15 @@ class _SimOutput:
     def sys_log_level(self, sys_log_level: LogLevel) -> None:
         self._sys_log_level = sys_log_level
 
+    @property
+    def agent_log_level(self) -> LogLevel:
+        if is_dev_mode():
+            return LogLevel[PRIMAITE_CONFIG.get("developer_mode").get("agent_log_level")]
+        return self._agent_log_level
+
+    @agent_log_level.setter
+    def agent_log_level(self, agent_log_level: LogLevel) -> None:
+        self._agent_log_level = agent_log_level
+
 
 SIM_OUTPUT = _SimOutput()

src/primaite/simulator/core.py

@@ -3,9 +3,10 @@
 """Core of the PrimAITE Simulator."""
 import warnings
 from abc import abstractmethod
-from typing import Callable, Dict, List, Literal, Optional, Union
+from typing import Callable, Dict, Iterable, List, Literal, Optional, Tuple, Union
 from uuid import uuid4
 
+from prettytable import PrettyTable
 from pydantic import BaseModel, ConfigDict, Field, validate_call
 
 from primaite import getLogger
@@ -34,6 +35,20 @@ class RequestPermissionValidator(BaseModel):
         """Message that is reported when a request is rejected by this validator."""
         return "request rejected"
 
+    def __add__(self, other: "RequestPermissionValidator") -> "_CombinedValidator":
+        return _CombinedValidator(validators=[self, other])
+
+
+class _CombinedValidator(RequestPermissionValidator):
+    validators: List[RequestPermissionValidator] = []
+
+    def __call__(self, request, context) -> bool:
+        return all(x(request, context) for x in self.validators)
+
+    @property
+    def fail_message(self):
+        return f"One of the following conditions are not met: {[v.fail_message for v in self.validators]}"
+
 
 class AllowAllValidator(RequestPermissionValidator):
     """Always allows the request."""
@@ -150,8 +165,17 @@ class RequestManager(BaseModel):
 
         self.request_types.pop(name)
 
-    def get_request_types_recursively(self) -> List[List[str]]:
-        """Recursively generate request tree for this component."""
+    def get_request_types_recursively(self) -> List[RequestFormat]:
+        """
+        Recursively generate request tree for this component.
+
+        :param parent_valid: Whether this sub-request's parent request was valid. This value should not be specified by
+                             users, it is used by the recursive call.
+        :type parent_valid: bool
+        :returns: A list of tuples where the first tuple element is the request string and the second is whether that
+                  request is currently possible to execute.
+        :rtype: List[Tuple[RequestFormat, bool]]
+        """
         requests = []
         for req_name, req in self.request_types.items():
             if isinstance(req.func, RequestManager):
@@ -162,6 +186,30 @@ class RequestManager(BaseModel):
                 requests.append([req_name])
         return requests
 
+    def show(self) -> None:
+        """Display all currently available requests."""
+        table = PrettyTable(["requests"])
+        table.align = "l"
+        table.add_rows([[x] for x in self.get_request_types_recursively()])
+        print(table)
+
+    def check_valid(self, request: RequestFormat, context: Dict) -> bool:
+        """Check if this request would be valid in the current state of the simulation without invoking it."""
+
+        request_key = request[0]
+        request_options = request[1:]
+
+        if request_key not in self.request_types:
+            return False
+
+        request_type = self.request_types[request_key]
+
+        # recurse if we are not at a leaf node
+        if isinstance(request_type.func, RequestManager):
+            return request_type.func.check_valid(request_options, context)
+
+        return request_type.validator(request_options, context)
+
 
 class SimComponent(BaseModel):
     """Extension of pydantic BaseModel with additional methods that must be defined by all classes in the simulator."""

src/primaite/simulator/domain/controller.py

@@ -52,6 +52,8 @@ class GroupMembershipValidator(RequestPermissionValidator):
     def __call__(self, request: List[str], context: Dict) -> bool:
         """Permit the action if the request comes from an account which belongs to the right group."""
         # if context request source is part of any groups mentioned in self.allow_groups, return true, otherwise false
+        if not context:
+            return False
         requestor_groups: List[str] = context["request_source"]["groups"]
         for allowed_group in self.allowed_groups:
             if allowed_group.name in requestor_groups:

src/primaite/simulator/file_system/file_system.py

@@ -6,8 +6,8 @@ from typing import Any, Dict, List, Optional
 
 from prettytable import MARKDOWN, PrettyTable
 
-from primaite.interface.request import RequestResponse
-from primaite.simulator.core import RequestManager, RequestType, SimComponent
+from primaite.interface.request import RequestFormat, RequestResponse
+from primaite.simulator.core import RequestManager, RequestPermissionValidator, RequestType, SimComponent
 from primaite.simulator.file_system.file import File
 from primaite.simulator.file_system.file_type import FileType
 from primaite.simulator.file_system.folder import Folder
@@ -42,6 +42,10 @@ class FileSystem(SimComponent):
 
         More information in user guide and docstring for SimComponent._init_request_manager.
         """
+        self._folder_exists = FileSystem._FolderExistsValidator(file_system=self)
+        self._folder_not_deleted = FileSystem._FolderNotDeletedValidator(file_system=self)
+        self._file_exists = FileSystem._FileExistsValidator(file_system=self)
+
         rm = super()._init_request_manager()
 
         self._delete_manager = RequestManager()
@@ -50,13 +54,15 @@ class FileSystem(SimComponent):
             request_type=RequestType(
                 func=lambda request, context: RequestResponse.from_bool(
                     self.delete_file(folder_name=request[0], file_name=request[1])
-                )
+                ),
+                validator=self._file_exists,
             ),
         )
         self._delete_manager.add_request(
             name="folder",
             request_type=RequestType(
-                func=lambda request, context: RequestResponse.from_bool(self.delete_folder(folder_name=request[0]))
+                func=lambda request, context: RequestResponse.from_bool(self.delete_folder(folder_name=request[0])),
+                validator=self._folder_exists,
             ),
         )
         rm.add_request(
@@ -144,10 +150,13 @@ class FileSystem(SimComponent):
         )
 
         self._folder_request_manager = RequestManager()
-        rm.add_request("folder", RequestType(func=self._folder_request_manager))
+        rm.add_request(
+            "folder",
+            RequestType(func=self._folder_request_manager, validator=self._folder_exists + self._folder_not_deleted),
+        )
 
         self._file_request_manager = RequestManager()
-        rm.add_request("file", RequestType(func=self._file_request_manager))
+        rm.add_request("file", RequestType(func=self._file_request_manager, validator=self._file_exists))
 
         return rm
 
@@ -626,3 +635,62 @@ class FileSystem(SimComponent):
                 self.sys_log.error(f"Unable to access file that does not exist. (file name: {file_name})")
 
         return False
+
+    class _FolderExistsValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the Folder exists.
+
+        Actions cannot be performed on a non-existent folder.
+        """
+
+        file_system: FileSystem
+        """Save a reference to the FileSystem instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Returns True if folder exists."""
+            return self.file_system.get_folder(folder_name=request[0]) is not None
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return "Cannot perform request on folder because it does not exist."
+
+    class _FolderNotDeletedValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the Folder has not been deleted.
+
+        Actions cannot be performed on a deleted folder.
+        """
+
+        file_system: FileSystem
+        """Save a reference to the FileSystem instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Returns True if folder exists and is not deleted."""
+            # get folder
+            folder = self.file_system.get_folder(folder_name=request[0], include_deleted=True)
+            return folder is not None and not folder.deleted
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return "Cannot perform request on folder because it is deleted."
+
+    class _FileExistsValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the File exists.
+
+        Actions cannot be performed on a non-existent file.
+        """
+
+        file_system: FileSystem
+        """Save a reference to the FileSystem instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Returns True if file exists."""
+            return self.file_system.get_file(folder_name=request[0], file_name=request[1]) is not None
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return "Cannot perform request on a file that does not exist."

src/primaite/simulator/file_system/file_type.py

@@ -185,5 +185,5 @@ file_type_sizes_bytes = {
     FileType.ZIP: 1024000,
     FileType.TAR: 1024000,
     FileType.GZ: 819200,
-    FileType.DB: 15360000,
+    FileType.DB: 5_000_000,
 }

src/primaite/simulator/file_system/folder.py

@@ -6,8 +6,8 @@ from typing import Dict, Optional
 
 from prettytable import MARKDOWN, PrettyTable
 
-from primaite.interface.request import RequestResponse
-from primaite.simulator.core import RequestManager, RequestType
+from primaite.interface.request import RequestFormat, RequestResponse
+from primaite.simulator.core import RequestManager, RequestPermissionValidator, RequestType
 from primaite.simulator.file_system.file import File
 from primaite.simulator.file_system.file_system_item_abc import FileSystemItemABC, FileSystemItemHealthStatus
 
@@ -55,6 +55,9 @@ class Folder(FileSystemItemABC):
 
         More information in user guide and docstring for SimComponent._init_request_manager.
         """
+        self._file_exists = Folder._FileExistsValidator(folder=self)
+        self._file_not_deleted = Folder._FileNotDeletedValidator(folder=self)
+
         rm = super()._init_request_manager()
         rm.add_request(
             name="delete",
@@ -65,7 +68,9 @@ class Folder(FileSystemItemABC):
         self._file_request_manager = RequestManager()
         rm.add_request(
             name="file",
-            request_type=RequestType(func=self._file_request_manager),
+            request_type=RequestType(
+                func=self._file_request_manager, validator=self._file_exists + self._file_not_deleted
+            ),
         )
         return rm
 
@@ -469,3 +474,42 @@ class Folder(FileSystemItemABC):
 
         self.deleted = True
         return True
+
+    class _FileExistsValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the File exists.
+
+        Actions cannot be performed on a non-existent file.
+        """
+
+        folder: Folder
+        """Save a reference to the Folder instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Returns True if file exists."""
+            return self.folder.get_file(file_name=request[0]) is not None
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return "Cannot perform request on a file that does not exist."
+
+    class _FileNotDeletedValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the File is not deleted.
+
+        Actions cannot be performed on a deleted file.
+        """
+
+        folder: Folder
+        """Save a reference to the Folder instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Returns True if file exists and is not deleted."""
+            file = self.folder.get_file(file_name=request[0])
+            return file is not None and not file.deleted
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return "Cannot perform request on a file that is deleted."

src/primaite/simulator/network/airspace.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
-from prettytable import PrettyTable
+from prettytable import MARKDOWN, PrettyTable
+from pydantic import BaseModel, Field
 
 from primaite import getLogger
 from primaite.simulator.network.hardware.base import Layer3Interface, NetworkInterface, WiredNetworkInterface
@@ -15,90 +16,29 @@ from primaite.simulator.system.core.packet_capture import PacketCapture
 
 _LOGGER = getLogger(__name__)
 
-__all__ = ["AirSpaceFrequency", "WirelessNetworkInterface", "IPWirelessNetworkInterface"]
 
+def format_hertz(hertz: float, format_terahertz: bool = False, decimals: int = 3) -> str:
+    """
+    Convert a frequency in Hertz to a formatted string using the most appropriate unit.
 
-class AirSpace:
-    """Represents a wireless airspace, managing wireless network interfaces and handling wireless transmission."""
+    Optionally includes formatting for Terahertz.
 
-    def __init__(self):
-        self._wireless_interfaces: Dict[str, WirelessNetworkInterface] = {}
-        self._wireless_interfaces_by_frequency: Dict[AirSpaceFrequency, List[WirelessNetworkInterface]] = {}
-
-    def show(self, frequency: Optional[AirSpaceFrequency] = None):
-        """
-        Displays a summary of wireless interfaces in the airspace, optionally filtered by a specific frequency.
-
-        :param frequency: The frequency band to filter devices by. If None, devices for all frequencies are shown.
-        """
-        table = PrettyTable()
-        table.field_names = ["Connected Node", "MAC Address", "IP Address", "Subnet Mask", "Frequency", "Status"]
-
-        # If a specific frequency is provided, filter by it; otherwise, use all frequencies.
-        frequencies_to_show = [frequency] if frequency else self._wireless_interfaces_by_frequency.keys()
-
-        for freq in frequencies_to_show:
-            interfaces = self._wireless_interfaces_by_frequency.get(freq, [])
-            for interface in interfaces:
-                status = "Enabled" if interface.enabled else "Disabled"
-                table.add_row(
-                    [
-                        interface._connected_node.hostname,  # noqa
-                        interface.mac_address,
-                        interface.ip_address if hasattr(interface, "ip_address") else None,
-                        interface.subnet_mask if hasattr(interface, "subnet_mask") else None,
-                        str(freq),
-                        status,
-                    ]
-                )
-
-        print(table)
-
-    def add_wireless_interface(self, wireless_interface: WirelessNetworkInterface):
-        """
-        Adds a wireless network interface to the airspace if it's not already present.
-
-        :param wireless_interface: The wireless network interface to be added.
-        """
-        if wireless_interface.mac_address not in self._wireless_interfaces:
-            self._wireless_interfaces[wireless_interface.mac_address] = wireless_interface
-            if wireless_interface.frequency not in self._wireless_interfaces_by_frequency:
-                self._wireless_interfaces_by_frequency[wireless_interface.frequency] = []
-            self._wireless_interfaces_by_frequency[wireless_interface.frequency].append(wireless_interface)
-
-    def remove_wireless_interface(self, wireless_interface: WirelessNetworkInterface):
-        """
-        Removes a wireless network interface from the airspace if it's present.
-
-        :param wireless_interface: The wireless network interface to be removed.
-        """
-        if wireless_interface.mac_address in self._wireless_interfaces:
-            self._wireless_interfaces.pop(wireless_interface.mac_address)
-            self._wireless_interfaces_by_frequency[wireless_interface.frequency].remove(wireless_interface)
-
-    def clear(self):
-        """
-        Clears all wireless network interfaces and their frequency associations from the airspace.
-
-        After calling this method, the airspace will contain no wireless network interfaces, and transmissions cannot
-        occur until new interfaces are added again.
-        """
-        self._wireless_interfaces.clear()
-        self._wireless_interfaces_by_frequency.clear()
-
-    def transmit(self, frame: Frame, sender_network_interface: WirelessNetworkInterface):
-        """
-        Transmits a frame to all enabled wireless network interfaces on a specific frequency within the airspace.
-
-        This ensures that a wireless interface does not receive its own transmission.
-
-        :param frame: The frame to be transmitted.
-        :param sender_network_interface: The wireless network interface sending the frame. This interface will be
-            excluded from the list of receivers to prevent it from receiving its own transmission.
-        """
-        for wireless_interface in self._wireless_interfaces_by_frequency.get(sender_network_interface.frequency, []):
-            if wireless_interface != sender_network_interface and wireless_interface.enabled:
-                wireless_interface.receive_frame(frame)
+    :param hertz: Frequency in Hertz.
+    :param format_terahertz: Whether to format frequency in Terahertz, default is False.
+    :param decimals: Number of decimal places to round to, default is 3.
+    :returns: Formatted string with the frequency in the most suitable unit.
+    """
+    format_str = f"{{:.{decimals}f}}"
+    if format_terahertz and hertz >= 1e12:  # Terahertz
+        return format_str.format(hertz / 1e12) + " THz"
+    elif hertz >= 1e9:  # Gigahertz
+        return format_str.format(hertz / 1e9) + " GHz"
+    elif hertz >= 1e6:  # Megahertz
+        return format_str.format(hertz / 1e6) + " MHz"
+    elif hertz >= 1e3:  # Kilohertz
+        return format_str.format(hertz / 1e3) + " kHz"
+    else:  # Hertz
+        return format_str.format(hertz) + " Hz"
 
 
 class AirSpaceFrequency(Enum):
@@ -110,12 +50,231 @@ class AirSpaceFrequency(Enum):
     """WiFi 5 GHz. Known for its higher data transmission speeds and reduced interference from other devices."""
 
     def __str__(self) -> str:
+        hertz_str = format_hertz(hertz=self.value)
         if self == AirSpaceFrequency.WIFI_2_4:
-            return "WiFi 2.4 GHz"
-        elif self == AirSpaceFrequency.WIFI_5:
-            return "WiFi 5 GHz"
-        else:
-            return "Unknown Frequency"
+            return f"WiFi {hertz_str}"
+        if self == AirSpaceFrequency.WIFI_5:
+            return f"WiFi {hertz_str}"
+        return "Unknown Frequency"
+
+    @property
+    def maximum_data_rate_bps(self) -> float:
+        """
+        Retrieves the maximum data transmission rate in bits per second (bps) for the frequency.
+
+        The maximum rates are predefined for known frequencies:
+            - For WIFI_2_4, it returns 100,000,000 bps (100 Mbps).
+            - For WIFI_5, it returns 500,000,000 bps (500 Mbps).
+
+        :return: The maximum data rate in bits per second. If the frequency is not recognized, returns 0.0.
+        """
+        if self == AirSpaceFrequency.WIFI_2_4:
+            return 100_000_000.0  # 100 Megabits per second
+        if self == AirSpaceFrequency.WIFI_5:
+            return 500_000_000.0  # 500 Megabits per second
+        return 0.0
+
+    @property
+    def maximum_data_rate_mbps(self) -> float:
+        """
+        Retrieves the maximum data transmission rate in megabits per second (Mbps).
+
+        This is derived by converting the maximum data rate from bits per second, as defined
+        in `maximum_data_rate_bps`, to megabits per second.
+
+        :return: The maximum data rate in megabits per second.
+        """
+        return self.maximum_data_rate_bps / 1_000_000.0
+
+
+class AirSpace(BaseModel):
+    """
+    Represents a wireless airspace, managing wireless network interfaces and handling wireless transmission.
+
+    This class provides functionalities to manage a collection of wireless network interfaces, each associated with
+    specific frequencies. It includes methods to add and remove wireless interfaces, and handle data transmission
+    across these interfaces.
+    """
+
+    wireless_interfaces: Dict[str, WirelessNetworkInterface] = Field(default_factory=lambda: {})
+    wireless_interfaces_by_frequency: Dict[AirSpaceFrequency, List[WirelessNetworkInterface]] = Field(
+        default_factory=lambda: {}
+    )
+    bandwidth_load: Dict[AirSpaceFrequency, float] = Field(default_factory=lambda: {})
+    frequency_max_capacity_mbps_: Dict[AirSpaceFrequency, float] = Field(default_factory=lambda: {})
+
+    def get_frequency_max_capacity_mbps(self, frequency: AirSpaceFrequency) -> float:
+        """
+        Retrieves the maximum data transmission capacity for a specified frequency.
+
+        This method checks a dictionary holding custom maximum capacities. If the frequency is found, it returns the
+        custom set maximum capacity. If the frequency is not found in the dictionary, it defaults to the standard
+        maximum data rate associated with that frequency.
+
+        :param frequency: The frequency for which the maximum capacity is queried.
+
+        :return: The maximum capacity in Mbps for the specified frequency.
+        """
+        if frequency in self.frequency_max_capacity_mbps_:
+            return self.frequency_max_capacity_mbps_[frequency]
+        return frequency.maximum_data_rate_mbps
+
+    def set_frequency_max_capacity_mbps(self, cfg: Dict[AirSpaceFrequency, float]):
+        """
+        Sets custom maximum data transmission capacities for multiple frequencies.
+
+        :param cfg: A dictionary mapping frequencies to their new maximum capacities in Mbps.
+        """
+        self.frequency_max_capacity_mbps_ = cfg
+        for freq, mbps in cfg.items():
+            print(f"Overriding {freq} max capacity as {mbps:.3f} mbps")
+
+    def show_bandwidth_load(self, markdown: bool = False):
+        """
+        Prints a table of the current bandwidth load for each frequency on the airspace.
+
+        This method prints a tabulated view showing the utilisation of available bandwidth capacities for all
+        frequencies. The table includes the current capacity usage as a percentage of the maximum capacity, alongside
+        the absolute maximum capacity values in Mbps.
+
+        :param markdown: Flag indicating if output should be in markdown format.
+        """
+        headers = ["Frequency", "Current Capacity (%)", "Maximum Capacity (Mbit)"]
+        table = PrettyTable(headers)
+        if markdown:
+            table.set_style(MARKDOWN)
+        table.align = "l"
+        table.title = "Airspace Frequency Channel Loads"
+        for frequency, load in self.bandwidth_load.items():
+            maximum_capacity = self.get_frequency_max_capacity_mbps(frequency)
+            load_percent = load / maximum_capacity if maximum_capacity > 0 else 0.0
+            if load_percent > 1.0:
+                load_percent = 1.0
+            table.add_row([format_hertz(frequency.value), f"{load_percent:.0%}", f"{maximum_capacity:.3f}"])
+        print(table)
+
+    def show_wireless_interfaces(self, markdown: bool = False):
+        """
+        Prints a table of wireless interfaces in the airspace.
+
+        :param markdown: Flag indicating if output should be in markdown format.
+        """
+        headers = [
+            "Connected Node",
+            "MAC Address",
+            "IP Address",
+            "Subnet Mask",
+            "Frequency",
+            "Speed (Mbps)",
+            "Status",
+        ]
+        table = PrettyTable(headers)
+        if markdown:
+            table.set_style(MARKDOWN)
+        table.align = "l"
+        table.title = "Devices on Air Space"
+
+        for interface in self.wireless_interfaces.values():
+            status = "Enabled" if interface.enabled else "Disabled"
+            table.add_row(
+                [
+                    interface._connected_node.hostname,  # noqa
+                    interface.mac_address,
+                    interface.ip_address if hasattr(interface, "ip_address") else None,
+                    interface.subnet_mask if hasattr(interface, "subnet_mask") else None,
+                    format_hertz(interface.frequency.value),
+                    f"{interface.speed:.3f}",
+                    status,
+                ]
+            )
+        print(table.get_string(sortby="Frequency"))
+
+    def show(self, markdown: bool = False):
+        """
+        Prints a summary of the current state of the airspace, including both wireless interfaces and bandwidth loads.
+
+        This method is a convenient wrapper that calls two separate methods to display detailed tables: one for
+        wireless interfaces and another for bandwidth load across all frequencies managed within the airspace. It
+        provides a holistic view of the operational status and performance metrics of the airspace.
+
+        :param markdown: Flag indicating if output should be in markdown format.
+        """
+        self.show_wireless_interfaces(markdown)
+        self.show_bandwidth_load(markdown)
+
+    def add_wireless_interface(self, wireless_interface: WirelessNetworkInterface):
+        """
+        Adds a wireless network interface to the airspace if it's not already present.
+
+        :param wireless_interface: The wireless network interface to be added.
+        """
+        if wireless_interface.mac_address not in self.wireless_interfaces:
+            self.wireless_interfaces[wireless_interface.mac_address] = wireless_interface
+            if wireless_interface.frequency not in self.wireless_interfaces_by_frequency:
+                self.wireless_interfaces_by_frequency[wireless_interface.frequency] = []
+            self.wireless_interfaces_by_frequency[wireless_interface.frequency].append(wireless_interface)
+
+    def remove_wireless_interface(self, wireless_interface: WirelessNetworkInterface):
+        """
+        Removes a wireless network interface from the airspace if it's present.
+
+        :param wireless_interface: The wireless network interface to be removed.
+        """
+        if wireless_interface.mac_address in self.wireless_interfaces:
+            self.wireless_interfaces.pop(wireless_interface.mac_address)
+            self.wireless_interfaces_by_frequency[wireless_interface.frequency].remove(wireless_interface)
+
+    def clear(self):
+        """
+        Clears all wireless network interfaces and their frequency associations from the airspace.
+
+        After calling this method, the airspace will contain no wireless network interfaces, and transmissions cannot
+        occur until new interfaces are added again.
+        """
+        self.wireless_interfaces.clear()
+        self.wireless_interfaces_by_frequency.clear()
+
+    def reset_bandwidth_load(self):
+        """
+        Resets the bandwidth load tracking for all frequencies in the airspace.
+
+        This method clears the current load metrics for all operating frequencies, effectively setting the load to zero.
+        """
+        self.bandwidth_load = {}
+
+    def can_transmit_frame(self, frame: Frame, sender_network_interface: WirelessNetworkInterface) -> bool:
+        """
+        Determines if a frame can be transmitted by the sender network interface based on the current bandwidth load.
+
+        This method checks if adding the size of the frame to the current bandwidth load of the frequency used by the
+        sender network interface would exceed the maximum allowed bandwidth for that frequency. It returns True if the
+        frame can be transmitted without exceeding the limit, and False otherwise.
+
+        :param frame: The frame to be transmitted, used to check its size against the frequency's bandwidth limit.
+        :param sender_network_interface: The network interface attempting to transmit the frame, used to determine the
+             relevant frequency and its current bandwidth load.
+        :return: True if the frame can be transmitted within the bandwidth limit, False if it would exceed the limit.
+        """
+        if sender_network_interface.frequency not in self.bandwidth_load:
+            self.bandwidth_load[sender_network_interface.frequency] = 0.0
+        return self.bandwidth_load[
+            sender_network_interface.frequency
+        ] + frame.size_Mbits <= self.get_frequency_max_capacity_mbps(sender_network_interface.frequency)
+
+    def transmit(self, frame: Frame, sender_network_interface: WirelessNetworkInterface):
+        """
+        Transmits a frame to all enabled wireless network interfaces on a specific frequency within the airspace.
+
+        This ensures that a wireless interface does not receive its own transmission.
+
+        :param frame: The frame to be transmitted.
+        :param sender_network_interface: The wireless network interface sending the frame. This interface will be
+            excluded from the list of receivers to prevent it from receiving its own transmission.
+        """
+        self.bandwidth_load[sender_network_interface.frequency] += frame.size_Mbits
+        for wireless_interface in self.wireless_interfaces_by_frequency.get(sender_network_interface.frequency, []):
+            if wireless_interface != sender_network_interface and wireless_interface.enabled:
+                wireless_interface.receive_frame(frame)
 
 
 class WirelessNetworkInterface(NetworkInterface, ABC):
@@ -185,13 +344,18 @@ class WirelessNetworkInterface(NetworkInterface, ABC):
         :param frame: The network frame to be sent.
         :return: True if the frame is sent successfully, False if the network interface is disabled.
         """
-        if self.enabled:
-            frame.set_sent_timestamp()
-            self.pcap.capture_outbound(frame)
-            self.airspace.transmit(frame, self)
-            return True
-        # Cannot send Frame as the network interface is not enabled
-        return False
+        if not self.enabled:
+            return False
+        if not self.airspace.can_transmit_frame(frame, self):
+            # Drop frame for now. Queuing will happen here (probably) if it's done in the future.
+            self._connected_node.sys_log.info(f"{self}: Frame dropped as Link is at capacity")
+            return False
+
+        super().send_frame(frame)
+        frame.set_sent_timestamp()
+        self.pcap.capture_outbound(frame)
+        self.airspace.transmit(frame, self)
+        return True
 
     def receive_frame(self, frame: Frame) -> bool:
         """

src/primaite/simulator/network/container.py

@@ -96,6 +96,8 @@ class Network(SimComponent):
         """Apply pre-timestep logic."""
         super().pre_timestep(timestep)
 
+        self.airspace.reset_bandwidth_load()
+
         for node in self.nodes.values():
             node.pre_timestep(timestep)
 

src/primaite/simulator/network/hardware/base.py

@@ -78,7 +78,7 @@ class NetworkInterface(SimComponent, ABC):
     mac_address: str = Field(default_factory=generate_mac_address)
     "The MAC address of the interface."
 
-    speed: int = 100
+    speed: float = 100.0
     "The speed of the interface in Mbps. Default is 100 Mbps."
 
     mtu: int = 1500
@@ -124,10 +124,25 @@ class NetworkInterface(SimComponent, ABC):
 
         More information in user guide and docstring for SimComponent._init_request_manager.
         """
+        _is_network_interface_enabled = NetworkInterface._EnabledValidator(network_interface=self)
+        _is_network_interface_disabled = NetworkInterface._DisabledValidator(network_interface=self)
+
         rm = super()._init_request_manager()
 
-        rm.add_request("enable", RequestType(func=lambda request, context: RequestResponse.from_bool(self.enable())))
-        rm.add_request("disable", RequestType(func=lambda request, context: RequestResponse.from_bool(self.disable())))
+        rm.add_request(
+            "enable",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.enable()),
+                validator=_is_network_interface_disabled,
+            ),
+        )
+        rm.add_request(
+            "disable",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.disable()),
+                validator=_is_network_interface_enabled,
+            ),
+        )
 
         return rm
 
@@ -326,6 +341,50 @@ class NetworkInterface(SimComponent, ABC):
         super().pre_timestep(timestep)
         self.traffic = {}
 
+    class _EnabledValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the NetworkInterface is enabled.
+
+        This is useful because most actions should be being resolved if the NetworkInterface is disabled.
+        """
+
+        network_interface: NetworkInterface
+        """Save a reference to the node instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Return whether the NetworkInterface is enabled or not."""
+            return self.network_interface.enabled
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return (
+                f"Cannot perform request on NetworkInterface "
+                f"'{self.network_interface.mac_address}' because it is not enabled."
+            )
+
+    class _DisabledValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the NetworkInterface is disabled.
+
+        This is useful because some actions should be being resolved if the NetworkInterface is disabled.
+        """
+
+        network_interface: NetworkInterface
+        """Save a reference to the node instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Return whether the NetworkInterface is disabled or not."""
+            return not self.network_interface.enabled
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return (
+                f"Cannot perform request on NetworkInterface "
+                f"'{self.network_interface.mac_address}' because it is not disabled."
+            )
+
 
 class WiredNetworkInterface(NetworkInterface, ABC):
     """
@@ -434,14 +493,17 @@ class WiredNetworkInterface(NetworkInterface, ABC):
         :param frame: The network frame to be sent.
         :return: True if the frame is sent, False if the Network Interface is disabled or not connected to a link.
         """
+        if not self.enabled:
+            return False
+        if not self._connected_link.can_transmit_frame(frame):
+            # Drop frame for now. Queuing will happen here (probably) if it's done in the future.
+            self._connected_node.sys_log.info(f"{self}: Frame dropped as Link is at capacity")
+            return False
         super().send_frame(frame)
-        if self.enabled:
-            frame.set_sent_timestamp()
-            self.pcap.capture_outbound(frame)
-            self._connected_link.transmit_frame(sender_nic=self, frame=frame)
-            return True
-        # Cannot send Frame as the NIC is not enabled
-        return False
+        frame.set_sent_timestamp()
+        self.pcap.capture_outbound(frame)
+        self._connected_link.transmit_frame(sender_nic=self, frame=frame)
+        return True
 
     @abstractmethod
     def receive_frame(self, frame: Frame) -> bool:
@@ -672,12 +734,21 @@ class Link(SimComponent):
         """
         return self.endpoint_a.enabled and self.endpoint_b.enabled
 
-    def _can_transmit(self, frame: Frame) -> bool:
+    def can_transmit_frame(self, frame: Frame) -> bool:
+        """
+        Determines whether a frame can be transmitted considering the current Link load and the Link's bandwidth.
+
+        This method assesses if the transmission of a given frame is possible without exceeding the Link's total
+        bandwidth capacity. It checks if the current load of the Link plus the size of the frame (expressed in Mbps)
+        would remain within the defined bandwidth limits. The transmission is only feasible if the Link is active
+        ('up') and the total load including the new frame does not surpass the bandwidth limit.
+
+        :param frame: The frame intended for transmission, which contains its size in Mbps.
+        :return: True if the frame can be transmitted without exceeding the bandwidth limit, False otherwise.
+        """
         if self.is_up:
             frame_size_Mbits = frame.size_Mbits  # noqa - Leaving it as Mbits as this is how they're expressed
-            # return self.current_load + frame_size_Mbits <= self.bandwidth
-            # TODO: re add this check once packet size limiting and MTU checks are implemented
-            return True
+            return self.current_load + frame.size_Mbits <= self.bandwidth
         return False
 
     def transmit_frame(self, sender_nic: WiredNetworkInterface, frame: Frame) -> bool:
@@ -688,11 +759,6 @@ class Link(SimComponent):
         :param frame: The network frame to be sent.
         :return: True if the Frame can be sent, otherwise False.
         """
-        can_transmit = self._can_transmit(frame)
-        if not can_transmit:
-            _LOGGER.debug(f"Cannot transmit frame as {self} is at capacity")
-            return False
-
         receiver = self.endpoint_a
         if receiver == sender_nic:
             receiver = self.endpoint_b
@@ -872,6 +938,25 @@ class Node(SimComponent):
             """Message that is reported when a request is rejected by this validator."""
             return f"Cannot perform request on node '{self.node.hostname}' because it is not turned on."
 
+    class _NodeIsOffValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the node is off.
+
+        This is useful because some actions require the node to be in an off state.
+        """
+
+        node: Node
+        """Save a reference to the node instance."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Return whether the node is on or off."""
+            return self.node.operating_state == NodeOperatingState.OFF
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return f"Cannot perform request on node '{self.node.hostname}' because it is not turned off."
+
     def _init_request_manager(self) -> RequestManager:
         """
         Initialise the request manager.
@@ -934,6 +1019,7 @@ class Node(SimComponent):
                 return RequestResponse.from_bool(False)
 
         _node_is_on = Node._NodeIsOnValidator(node=self)
+        _node_is_off = Node._NodeIsOffValidator(node=self)
 
         rm = super()._init_request_manager()
         # since there are potentially many services, create an request manager that can map service name
@@ -963,7 +1049,12 @@ class Node(SimComponent):
                 func=lambda request, context: RequestResponse.from_bool(self.power_off()), validator=_node_is_on
             ),
         )
-        rm.add_request("startup", RequestType(func=lambda request, context: RequestResponse.from_bool(self.power_on())))
+        rm.add_request(
+            "startup",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.power_on()), validator=_node_is_off
+            ),
+        )
         rm.add_request(
             "reset",
             RequestType(func=lambda request, context: RequestResponse.from_bool(self.reset()), validator=_node_is_on),

src/primaite/simulator/network/hardware/nodes/network/switch.py

@@ -58,12 +58,16 @@ class SwitchPort(WiredNetworkInterface):
         :param frame: The network frame to be sent.
         :return: A boolean indicating whether the frame was successfully sent.
         """
-        if self.enabled:
-            self.pcap.capture_outbound(frame)
-            self._connected_link.transmit_frame(sender_nic=self, frame=frame)
-            return True
-        # Cannot send Frame as the SwitchPort is not enabled
-        return False
+        if not self.enabled:
+            return False
+        if not self._connected_link.can_transmit_frame(frame):
+            # Drop frame for now. Queuing will happen here (probably) if it's done in the future.
+            self._connected_node.sys_log.info(f"{self}: Frame dropped as Link is at capacity")
+            return False
+
+        self.pcap.capture_outbound(frame)
+        self._connected_link.transmit_frame(sender_nic=self, frame=frame)
+        return True
 
     def receive_frame(self, frame: Frame) -> bool:
         """

src/primaite/simulator/network/hardware/nodes/network/wireless_router.py

@@ -1,6 +1,6 @@
 # © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
 from ipaddress import IPv4Address
-from typing import Any, Dict, Union
+from typing import Any, Dict, Optional, Union
 
 from pydantic import validate_call
 
@@ -153,7 +153,7 @@ class WirelessRouter(Router):
         self,
         ip_address: IPV4Address,
         subnet_mask: IPV4Address,
-        frequency: AirSpaceFrequency = AirSpaceFrequency.WIFI_2_4,
+        frequency: Optional[AirSpaceFrequency] = AirSpaceFrequency.WIFI_2_4,
     ):
         """
         Configures a wireless access point (WAP).
@@ -170,13 +170,20 @@ class WirelessRouter(Router):
             enum. This determines the frequency band (e.g., 2.4 GHz or 5 GHz) the access point will use for wireless
             communication. Default is AirSpaceFrequency.WIFI_2_4.
         """
+        if not frequency:
+            frequency = AirSpaceFrequency.WIFI_2_4
+        self.sys_log.info("Configuring wireless access point")
+
         self.wireless_access_point.disable()  # Temporarily disable the WAP for reconfiguration
+
         network_interface = self.network_interface[1]
+
         network_interface.ip_address = ip_address
         network_interface.subnet_mask = subnet_mask
-        self.sys_log.info(f"Configured WAP {network_interface}")
+
         self.wireless_access_point.frequency = frequency  # Set operating frequency
         self.wireless_access_point.enable()  # Re-enable the WAP with new settings
+        self.sys_log.info(f"Configured WAP {network_interface}")
 
     @property
     def router_interface(self) -> RouterInterface:

src/primaite/simulator/network/transmission/data_link_layer.py

@@ -133,10 +133,11 @@ class Frame(BaseModel):
     def size(self) -> float:  # noqa - Keep it as MBits as this is how they're expressed
         """The size of the Frame in Bytes."""
         # get the payload size if it is a data packet
+        payload_size = 0.0
         if isinstance(self.payload, DataPacket):
-            return self.payload.get_packet_size()
+            payload_size = self.payload.get_packet_size()
 
-        return float(len(self.model_dump_json().encode("utf-8")))
+        return float(len(self.model_dump_json().encode("utf-8"))) + payload_size
 
     @property
     def size_Mbits(self) -> float:  # noqa - Keep it as MBits as this is how they're expressed

src/primaite/simulator/system/applications/application.py

@@ -1,10 +1,12 @@
 # © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+from __future__ import annotations
+
 from abc import abstractmethod
 from enum import Enum
 from typing import Any, ClassVar, Dict, Optional, Set, Type
 
-from primaite.interface.request import RequestResponse
-from primaite.simulator.core import RequestManager, RequestType
+from primaite.interface.request import RequestFormat, RequestResponse
+from primaite.simulator.core import RequestManager, RequestPermissionValidator, RequestType
 from primaite.simulator.system.software import IOSoftware, SoftwareHealthState
 
 
@@ -64,9 +66,27 @@ class Application(IOSoftware):
 
         More information in user guide and docstring for SimComponent._init_request_manager.
         """
-        rm = super()._init_request_manager()
+        _is_application_running = Application._StateValidator(application=self, state=ApplicationOperatingState.RUNNING)
 
-        rm.add_request("close", RequestType(func=lambda request, context: RequestResponse.from_bool(self.close())))
+        rm = super()._init_request_manager()
+        rm.add_request(
+            "scan",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.scan()), validator=_is_application_running
+            ),
+        )
+        rm.add_request(
+            "close",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.close()), validator=_is_application_running
+            ),
+        )
+        rm.add_request(
+            "fix",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.fix()), validator=_is_application_running
+            ),
+        )
         return rm
 
     @abstractmethod
@@ -169,3 +189,28 @@ class Application(IOSoftware):
         :return: True if successful, False otherwise.
         """
         return super().receive(payload=payload, session_id=session_id, **kwargs)
+
+    class _StateValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the application is in the correct state.
+
+        This is useful because most actions require the application to be in a specific state.
+        """
+
+        application: Application
+        """Save a reference to the application instance."""
+
+        state: ApplicationOperatingState
+        """The state of the application to validate."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Return whether the application is in the state we are validating for."""
+            return self.application.operating_state == self.state
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return (
+                f"Cannot perform request on application '{self.application.name}' because it is not in the "
+                f"{self.state.name} state."
+            )

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

@@ -1,11 +1,13 @@
 # © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+from __future__ import annotations
+
 from abc import abstractmethod
 from enum import Enum
 from typing import Any, Dict, Optional
 
 from primaite import getLogger
-from primaite.interface.request import RequestResponse
-from primaite.simulator.core import RequestManager, RequestType
+from primaite.interface.request import RequestFormat, RequestResponse
+from primaite.simulator.core import RequestManager, RequestPermissionValidator, RequestType
 from primaite.simulator.system.software import IOSoftware, SoftwareHealthState
 
 _LOGGER = getLogger(__name__)
@@ -40,6 +42,7 @@ class Service(IOSoftware):
 
     restart_duration: int = 5
     "How many timesteps does it take to restart this service."
+
     restart_countdown: Optional[int] = None
     "If currently restarting, how many timesteps remain until the restart is finished."
 
@@ -86,15 +89,61 @@ class Service(IOSoftware):
 
         More information in user guide and docstring for SimComponent._init_request_manager.
         """
+        _is_service_running = Service._StateValidator(service=self, state=ServiceOperatingState.RUNNING)
+        _is_service_stopped = Service._StateValidator(service=self, state=ServiceOperatingState.STOPPED)
+        _is_service_paused = Service._StateValidator(service=self, state=ServiceOperatingState.PAUSED)
+        _is_service_disabled = Service._StateValidator(service=self, state=ServiceOperatingState.DISABLED)
+
         rm = super()._init_request_manager()
-        rm.add_request("scan", RequestType(func=lambda request, context: RequestResponse.from_bool(self.scan())))
-        rm.add_request("stop", RequestType(func=lambda request, context: RequestResponse.from_bool(self.stop())))
-        rm.add_request("start", RequestType(func=lambda request, context: RequestResponse.from_bool(self.start())))
-        rm.add_request("pause", RequestType(func=lambda request, context: RequestResponse.from_bool(self.pause())))
-        rm.add_request("resume", RequestType(func=lambda request, context: RequestResponse.from_bool(self.resume())))
-        rm.add_request("restart", RequestType(func=lambda request, context: RequestResponse.from_bool(self.restart())))
+        rm.add_request(
+            "scan",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.scan()), validator=_is_service_running
+            ),
+        )
+        rm.add_request(
+            "stop",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.stop()), validator=_is_service_running
+            ),
+        )
+        rm.add_request(
+            "start",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.start()), validator=_is_service_stopped
+            ),
+        )
+        rm.add_request(
+            "pause",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.pause()), validator=_is_service_running
+            ),
+        )
+        rm.add_request(
+            "resume",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.resume()), validator=_is_service_paused
+            ),
+        )
+        rm.add_request(
+            "restart",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.restart()), validator=_is_service_running
+            ),
+        )
         rm.add_request("disable", RequestType(func=lambda request, context: RequestResponse.from_bool(self.disable())))
-        rm.add_request("enable", RequestType(func=lambda request, context: RequestResponse.from_bool(self.enable())))
+        rm.add_request(
+            "enable",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.enable()), validator=_is_service_disabled
+            ),
+        )
+        rm.add_request(
+            "fix",
+            RequestType(
+                func=lambda request, context: RequestResponse.from_bool(self.fix()), validator=_is_service_running
+            ),
+        )
         return rm
 
     @abstractmethod
@@ -191,3 +240,28 @@ class Service(IOSoftware):
                 self.sys_log.debug(f"Restarting finished for service {self.name}")
                 self.operating_state = ServiceOperatingState.RUNNING
             self.restart_countdown -= 1
+
+    class _StateValidator(RequestPermissionValidator):
+        """
+        When requests come in, this validator will only let them through if the service is in the correct state.
+
+        This is useful because most actions require the service to be in a specific state.
+        """
+
+        service: Service
+        """Save a reference to the service instance."""
+
+        state: ServiceOperatingState
+        """The state of the service to validate."""
+
+        def __call__(self, request: RequestFormat, context: Dict) -> bool:
+            """Return whether the service is in the state we are validating for."""
+            return self.service.operating_state == self.state
+
+        @property
+        def fail_message(self) -> str:
+            """Message that is reported when a request is rejected by this validator."""
+            return (
+                f"Cannot perform request on service '{self.service.name}' because it is not in the "
+                f"{self.state.name} state."
+            )