conson-xp 0.11.21__py3-none-any.whl → 1.1.0__py3-none-any.whl

xp/services/conbus/conbus_connection_pool.py

@@ -1,148 +0,0 @@
-"""Connection pooling implementation for Conbus TCP connections.
-
-This module provides a singleton connection pool for managing TCP socket connections
-to Conbus servers with automatic lifecycle management, health checking, and reconnection.
-"""
-
-import logging
-import socket
-import threading
-import time
-from typing import Any, Optional
-
-from xp.models import ConbusClientConfig
-
-
-class ConbusSocketConnectionManager:
-    """Connection manager for TCP socket connections to Conbus servers"""
-
-    def __init__(self, cli_config: ConbusClientConfig):
-        self.config = cli_config.conbus
-        self.logger = logging.getLogger(__name__)
-
-    def create(self) -> socket.socket:
-        """Create and configure a new TCP socket connection"""
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(self.config.timeout)
-        sock.connect((self.config.ip, self.config.port))
-        self.logger.info(
-            f"Created new connection to {self.config.ip}:{self.config.port} (timeout: {self.config.timeout})"
-        )
-        return sock
-
-    def dispose(self, connection: socket.socket) -> None:
-        """Close and cleanup socket connection"""
-        try:
-            connection.close()
-            self.logger.info("Disposed socket connection")
-        except Exception as e:
-            self.logger.warning(f"Error disposing connection: {e}")
-
-    @staticmethod
-    def check_aliveness(connection: socket.socket) -> bool:
-        """Verify if connection is still alive"""
-        try:
-            # Use socket error checking rather than sending empty data
-            # to avoid potential protocol issues
-            error = connection.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
-            return error == 0
-        except (socket.error, OSError):
-            return False
-
-
-class ConbusConnectionPool:
-    """Singleton connection pool for Conbus TCP connections"""
-
-    _lock = threading.Lock()
-
-    def __init__(self, connection_manager: ConbusSocketConnectionManager) -> None:
-        if hasattr(self, "_initialized"):
-            return
-
-        self._connection_manager = connection_manager
-        self._connection: Optional[socket.socket] = None
-        self._current_connection: Optional[socket.socket] = None
-        self._connection_created_at: Optional[float] = None
-        self._lock = threading.Lock()
-        self.logger = logging.getLogger(__name__)
-
-        # Configuration
-        self.idle_timeout = 21600  # 6 hours
-        self.max_lifetime = 21600  # 6 hours
-        self._initialized = True
-
-    def _is_connection_expired(self) -> bool:
-        """Check if the current connection has expired"""
-        if self._connection_created_at is None:
-            return True
-
-        age = time.time() - self._connection_created_at
-        return age > self.max_lifetime
-
-    def _is_connection_alive(self) -> bool:
-        """Check if connection is still alive"""
-        if self._connection is None or self._connection_manager is None:
-            return False
-
-        return self._connection_manager.check_aliveness(self._connection)
-
-    def acquire_connection(self) -> socket.socket:
-        """Acquire a connection from the pool"""
-        if self._connection_manager is None:
-            raise RuntimeError("Connection pool not initialized")
-
-        with self._lock:
-            # Check if we need a new connection
-            if (
-                self._connection is None
-                or self._is_connection_expired()
-                or not self._is_connection_alive()
-            ):
-
-                # Close existing connection if any
-                if self._connection:
-                    self._connection_manager.dispose(self._connection)
-                    self._connection = None
-
-                # Create new connection
-                self._connection = self._connection_manager.create()
-                self._connection_created_at = time.time()
-                self.logger.debug("Created new connection")
-
-            self.logger.debug("Acquired connection from pool")
-            return self._connection
-
-    # noinspection PyUnusedLocal
-    def release_connection(self, connection: socket.socket) -> None:
-        """Release a connection back to the pool (no-op for single connection pool)"""
-        self.logger.debug("Released connection back to pool")
-        # For single connection pool, we just log but don't actually close the connection
-
-    def __enter__(self) -> socket.socket:
-        """Context manager entry - acquire connection"""
-        self._current_connection = self.acquire_connection()
-        return self._current_connection
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        """Context manager exit - release connection"""
-        if hasattr(self, "_current_connection") and self._current_connection:
-            self.release_connection(self._current_connection)
-            self._current_connection = None
-
-    def close(self) -> None:
-        """Close the connection pool and cleanup resources"""
-        with self._lock:
-            if self._connection and self._connection_manager is not None:
-                try:
-                    self._connection_manager.dispose(self._connection)
-                    self.logger.info("Connection pool closed")
-                except Exception as e:
-                    self.logger.error(f"Error closing connection pool: {e}")
-                finally:
-                    self._connection = None
-                    self._connection_created_at = None

