bedger 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

bedger/edge/client.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import socket
+import logging
+from http.client import HTTPConnection
+from typing import Any
+
+from .config import Config
+from .entities.device_event import DeviceEvent
+from . import entities
+from .errors import (
+    ConnectionError,
+    SendError,
+    HTTPRequestError,
+    JSONSerializationError,
+    map_socket_error,
+)
+
+logger = logging.getLogger("bedger.edge.client")
+
+
+class UnixSocketHTTPConnection(HTTPConnection):
+    """HTTPConnection subclass that communicates via UNIX domain sockets."""
+
+    def __init__(self, unix_socket_path: str):
+        super().__init__("localhost")  # dummy host
+        self.unix_socket_path = unix_socket_path
+
+    def connect(self):
+        """Override to connect to a UNIX socket instead of TCP."""
+        try:
+            self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            self.sock.connect(self.unix_socket_path)
+        except Exception as e:
+            raise map_socket_error(e, self.unix_socket_path)
+
+
+class Client:
+    """
+    Bedger Edge Client that communicates with the local agent's HTTP API
+    over a UNIX socket. Matches BedgerConnection interface.
+    """
+
+    def __init__(self, config: Config = Config()):
+        self._config = config
+        self._connection: UnixSocketHTTPConnection | None = None
+
+    def __enter__(self) -> Client:
+        self._connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._disconnect()
+
+    def _connect(self) -> None:
+        socket_path = self._config.socket_path
+        logger.info(f"Connecting to Bedger Edge API at {socket_path}")
+        try:
+            self._connection = UnixSocketHTTPConnection(socket_path)
+        except Exception as e:
+            raise ConnectionError(socket_path, e)
+
+    def _disconnect(self) -> None:
+        if self._connection:
+            try:
+                self._connection.close()
+                logger.info("Connection closed")
+            except Exception as e:
+                logger.warning(f"Error closing connection: {e}")
+            finally:
+                self._connection = None
+
+    def send_event(
+        self, event_type: str, severity: entities.Severity, payload: dict[str, Any]
+    ) -> None:
+        """Send a DeviceEvent to /device/events."""
+        if not self._connection:
+            raise ConnectionError(self._config.socket_path)
+
+        try:
+            event = DeviceEvent(event_type=event_type, severity=severity, details=payload)
+            serialized = event.model_dump_json(by_alias=True).encode("utf-8")
+        except Exception as e:
+            raise JSONSerializationError(f"Failed to serialize DeviceEvent {event_type}") from e
+
+        try:
+            self._connection.request(
+                "POST",
+                "/device/events",
+                body=serialized,
+                headers={"Content-Type": "application/json"},
+            )
+
+            response = self._connection.getresponse()
+            response_data = response.read().decode("utf-8")
+
+            if response.status != 200:
+                raise HTTPRequestError(response.status, response_data)
+
+            logger.info(f"Event sent successfully: {response_data}")
+        except HTTPRequestError:
+            raise
+        except Exception as e:
+            raise SendError("Failed to send DeviceEvent", e)

bedger/edge/entities/__init__.py

@@ -1,4 +1,5 @@
-from .message import Message
+from .device_event import DeviceEvent
 from .severity import Severity
 
-__all__ = [Message, Severity]
+
+__all__ = [DeviceEvent, Severity]

