conson-xp 1.4.0__tar.gz → 1.5.0__tar.gz

{conson_xp-1.4.0 → conson_xp-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.4.0
+Version: 1.5.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-1.4.0 → conson_xp-1.5.0}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.4.0"
+version = "1.5.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.4.0 → conson_xp-1.5.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.4.0"
+__version__ = "1.5.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.4.0 → conson_xp-1.5.0}/src/xp/services/server/base_server_service.py

@@ -5,6 +5,7 @@ containing common functionality like module type response generation.
 """
 
 import logging
+import threading
 from abc import ABC
 from typing import Optional
 
@@ -42,6 +43,9 @@ class BaseServerService(ABC):
         self.temperature: str = "+23,5§C"
         self.voltage: str = "+12,5§V"
 
+        self.telegram_buffer: list[str] = []
+        self.telegram_buffer_lock = threading.Lock()  # Lock for socket set
+
     def generate_datapoint_type_response(
         self, datapoint_type: DataPointType
     ) -> Optional[str]:
@@ -257,3 +261,28 @@ class BaseServerService(ABC):
             The response telegram string, or None if request cannot be handled.
         """
         return None
+
+    def add_telegram_buffer(self, telegram: str) -> None:
+        """Add telegram to the buffer.
+
+        Args:
+            telegram: The telegram string to add to the buffer.
+        """
+        self.logger.debug(f"Add telegram to the buffer: {telegram}")
+        with self.telegram_buffer_lock:
+            self.telegram_buffer.append(telegram)
+
+    def collect_telegram_buffer(self) -> list[str]:
+        """Collecting telegrams from the buffer.
+
+        Returns:
+            List of telegram strings from the buffer. The buffer is cleared after collection.
+        """
+        self.logger.debug(
+            f"Collecting {self.serial_number} telegrams from buffer: {len(self.telegram_buffer)}"
+        )
+        with self.telegram_buffer_lock:
+            result = self.telegram_buffer.copy()
+            self.logger.debug(f"Resetting {self.serial_number} buffer")
+            self.telegram_buffer.clear()
+            return result

{conson_xp-1.4.0 → conson_xp-1.5.0}/src/xp/services/server/server_service.py

@@ -71,6 +71,13 @@ class ServerService:
             ],
         ] = {}  # serial -> device service instance
 
+        # Collect device buffer to broadcast to client
+        self.collector_thread: Optional[threading.Thread] = (
+            None  # Background thread for storm
+        )
+        self.collector_stop_event = threading.Event()  # Event to stop thread
+        self.collector_buffer: list[str] = []  # All collected buffers
+
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
@@ -167,6 +174,8 @@ class ServerService:
             self.server_socket.bind(("0.0.0.0", self.port))
             self.server_socket.listen(1)  # Accept single connection as per spec
 
+            self._start_device_collector_thread()
+
             self.is_running = True
             self.logger.info(f"Conbus emulator server started on port {self.port}")
             self.logger.info(
@@ -221,17 +230,44 @@ class ServerService:
     ) -> None:
         """Handle individual client connection."""
         try:
+
+            idle_timeout = 300
+            rcv_timeout = 10
+
             # Set timeout for idle connections (30 seconds as per spec)
-            client_socket.settimeout(300.0)
+            client_socket.settimeout(rcv_timeout)
+            timeout = idle_timeout / rcv_timeout
 
             while True:
+
+                # send waiting buffer
+                for i in range(len(self.collector_buffer)):
+                    buffer = self.collector_buffer.pop()
+                    client_socket.send(buffer.encode("latin-1"))
+                    self.logger.debug(f"Sent buffer to {client_address}")
+
                 # Receive data from client
-                data = client_socket.recv(1024)
+                self.logger.debug(f"Receiving data {client_address}")
+                data = None
+                try:
+                    data = client_socket.recv(1024)
+                except socket.timeout:
+                    self.logger.debug(
+                        f"Timeout receiving data {client_address} ({timeout})"
+                    )
+                finally:
+                    timeout -= 1
+
                 if not data:
-                    break
+                    if timeout <= 0:
+                        break
+                    continue
+
+                # reset timeout on receiving data
+                timeout = idle_timeout / rcv_timeout
 
                 message = data.decode("latin-1").strip()
-                self.logger.info(f"Received from {client_address}: {message}")
+                self.logger.debug(f"Received from {client_address}: {message}")
 
                 # Process request (discover or data request)
                 responses = self._process_request(message)
@@ -239,10 +275,10 @@ class ServerService:
                 # Send responses
                 for response in responses:
                     client_socket.send(response.encode("latin-1"))
-                    self.logger.info(f"Sent to {client_address}: {response[:-1]}")
+                    self.logger.debug(f"Sent to {client_address}: {response[:-1]}")
 
         except socket.timeout:
-            self.logger.info(f"Client {client_address} timed out")
+            self.logger.debug(f"Client {client_address} timed out")
         except Exception as e:
             self.logger.error(f"Error handling client {client_address}: {e}")
         finally:
