feat/service_status/ab#2950

iso15118/secc/comm_session_handler.py

@@ -16,7 +16,10 @@
 from asyncio.streams import StreamReader, StreamWriter
 from typing import Dict, List, Optional, Tuple, Union
 
-from iso15118.secc.controller.interface import EVSEControllerInterface
+from iso15118.secc.controller.interface import (
+    EVSEControllerInterface,
+    EVSEServiceStatus,
+)
 from iso15118.secc.failed_responses import (
     init_failed_responses_din_spec_70121,
     init_failed_responses_iso_v2,
@@ -168,6 +171,9 @@ def __init__(
         self.config = config
         self.evse_controller = evse_controller
 
+        # List of server status events
+        self.status_event_list: List[asyncio.Event] = []
+
         # Set the selected EXI codec implementation
         EXI().set_exi_codec(codec)
 
@@ -189,21 +195,47 @@ async def __init__.
         """
 
         self.udp_server = UDPServer(self._rcv_queue, self.config.iface)
+        self.status_event_list.append(self.udp_server.ready_event)
+
         self.tcp_server = TCPServer(self._rcv_queue, self.config.iface)
+        self.status_event_list.append(self.tcp_server.tls_ready_event)
 
         self.list_of_tasks = [
             self.get_from_rcv_queue(self._rcv_queue),
             self.udp_server.start(),
             self.tcp_server.start_tls(),
+            self.check_status_task(),
         ]
 
         if not self.config.enforce_tls:
             self.list_of_tasks.append(self.tcp_server.start_no_tls())
+            self.status_event_list.append(self.tcp_server.tcp_ready_event)
 
         logger.info("Communication session handler started")
 
         await wait_for_tasks(self.list_of_tasks)
 
+    def check_events(self) -> bool:
+        result: bool = True
+        for event in self.status_event_list:
+            if event.is_set() is False:
+                result = False
+                break
+        return result
+
+    async def check_ready_status(self) -> None:
+        # Wait until all flags are set
+        while self.check_events() is False:
+            await asyncio.sleep(0.1)
+
+    async def check_status_task(self) -> None:
+        try:
+            await asyncio.wait_for(self.check_ready_status(), timeout=10)
+            await self.evse_controller.set_status(EVSEServiceStatus.READY)
+        except asyncio.TimeoutError:
+            logger.error("Timeout: Servers failed to startup")
+            await self.evse_controller.set_status(EVSEServiceStatus.ERROR)
+
     async def get_from_rcv_queue(self, queue: asyncio.Queue):
         """
         Waits for an incoming message from the transport layer

iso15118/secc/controller/interface.py

@@ -4,6 +4,7 @@
 """
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from enum import Enum
 from typing import Dict, List, Optional, Union
 
 from iso15118.shared.messages.datatypes import (
@@ -72,6 +73,14 @@ class EVDataContext:
     soc: Optional[int] = None  # 0-100
 
 
+class EVSEServiceStatus(str, Enum):
+    READY = "ready"
+    STARTING = "starting"
+    STOPPING = "stopping"
+    ERROR = "error"
+    BUSY = "busy"
+
+
 @dataclass
 class EVChargeParamsLimits:
     ev_max_voltage: Optional[Union[PVEVMaxVoltageLimit, PVEVMaxVoltage]] = None
@@ -91,6 +100,13 @@ def reset_ev_data_context(self):
     # |             COMMON FUNCTIONS (FOR ALL ENERGY TRANSFER MODES)             |
     # ============================================================================
 
+    @abstractmethod
+    async def set_status(self, status: EVSEServiceStatus) -> None:
+        """
+        Sets the new status for the EVSE Controller
+        """
+        raise NotImplementedError
+
     @abstractmethod
     async def get_evse_id(self, protocol: Protocol) -> str:
         """

iso15118/secc/controller/simulator.py

@@ -15,6 +15,7 @@
     EVChargeParamsLimits,
     EVDataContext,
     EVSEControllerInterface,
+    EVSEServiceStatus,
 )
 from iso15118.shared.exceptions import EncryptionError, PrivateKeyReadError
 from iso15118.shared.exi_codec import EXI
@@ -195,6 +196,8 @@ def reset_ev_data_context(self):
     # ============================================================================
     # |             COMMON FUNCTIONS (FOR ALL ENERGY TRANSFER MODES)             |
     # ============================================================================
+    async def set_status(self, status: EVSEServiceStatus) -> None:
+        logger.debug(f"New Status: {status}")
 
     async def get_evse_id(self, protocol: Protocol) -> str:
         if protocol == Protocol.DIN_SPEC_70121:

iso15118/secc/main.py

@@ -2,6 +2,7 @@
 import logging
 
 from iso15118.secc import SECCHandler
+from iso15118.secc.controller.interface import EVSEServiceStatus
 from iso15118.secc.controller.simulator import SimEVSEController
 from iso15118.shared.exificient_exi_codec import ExificientEXICodec
 
@@ -14,6 +15,7 @@ async def main():
     the SECC (Supply Equipment Communication Controller)
     """
     sim_evse_controller = await SimEVSEController.create()
+    await sim_evse_controller.set_status(EVSEServiceStatus.STARTING)
     await SECCHandler(
         exi_codec=ExificientEXICodec(), evse_controller=sim_evse_controller
     ).start()

iso15118/secc/transport/tcp_server.py

@@ -27,6 +27,8 @@ def __init__(self, session_handler_queue: asyncio.Queue, iface: str) -> None:
         self.port_no_tls = get_tcp_port()
         self.port_tls = get_tcp_port()
         self.iface = iface
+        self.tls_ready_event: asyncio.Event = asyncio.Event()
+        self.tcp_ready_event: asyncio.Event = asyncio.Event()
 
         # Making sure the TCP and TLS port are definitely different
         while self.port_no_tls == self.port_tls:
@@ -112,6 +114,11 @@ async def server_factory(self, tls: bool) -> None:
             f"port {port}"
         )
 
+        if tls:
+            self.tls_ready_event.set()
+        else:
+            self.tcp_ready_event.set()
+
         try:
             # Shield the task so we can handle the cancellation
             # closing the opening connections

iso15118/secc/transport/udp_server.py

@@ -36,6 +36,7 @@ class UDPServer(asyncio.DatagramProtocol):
     def __init__(self, session_handler_queue: asyncio.Queue, iface: str):
         self.started: bool = False
         self.iface = iface
+        self.ready_event: asyncio.Event = asyncio.Event()
         self._session_handler_queue: asyncio.Queue = session_handler_queue
         self._rcv_queue: asyncio.Queue = asyncio.Queue()
         self._transport: Optional[DatagramTransport] = None
@@ -99,6 +100,7 @@ async def start(self):
             f"{SDP_MULTICAST_GROUP}%{self.iface} "
             f"and port {SDP_SERVER_PORT}"
         )
+        self.ready_event.set()
         tasks = [self.rcv_task()]
         await wait_for_tasks(tasks)