xp/services/conbus/conbus_linknumber_service.py

@@ -1,197 +0,0 @@
-"""Conbus Link Number Service for setting module link numbers.
-
-This service handles setting link numbers for modules through Conbus telegrams.
-"""
-
-import logging
-from typing import Any, Optional
-
-from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
-from xp.models.telegram.datapoint_type import DataPointType
-from xp.models.telegram.reply_telegram import ReplyTelegram
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-from xp.services.conbus.conbus_service import ConbusService
-from xp.services.telegram.telegram_link_number_service import (
-    LinkNumberError,
-    LinkNumberService,
-)
-from xp.services.telegram.telegram_service import TelegramService
-
-
-class ConbusLinknumberService:
-    """
-    Service for setting and getting module link numbers via Conbus telegrams.
-
-    Handles link number assignment by sending F04D04 telegrams and processing
-    ACK/NAK responses from modules. Also handles link number reading using
-    datapoint queries.
-    """
-
-    def __init__(
-        self,
-        conbus_service: ConbusService,
-        datapoint_service: ConbusDatapointService,
-        link_number_service: LinkNumberService,
-        telegram_service: TelegramService,
-    ):
-        """Initialize the Conbus link number service"""
-
-        # Service dependencies
-        self.conbus_service = conbus_service
-        self.datapoint_service = datapoint_service
-        self.link_number_service = link_number_service
-        self.telegram_service = telegram_service
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-    def __enter__(self) -> "ConbusLinknumberService":
-        return self
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        # Cleanup logic if needed
-        pass
-
-    def set_linknumber(
-        self, serial_number: str, link_number: int
-    ) -> ConbusLinknumberResponse:
-        """
-        Set the link number for a specific module.
-
-        Args:
-            serial_number: 10-digit module serial number
-            link_number: Link number to set (0-99)
-
-        Returns:
-            ConbusLinknumberResponse with operation result
-
-        Raises:
-            LinkNumberError: If parameters are invalid
-        """
-        try:
-            # Generate the link number setting telegram
-            telegram = self.link_number_service.generate_set_link_number_telegram(
-                serial_number, link_number
-            )
-
-            # Send telegram using ConbusService
-            with self.conbus_service:
-                response = self.conbus_service.send_raw_telegram(telegram)
-
-                # Determine result based on response
-                result = "NAK"  # Default to NAK
-                if response.success and response.received_telegrams:
-                    # Try to parse the first received telegram
-                    if len(response.received_telegrams) > 0:
-                        received_telegram = response.received_telegrams[0]
-                        try:
-                            parsed_telegram = self.telegram_service.parse_telegram(
-                                received_telegram
-                            )
-                            if isinstance(parsed_telegram, ReplyTelegram):
-                                if self.link_number_service.is_ack_response(
-                                    parsed_telegram
-                                ):
-                                    result = "ACK"
-                                elif self.link_number_service.is_nak_response(
-                                    parsed_telegram
-                                ):
-                                    result = "NAK"
-                        except Exception as e:
-                            self.logger.warning(f"Failed to parse reply telegram: {e}")
-
-                return ConbusLinknumberResponse(
-                    success=response.success and result == "ACK",
-                    result=result,
-                    link_number=link_number,
-                    serial_number=serial_number,
-                    sent_telegram=telegram,
-                    received_telegrams=response.received_telegrams,
-                    error=response.error,
-                    timestamp=response.timestamp,
-                )
-
-        except LinkNumberError as e:
-            return ConbusLinknumberResponse(
-                success=False,
-                result="NAK",
-                serial_number=serial_number,
-                error=str(e),
-            )
-        except Exception as e:
-            return ConbusLinknumberResponse(
-                success=False,
-                result="NAK",
-                serial_number=serial_number,
-                error=f"Unexpected error: {e}",
-            )
-
-    def get_linknumber(self, serial_number: str) -> ConbusLinknumberResponse:
-        """
-        Get the current link number for a specific module.
-
-        Args:
-            serial_number: 10-digit module serial number
-
-        Returns:
-            ConbusLinknumberResponse with operation result and link number
-
-        Raises:
-            Exception: If datapoint query fails
-        """
-        try:
-            # TODO: Migrate to new ConbusDatapointService callback-based API
-            # Query the LINK_NUMBER datapoint
-            datapoint_response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-                serial_number=serial_number,
-                datapoint_type=DataPointType.LINK_NUMBER,
-            )
-
-            if datapoint_response.success and datapoint_response.datapoint_telegram:
-                # Extract link number from datapoint response
-                try:
-                    link_number_value = int(
-                        datapoint_response.datapoint_telegram.data_value
-                    )
-                    return ConbusLinknumberResponse(
-                        success=True,
-                        result="SUCCESS",
-                        serial_number=serial_number,
-                        link_number=link_number_value,
-                        sent_telegram=datapoint_response.sent_telegram,
-                        received_telegrams=datapoint_response.received_telegrams,
-                        timestamp=datapoint_response.timestamp,
-                    )
-                except (ValueError, TypeError) as e:
-                    return ConbusLinknumberResponse(
-                        success=False,
-                        result="PARSE_ERROR",
-                        serial_number=serial_number,
-                        sent_telegram=datapoint_response.sent_telegram,
-                        received_telegrams=datapoint_response.received_telegrams,
-                        error=f"Failed to parse link number: {e}",
-                        timestamp=datapoint_response.timestamp,
-                    )
-            else:
-                return ConbusLinknumberResponse(
-                    success=False,
-                    result="QUERY_FAILED",
-                    serial_number=serial_number,
-                    sent_telegram=datapoint_response.sent_telegram,
-                    received_telegrams=datapoint_response.received_telegrams,
-                    error=datapoint_response.error or "Failed to query link number",
-                    timestamp=datapoint_response.timestamp,
-                )
-
-        except Exception as e:
-            return ConbusLinknumberResponse(
-                success=False,
-                result="ERROR",
-                serial_number=serial_number,
-                error=f"Unexpected error: {e}",
-            )