@@ -390,3 +426,48 @@ class ServerService:
         self.logger.info(
             f"Configuration reloaded: {len(self.devices)} devices, {len(self.device_services)} services"
         )
+
+    def _start_device_collector_thread(self) -> None:
+        """Start device buffer collector thread."""
+        if self.collector_thread and self.collector_thread.is_alive():
+            self.logger.debug("Collector thread already running")
+            return
+
+        # Start background thread to send storm telegrams
+        self.collector_thread = threading.Thread(
+            target=self._device_collector_thread, daemon=True, name="DeviceCollector"
+        )
+        self.collector_thread.start()
+        self.logger.info("Collector thread started")
+
+    def _stop_device_collector_thread(self) -> None:
+        """Stop device buffer collector thread."""
+        if not self.collector_thread or not self.collector_thread.is_alive():
+            self.logger.debug("Collector thread not running")
+            return
+
+        self.logger.info(f"Stopping collector thread: {self.collector_thread.name}")
+
+        # Wait for thread to finish (with timeout)
+        if self.collector_thread and self.collector_thread.is_alive():
+            self.collector_thread.join(timeout=1.0)
+
+            self.logger.info("Collector stopped.")
+
+    def _device_collector_thread(self) -> None:
+        """Device buffer collector thread."""
+        self.logger.info("Collector thread starting")
+
+        while True:
+            self.logger.debug(
+                f"Collector thread collecting ({len(self.collector_buffer)})"
+            )
+            collected = 0
+            for device_service in self.device_services.values():
+                telegram_buffer = device_service.collect_telegram_buffer()
+                self.collector_buffer.extend(telegram_buffer)
+                collected += len(telegram_buffer)
+
+            # Wait a bit before checking again
+            self.logger.debug(f"Collector thread collected ({collected})")
+            self.collector_stop_event.wait(timeout=1)

{conson_xp-1.4.0 → conson_xp-1.5.0}/src/xp/services/server/xp33_server_service.py