bedger/edge/entities/device_event.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Dict, Any, Annotated
+from pydantic import BaseModel, Field, field_validator, field_serializer
+from .severity import Severity
+
+
+class DeviceEvent(BaseModel):
+    """
+    Represents a stored or transmitted device event.
+    This model is compatible with the local /device/events API.
+    """
+
+    event_type: Annotated[
+        str,
+        Field(
+            description="Event type in PascalCase format",
+            pattern=r"^[A-Z][a-zA-Z0-9]*$",
+        ),
+    ]
+    severity: Severity
+    details: Annotated[
+        Dict[str, Any],
+        Field(description="Event-specific details, must be JSON serializable"),
+    ]
+
+    @field_validator("details")
+    @classmethod
+    def validate_details(cls, value: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            json.dumps(value)
+        except TypeError:
+            raise ValueError("details must be a JSON serializable dictionary")
+        return value
+
+    @field_serializer("severity")
+    def serialize_severity(self, severity: Severity) -> str:
+        return severity.value
+
+    @field_serializer("timestamp")
+    def serialize_timestamp(self, timestamp: datetime) -> str:
+        return timestamp.isoformat()

bedger/edge/entities/severity.py

@@ -7,4 +7,3 @@ class Severity(str, Enum):
     MEDIUM = "MEDIUM"
     HIGH = "HIGH"
     CRITICAL = "CRITICAL"
-    INFO = "INFO"

bedger/edge/errors.py

@@ -1,18 +1,104 @@
-class SocketPermissionDeniedError(Exception):
+from __future__ import annotations
+import socket
+
+
+class BedgerError(Exception):
+    """Base class for all Bedger-related exceptions."""
+    pass
+
+
+# --- Configuration and Initialization ---
+
+
+class ConfigurationError(BedgerError):
+    """Raised when configuration values are missing, invalid, or inconsistent."""
+    def __init__(self, message: str, path: str | None = None):
+        self.path = path
+        super().__init__(f"{message}{f' (path: {path})' if path else ''}")
+
+
+class EnvironmentError(BedgerError):
+    """Raised when the environment or system setup prevents operation (permissions, missing dirs, etc.)."""
+    pass
+
+
+# --- Networking / Socket Communication ---
+
+
+class ConnectionError(BedgerError):
+    """Raised when connection to a UNIX or network socket fails."""
+    def __init__(self, socket_path: str, original_error: Exception | None = None):
+        self.socket_path = socket_path
+        self.original_error = original_error
+        super().__init__(f"Failed to connect to socket at {socket_path}: {original_error}")
+
+
+class SendError(BedgerError):
+    """Raised when sending data to Bedger Edge fails."""
+    def __init__(self, message: str, original_error: Exception | None = None):
+        self.original_error = original_error
+        super().__init__(f"{message}{f' ({original_error})' if original_error else ''}")
+
+
+class ReceiveError(BedgerError):
+    """Raised when receiving acknowledgment or response fails."""
+    def __init__(self, message: str, original_error: Exception | None = None):
+        self.original_error = original_error
+        super().__init__(f"{message}{f' ({original_error})' if original_error else ''}")
+
+
+# --- HTTP API Errors ---
+
+
+class HTTPRequestError(BedgerError):
+    """Raised for failed HTTP requests to the local Bedger Edge API."""
+    def __init__(self, status_code: int, response: str):
+        self.status_code = status_code
+        self.response = response
+        super().__init__(f"Bedger API returned HTTP {status_code}: {response}")
+
+
+class JSONSerializationError(BedgerError):
+    """Raised when JSON encoding or decoding fails."""
     pass
 
 
-class SocketFileNotFoundError(Exception):
+# --- Certificates / Security ---
+
+
+class CaCertificateError(BedgerError):
+    """Raised when fetching or validating a CA certificate fails."""
     pass
 
 
-class SocketConnectionError(Exception):
+class AuthenticationError(BedgerError):
+    """Raised when authentication or provisioning fails."""
     pass
 
 
-class SocketNotConnectedError(Exception):
+# --- Device Twin / State Sync ---
+
+
+class DeviceTwinError(BedgerError):
+    """Raised when device twin synchronization or persistence fails."""
     pass
 
 
-class SocketCommunicationError(Exception):
+class DeviceEventError(BedgerError):
+    """Raised when processing or storing device events fails."""
     pass
+
+
+# --- Utilities ---
+
+
+def map_socket_error(err: Exception, socket_path: str) -> BedgerError:
+    """Map low-level socket errors to Bedger-friendly errors."""
+    if isinstance(err, FileNotFoundError):
+        return ConnectionError(socket_path, original_error=err)
+    elif isinstance(err, PermissionError):
+        return EnvironmentError(f"Permission denied on socket {socket_path}")
+    elif isinstance(err, socket.timeout):
+        return ConnectionError(socket_path, original_error=err)
+    else:
+        return BedgerError(str(err))

bedger-0.0.7.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: bedger
+Version: 0.0.7
+Summary: 
+Author: Henk van den Brink
+Requires-Python: >=3.8, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+

bedger-0.0.7.dist-info/RECORD

@@ -0,0 +1,12 @@
+bedger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bedger/edge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bedger/edge/client.py,sha256=R8jeGipxdfjPxn2SWRsNvH2UVx2-v7u2_xw-W62T7vc,3363
+bedger/edge/config.py,sha256=0fUKThP0aJFk3WBF7JUtuKKhXlV07SX5VnqVOLNou-A,152
+bedger/edge/entities/__init__.py,sha256=449LXPZNzoQS7_uxAc5GoT3tx2X-TmtJ-mvy080BNbM,104
+bedger/edge/entities/device_event.py,sha256=E4x7Yt_T2FNW1rNV1FJaPPxDxKWzH5hWDkpkeunK9f0,1273
+bedger/edge/entities/severity.py,sha256=tUN7eDSEN5cc5eAqhvKzVHD1pSEmrdwvNEGsmh4Pnfw,157
+bedger/edge/errors.py,sha256=QOE1aI93w9dLb6WG9c2glAnFaLMy9gN1z4PBimB8bXc,3193
+bedger-0.0.7.dist-info/LICENSE,sha256=lVrf6pfElYZ_o6ETq-XR91_7GHTzKGyeNWAKghvcNUE,1075
+bedger-0.0.7.dist-info/METADATA,sha256=-uIPxzTTC63VMaSCF1fcuSMeswwsjLcLey0ZMGNrbPc,434
+bedger-0.0.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+bedger-0.0.7.dist-info/RECORD,,

{bedger-0.0.5.dist-info → bedger-0.0.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

bedger/edge/connection.py

@@ -1,123 +0,0 @@
-from __future__ import annotations
-
-import logging
-import socket
-from typing import Optional
-
-from bedger.edge import errors
-from bedger.edge.config import Config
-from bedger.edge.entities import Message, Severity
-
-logger = logging.getLogger("bedger.edge.connection")
-
-
-class ConnectionManager:
-    """Manages a connection to a UNIX socket for sending and receiving messages.
-
-    This class provides context manager support for establishing and tearing
-    down a connection to a UNIX socket.
-
-    Attributes:
-        _config (Config): The configuration containing the socket path.
-        _socket (Optional[socket.socket]): The current socket connection.
-    """
-
-    def __init__(self, config: Config = Config()):
-        """Initializes the ConnectionManager.
-
-        Args:
-            config (Config): Configuration for the connection. Defaults to a new `Config` instance.
-        """
-        self._config = config
-        self._socket: Optional[socket.socket] = None
-
-    def __enter__(self) -> ConnectionManager:
-        """Establishes the socket connection when entering the context.
-
-        Returns:
-            ConnectionManager: The instance of the ConnectionManager.
-        """
-        self._connect()
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        """Closes the socket connection when exiting the context."""
-        self._disconnect()
-
-    def _connect(self) -> None:
-        """Establish a connection to the UNIX socket.
-
-        Raises:
-            errors.SocketPermissionDeniedError: If the application does not have permission to connect to the socket.
-            errors.SocketFileNotFoundError: If the socket file is not found at the specified path.
-            errors.SocketConnectionError: If any other error occurs during the connection attempt.
-        """
-        logger.info(f"Attempting to connect to socket at {self._config.socket_path}")
-        try:
-            self._socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            self._socket.connect(self._config.socket_path)
-            logger.info("Successfully connected to the socket")
-        except PermissionError:
-            logger.error("Permission denied: Unable to connect to the socket. Ensure you have the correct permissions.")
-            raise errors.SocketPermissionDeniedError("Permission denied to connect to socket. Are you running as root?")
-        except FileNotFoundError:
-            logger.error("Socket file not found. Verify the server is running and the socket path is correct.")
-            raise errors.SocketFileNotFoundError("Socket file not found. Is the server running?")
-        except Exception as e:
-            logger.exception(f"Unexpected error while connecting to the socket: {e}")
-            raise errors.SocketConnectionError(f"An unexpected error occurred while connecting to the socket: {e}")
-
-    def _disconnect(self) -> None:
-        """Close the socket connection gracefully.
-
-        Ensures the socket is closed and cleaned up properly, even in case of errors.
-        """
-        if self._socket:
-            try:
-                logger.info("Closing the socket connection")
-                self._socket.close()
-            except Exception as e:
-                logger.warning(f"Error occurred while closing the socket: {e}")
-            finally:
-                self._socket = None
-
-    def send_event(self, event_type: str, severity: str | Severity, payload: dict) -> None:
-        """Send an event message through the socket.
-
-        Args:
-            event_type (str): The type of event being sent.
-            severity (str | Severity): The severity level of the event.
-            payload (dict): The event's payload details.
-
-        Raises:
-            errors.SocketNotConnectedError: If no active socket connection exists.
-            errors.SocketBrokenPipeError: If the socket connection is lost during message transmission.
-            errors.SocketCommunicationError: If any error occurs during socket communication.
-        """
-        if not self._socket:
-            logger.error("Attempted to send a message without an active socket connection.")
-            raise errors.SocketNotConnectedError("No active socket connection. Ensure the connection is established.")
-
-        try:
-            message = Message(
-                event_type=event_type,
-                severity=severity,
-                details=payload,
-            )
-            message_json = message.model_dump_json()
-            logger.debug(f"Prepared message: {message_json}")
-
-            logger.debug("Sending message")
-            self._socket.sendall(message_json.encode())
-
-            ack = self._socket.recv(1024)
-            logger.info(f"Received acknowledgment from server: {ack.decode()}")
-        except BrokenPipeError:
-            logger.error("Broken pipe error: The socket connection was lost during message transmission.")
-            raise errors.SocketBrokenPipeError("Socket connection lost. Unable to send message.")
-        except socket.error as e:
-            logger.error(f"Socket error occurred: {e}")
-            raise errors.SocketCommunicationError(f"Socket error during communication: {e}")
-        except Exception as e:
-            logger.exception(f"Unexpected error while sending the message: {e}")
-            raise errors.SocketCommunicationError(f"Unexpected error occurred: {e}")

bedger/edge/entities/message.py

@@ -1,32 +0,0 @@
-import json
-from typing import Dict
-
-from pydantic import BaseModel, Field, field_serializer, field_validator
-from typing_extensions import Annotated
-
-from .severity import Severity
-
-
-class Message(BaseModel):
-    event_type: Annotated[
-        str,
-        Field(
-            description="Event type in PascalCase format",
-            pattern=r"^[A-Z][a-zA-Z0-9]*$",
-        ),
-    ]
-    severity: Severity
-    details: Annotated[Dict, Field(description="Details of the message as a JSON serializable dictionary")]
-
-    @field_validator("details")
-    @classmethod
-    def validate_details(cls, value: Dict) -> Dict:
-        try:
-            json.dumps(value)
-        except TypeError:
-            raise ValueError("details must be a JSON serializable dictionary")
-        return value
-
-    @field_serializer("severity")
-    def serialize_severity(self, severity: Severity) -> str:
-        return severity.value

bedger-0.0.5.dist-info/METADATA

@@ -1,105 +0,0 @@
-Metadata-Version: 2.1
-Name: bedger
-Version: 0.0.5
-Summary: Edge monitoring software for secure and efficient device management.
-Author: Henk van den Brink
-Author-email: henk.vandenbrink@bedger.io
-Requires-Python: >=3.8.1,<4.0.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: pydantic (>=2.9.2,<3.0.0)
-Requires-Dist: typing-extensions (>=4.12.2,<5.0.0)
-Project-URL: homepage, https://github.com/bedger-io/BEDGER-edgeservices-securitymonitoring-sdk
-Project-URL: issues, https://github.com/bedger-io/BEDGER-edgeservices-securitymonitoring-sdk/issues
-Description-Content-Type: text/markdown
-
-# ConnectionManager Class Documentation
-
-The `ConnectionManager` class manages connections to a UNIX socket for sending and receiving messages.
-It provides context management capabilities to ensure connections are properly opened and closed.
-
-## Features
-- Context manager support for connection lifecycle management.
-- Error handling for socket-related issues.
-- Sends event messages with acknowledgment handling.
-
-## Installation
-Ensure you have the `bedger` package and its dependencies installed.
-
-```bash
-pip install bedger
-```
-
-## Usage
-The following example demonstrates how to use the `ConnectionManager` to send events:
-
-```python
-import time
-import bedger.edge.config as config
-import bedger.edge.connection as connection
-import bedger.edge.entities as entities
-
-if __name__ == "__main__":
-    events = [
-        {"event_type": "EventA", "severity": entities.Severity.HIGH, "payload": {"key": "value1"}},
-        {"event_type": "EventB", "severity": entities.Severity.LOW, "payload": {"key": "value2"}},
-        {"event_type": "EventC", "severity": entities.Severity.CRITICAL, "payload": {"key": "value3"}},
-    ]
-
-    with connection.ConnectionManager(config.Config()) as conn:
-        for event in events:
-            time.sleep(1)
-            conn.send_event(event["event_type"], event["severity"], event["payload"])
-```
-
-## API Reference
-
-### `ConnectionManager`
-Manages a connection to a UNIX socket for sending and receiving messages.
-
-#### Constructor
-- **`__init__(config: Config = Config())`**
-  - Initializes the `ConnectionManager` with a specified configuration.
-  - **Parameters:**
-    - `config (Config)`: The configuration containing the socket path. Defaults to a new `Config` instance.
-
-#### Context Management
-- **`__enter__() -> ConnectionManager`**
-  - Establishes the socket connection when entering the context.
-  - **Returns:** The instance of the `ConnectionManager`.
-
-- **`__exit__(exc_type, exc_value, traceback) -> None`**
-  - Closes the socket connection when exiting the context.
-
-#### Methods
-- **`send_event(event_type: str, severity: str | Severity, payload: dict) -> None`**
-  - Sends an event message through the socket.
-  - **Parameters:**
-    - `event_type (str)`: The type of event being sent.
-    - `severity (str | Severity)`: The severity level of the event.
-    - `payload (dict)`: The event's payload details.
-  - **Raises:**
-    - `SocketNotConnectedError`: If no active socket connection exists.
-    - `SocketBrokenPipeError`: If the socket connection is lost during transmission.
-    - `SocketCommunicationError`: If an error occurs during socket communication.
-
-## Error Handling
-The `ConnectionManager` raises custom errors from the `bedger.edge.errors` module for:
-- Permission issues (`SocketPermissionDeniedError`).
-- Missing socket files (`SocketFileNotFoundError`).
-- Connection problems (`SocketConnectionError`).
-- Communication errors (`SocketCommunicationError`, `SocketBrokenPipeError`).
-
-## Logging
-The class uses the `logging` module to log the following:
-- Connection attempts and successes.
-- Errors during connection, disconnection, and message sending.
-- Debug information for message preparation and acknowledgments.
-
-## License
-This project is licensed under the MIT License. See the LICENSE file for details.
-

bedger-0.0.5.dist-info/RECORD

@@ -1,12 +0,0 @@
-bedger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bedger/edge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bedger/edge/config.py,sha256=0fUKThP0aJFk3WBF7JUtuKKhXlV07SX5VnqVOLNou-A,152
-bedger/edge/connection.py,sha256=25h7PzRhSw8m0w679p23M6X_o-wuIOl7M1P837bpy9I,5400
-bedger/edge/entities/__init__.py,sha256=_oKO_XdDerqOwVX8izhDPtGv4HqVDwQaT-otOdY8lYg,91
-bedger/edge/entities/message.py,sha256=wLbEZik_FBboyEAvX5Uvlto1t4BsjaeLXUFGOIjIHRU,913
-bedger/edge/entities/severity.py,sha256=lzJhqjFfeJ26EWJYDIe-Fotml00dQK6_ihpc_0NzLRg,175
-bedger/edge/errors.py,sha256=6jdmhlKoWlD-kZ8-xRiAlObRHEo9PwrKqhWQ5su5TLk,266
-bedger-0.0.5.dist-info/LICENSE,sha256=lVrf6pfElYZ_o6ETq-XR91_7GHTzKGyeNWAKghvcNUE,1075
-bedger-0.0.5.dist-info/METADATA,sha256=-yEloT1oseSC-2g89JZtO07GDqW5mH1RkbribcyN6hk,4144
-bedger-0.0.5.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-bedger-0.0.5.dist-info/RECORD,,