xp/services/conbus/conbus_service.py

@@ -1,306 +0,0 @@
-"""Conbus Client Send Service for TCP communication with Conbus servers.
-
-This service implements a TCP client that connects to Conbus servers and sends
-various types of telegrams including discover, version, and sensor data requests.
-"""
-
-import logging
-import socket
-from datetime import datetime
-from typing import Any, List, Optional
-
-from typing_extensions import Callable
-
-from xp.models import (
-    ConbusConnectionStatus,
-    ConbusRequest,
-    ConbusResponse,
-)
-from xp.models.conbus.conbus_client_config import ConbusClientConfig
-from xp.models.response import Response
-from xp.models.telegram.system_function import SystemFunction
-from xp.services.conbus.conbus_connection_pool import ConbusConnectionPool
-from xp.utils.checksum import calculate_checksum
-
-
-class ConbusError(Exception):
-    """Raised when Conbus client send operations fail"""
-
-    pass
-
-
-class ConbusService:
-    """
-    TCP client service for sending telegrams to Conbus servers.
-
-    Manages TCP socket connections, handles telegram generation and transmission,
-    and processes server responses.
-    """
-
-    def __init__(
-        self,
-        client_config: ConbusClientConfig,
-        connection_pool: ConbusConnectionPool,
-    ):
-        """Initialize the Conbus client send service
-
-        Args:
-            client_config: ConbusClientConfig for dependency injection
-            connection_pool: ConbusConnectionPool for dependency injection
-        """
-        self.client_config: ConbusClientConfig = client_config
-        self.is_connected = False
-        self.last_activity: Optional[datetime] = None
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-        # Use injected connection pool
-        self._connection_pool = connection_pool
-
-    def get_config(self) -> ConbusClientConfig:
-        """Get current client configuration"""
-        return self.client_config
-
-    def connect(self) -> Response:
-        """Test connection using the connection pool"""
-        try:
-            # Test connection by acquiring and immediately releasing
-            with self._connection_pool:
-                self.is_connected = True
-                self.last_activity = datetime.now()
-
-                self.logger.info(
-                    f"Connection pool ready for {self.client_config.conbus.ip}:{self.client_config.conbus.port}"
-                )
-
-                return Response(
-                    success=True,
-                    data={
-                        "message": f"Connection pool ready for {self.client_config.conbus.ip}:{self.client_config.conbus.port}",
-                    },
-                    error=None,
-                )
-
-        except Exception as e:
-            error_msg = f"Failed to establish connection pool to {self.client_config.conbus.ip}:{self.client_config.conbus.port}: {e}"
-            self.logger.error(error_msg)
-            self.is_connected = False
-            return Response(success=False, data=None, error=error_msg)
-
-    def disconnect(self) -> None:
-        """Close connection pool (graceful shutdown)"""
-        try:
-            self._connection_pool.close()
-            self.logger.info("Connection pool closed")
-        except Exception as e:
-            self.logger.error(f"Error closing connection pool: {e}")
-        finally:
-            self.is_connected = False
-
-    def get_connection_status(self) -> ConbusConnectionStatus:
-        """Get current connection status"""
-        return ConbusConnectionStatus(
-            connected=self.is_connected,
-            ip=self.client_config.conbus.ip,
-            port=self.client_config.conbus.port,
-            last_activity=self.last_activity,
-        )
-
-    @staticmethod
-    def _parse_telegrams(raw_data: str) -> List[str]:
-        """Parse raw data and extract telegrams using < and > delimiters"""
-        telegrams: list[str] = []
-        if not raw_data:
-            return telegrams
-
-        # Find all telegram patterns <...>
-        start_pos = 0
-        while True:
-            # Find the start of next telegram
-            start_idx = raw_data.find("<", start_pos)
-            if start_idx == -1:
-                break
-
-            # Find the end of this telegram
-            end_idx = raw_data.find(">", start_idx)
-            if end_idx == -1:
-                # Incomplete telegram at the end
-                break
-
-            # Extract telegram including < and >
-            telegram = raw_data[start_idx : end_idx + 1]
-            if telegram.strip():
-                telegrams.append(telegram.strip())
-
-            start_pos = end_idx + 1
-
-        return telegrams
-
-    def receive_responses(
-        self,
-        timeout: float = 0.1,
-        receive_callback: Optional[Callable[[list[str]], None]] = None,
-    ) -> List[str]:
-        """Receive responses from the server and properly split telegrams"""
-        import time
-
-        all_telegrams = []
-        start_time = time.time()
-
-        try:
-            with self._connection_pool as connection:
-                while time.time() - start_time < timeout:
-                    # Call _receive_responses_with_connection with a short timeout for each iteration
-                    telegrams = self._receive_responses_with_connection(
-                        connection, timeout=0.1
-                    )
-                    if receive_callback is not None:
-                        receive_callback(telegrams)
-                    all_telegrams.extend(telegrams)
-
-                    # Small sleep to avoid busy waiting when no data
-                    time.sleep(0.01)
-        except Exception as e:
-            self.logger.error(f"Error receiving responses: {e}")
-            return []
-
-        return all_telegrams
-
-    def _receive_responses_with_connection(
-        self,
-        connection: socket.socket,
-        timeout: float = 1.0,
-        receive_callback: Optional[Callable[[list[str]], None]] = None,
-    ) -> List[str]:
-        """Receive responses from the server using a specific connection"""
-        accumulated_data = ""
-
-        try:
-            # Set a shorter timeout for receiving responses
-            original_timeout = connection.gettimeout()
-            connection.settimeout(timeout)  # 1 second timeout for responses
-
-            while True:
-                try:
-                    data = connection.recv(1024)
-                    if not data:
-                        break
-
-                    # Accumulate all received data
-                    message = data.decode("latin-1")
-                    if receive_callback is not None:
-                        parsed_telegrams = self._parse_telegrams(message)
-                        receive_callback(parsed_telegrams)
-                    accumulated_data += message
-                    self.last_activity = datetime.now()
-                    connection.settimeout(0.1)  # 2 second timeout for responses
-
-                except socket.timeout:
-                    # No more data available
-                    break
-
-            # Restore original timeout
-            connection.settimeout(original_timeout)
-
-        except Exception as e:
-            self.logger.error(f"Error receiving responses: {e}")
-
-        # Parse telegrams from accumulated data
-        telegrams = self._parse_telegrams(accumulated_data)
-        for telegram in telegrams:
-            self.logger.info(f"Received telegram: {telegram}")
-
-        return telegrams
-
-    def send_telegram(
-        self,
-        serial_number: str,
-        system_function: SystemFunction,
-        data: str,
-        receive_callback: Optional[Callable[[list[str]], None]] = None,
-    ) -> ConbusResponse:
-        """Send custom telegram with specified function and data point codes"""
-        # Generate custom system telegram: <S{serial}F{function}{data_point}{checksum}>
-        function_code = system_function.value
-        telegram_body = f"S{serial_number}F{function_code}D{data}"
-        checksum = calculate_checksum(telegram_body)
-        telegram = f"<{telegram_body}{checksum}>"
-
-        return self.send_raw_telegram(telegram, receive_callback)
-
-    def send_telegram_body(
-        self,
-        telegram_body: str,
-        receive_callback: Optional[Callable[[list[str]], None]] = None,
-    ) -> ConbusResponse:
-        """Send custom telegram with specified function and data point codes"""
-        checksum = calculate_checksum(telegram_body)
-        telegram = f"<{telegram_body}{checksum}>"
-
-        return self.send_raw_telegram(telegram, receive_callback)
-
-    def send_raw_telegram(
-        self,
-        telegram: Optional[str] = None,
-        receive_callback: Optional[Callable[[list[str]], None]] = None,
-    ) -> ConbusResponse:
-        """Send telegram using connection pool with automatic acquire/release"""
-        request = ConbusRequest(telegram=telegram)
-
-        try:
-            # Use context manager for automatic connection management
-            with self._connection_pool as connection:
-
-                # Draining event waiting to be read (wait time 0)
-                responses = self._receive_responses_with_connection(connection, 0.001)
-                self.logger.info(f"Purged telegram: {responses}")
-
-                # Send telegram
-                if telegram is not None:
-                    connection.send(telegram.encode("latin-1"))
-                    self.logger.info(f"Sent telegram: {telegram}")
-
-                self.last_activity = datetime.now()
-                self.is_connected = True  # Update connection status
-
-                # Receive responses
-                responses = self._receive_responses_with_connection(
-                    connection, 0.1, receive_callback
-                )
-
-                return ConbusResponse(
-                    success=True,
-                    request=request,
-                    sent_telegram=telegram,
-                    received_telegrams=responses,
-                )
-                # Connection automatically released here
-
-        except Exception as e:
-            error_msg = f"Failed to send telegram: {e}"
-            self.logger.error(error_msg)
-            self.is_connected = False  # Update connection status on error
-            return ConbusResponse(
-                success=False,
-                request=request,
-                error=error_msg,
-            )
-
-    def send_raw_telegrams(self, telegrams: List[str]) -> ConbusResponse:
-        self.logger.info(f"send_raw_telegrams: {telegrams}")
-        all_telegrams = "".join(telegrams)
-        return self.send_raw_telegram(all_telegrams)
-
-    def __enter__(self) -> "ConbusService":
-        """Context manager entry"""
-        return self
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        """Context manager exit - ensure connection is closed"""
-        self.disconnect()