@@ -5,6 +5,8 @@ including response generation and device configuration handling for
 3-channel light dimmer modules.
 """
 
+import socket
+import threading
 from typing import Dict, Optional
 
 from xp.models import ModuleTypeCode
@@ -72,6 +74,17 @@ class XP33ServerService(BaseServerService):
             4: [0, 0, 0],  # Scene 4: Off
         }
 
+        # Storm mode state (XP33 Storm Simulator)
+        self.storm_mode = False  # Track if device is in storm mode
+        self.last_response: Optional[str] = None  # Cache last response for storm replay
+        self.storm_thread: Optional[threading.Thread] = (
+            None  # Background thread for storm
+        )
+        self.storm_stop_event = threading.Event()  # Event to stop storm thread
+        self.client_sockets: set[socket.socket] = set()  # All active client sockets
+        self.client_sockets_lock = threading.Lock()  # Lock for socket set
+        self.storm_packets_sent = 0  # Counter for packets sent during storm
+
     def _handle_device_specific_action_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
@@ -160,11 +173,32 @@ class XP33ServerService(BaseServerService):
     def _handle_device_specific_data_request(
         self, request: SystemTelegram
     ) -> Optional[str]:
-        """Handle XP33-specific data requests."""
+        """Handle XP33-specific data requests with storm mode support."""
         if not request.datapoint_type:
+            # Check for D99 storm trigger (not in DataPointType enum)
+            if request.data and request.data.startswith("99"):
+                return self._trigger_storm_mode()
             return None
 
         datapoint_type = request.datapoint_type
+
+        # Storm mode handling
+        if datapoint_type == DataPointType.MODULE_ERROR_CODE:
+            if self.storm_mode:
+                # MODULE_ERROR_CODE query stops storm
+                return self._exit_storm_mode()
+            else:
+                # Normal operation - return error code 00
+                return self._build_error_code_response("00")
+
+        # If in storm mode and not MODULE_ERROR_CODE query, ignore (background thread is sending)
+        if self.storm_mode:
+            self.logger.debug(
+                f"Ignoring query during storm mode for device {self.serial_number}"
+            )
+            return None  # Background thread is sending storm telegrams
+
+        # Normal data request handling
         handler = {
             DataPointType.MODULE_OUTPUT_STATE: self._handle_read_module_output_state,
             DataPointType.MODULE_STATE: self._handle_read_module_state,
@@ -183,6 +217,9 @@ class XP33ServerService(BaseServerService):
         )
         telegram = self._build_response_telegram(data_part)
 
+        # Cache response for potential storm replay
+        self.last_response = telegram
+
         self.logger.debug(
             f"Generated {self.device_type} module type response: {telegram}"
         )
@@ -230,6 +267,157 @@ class XP33ServerService(BaseServerService):
         ]
         return ",".join(levels)
 
+    def _trigger_storm_mode(self) -> Optional[str]:
+        """Trigger storm mode via D99 query.
+
+        Starts a background thread that sends 2 packets per second.
+        If storm is already active, this is a no-op.
+
+        Returns:
+            None (no response - storm mode activated).
+        """
+        # If storm already active, just log and continue
+        if self.storm_mode and self.storm_thread and self.storm_thread.is_alive():
+            self.logger.debug(
+                f"Storm already active for device {self.serial_number}, "
+                f"sent {self.storm_packets_sent}/200 packets"
+            )
+            return None
+
+        if not self.last_response:
+            self.logger.warning(
+                f"Cannot trigger storm for device {self.serial_number}: "
+                f"no cached response"
+            )
+            return None
+
+        self.storm_mode = True
+        self.storm_packets_sent = 0
+        self.storm_stop_event.clear()
+
+        # Start background thread to send storm telegrams
+        self.storm_thread = threading.Thread(
+            target=self._storm_sender_thread,
+            daemon=True,
+            name=f"Storm-{self.serial_number}",
+        )
+        self.storm_thread.start()
+
+        self.logger.info(
+            f"Storm triggered via D99 query for device {self.serial_number}"
+        )
+        return None  # No response when entering storm mode
+
+    def _exit_storm_mode(self) -> str:
+        """Exit storm mode and return error code FE.
+
+        Stops the background storm thread and returns error code.
+
+        Returns:
+            MODULE_ERROR_CODE response with error code FE (buffer overflow).
+        """
+        self.logger.info(
+            f"MODULE_ERROR_CODE query received, stopping storm for device {self.serial_number}"
+        )
+
+        # Signal the storm thread to stop
+        self.storm_stop_event.set()
+        self.storm_mode = False
+
+        # Wait for thread to finish (with timeout)
+        if self.storm_thread and self.storm_thread.is_alive():
+            self.storm_thread.join(timeout=1.0)
+
+        self.logger.info(
+            f"Storm stopped after {self.storm_packets_sent} packets for device {self.serial_number}"
+        )
+        self.logger.info(
+            f"Storm stopped, returning to normal operation for device {self.serial_number}"
+        )
+        return self._build_error_code_response("FE")
+
+    def _storm_sender_thread(self) -> None:
+        """Background thread that sends storm telegrams continuously.
+
+        Sends 2 packets per second (500ms delay) until:
+        - 200 packets have been sent, or
+        - Storm mode is stopped via stop event
+
+        The storm persists across socket disconnections. If the client disconnects
+        and reconnects, the storm will continue on the new connection.
+        """
+        if not self.last_response:
+            self.logger.error(
+                f"Storm thread started but missing cached response for {self.serial_number}"
+            )
+            self.storm_mode = False
+            return
+
+        self.logger.info(
+            f"Storm thread started, sending 200 duplicate telegrams at 2 packets/sec for device {self.serial_number}"
+        )
+
+        # Type narrowing for mypy
+        cached_response: str = self.last_response
+        max_packets = 200
+        packets_per_second = 2
+        delay_between_packets = 1.0 / packets_per_second  # 0.5 seconds
+
+        try:
+            while (
+                self.storm_packets_sent < max_packets
+                and not self.storm_stop_event.is_set()
+            ):
+                # Wait for a valid socket (client may have disconnected and reconnected)
+                self.add_telegram_buffer(cached_response)
+                self.storm_packets_sent += 1
+                self.logger.debug(
+                    f"Storm packet {self.storm_packets_sent}/{max_packets} sent for {self.serial_number}"
+                )
+
+                # Wait before sending next packet (0.5 seconds for 2 packets/sec)
+                if self.storm_packets_sent < max_packets:
+                    self.storm_stop_event.wait(timeout=delay_between_packets)
+
+                # Log completion status
+            if self.storm_packets_sent >= max_packets:
+                self.logger.info(
+                    f"Storm completed: sent all {self.storm_packets_sent} packets for {self.serial_number}"
+                )
+            elif self.storm_stop_event.is_set():
+                self.logger.info(
+                    f"Storm stopped by error code query: sent {self.storm_packets_sent} packets for {self.serial_number}"
+                )
+
+            # Clean up storm mode
+            self.storm_mode = False
+
+        except Exception as e:
+            self.logger.error(
+                f"Unexpected error in storm thread for {self.serial_number}: {e}"
+            )
+            self.storm_mode = False
+
+    def _build_error_code_response(self, error_code: str) -> str:
+        """Build MODULE_ERROR_CODE response telegram.
+
+        Args:
+            error_code: Error code (00 = normal, FE = buffer overflow).
+
+        Returns:
+            The complete MODULE_ERROR_CODE response telegram.
+        """
+        data_part = (
+            f"R{self.serial_number}"
+            f"F02D{DataPointType.MODULE_ERROR_CODE.value}"
+            f"{error_code}"
+        )
+        telegram = self._build_response_telegram(data_part)
+        self.logger.debug(
+            f"Generated {self.device_type} error code response: {telegram}"
+        )
+        return telegram
+
     def set_channel_dimming(self, channel: int, level: int) -> bool:
         """Set individual channel dimming level.