add systemd services and handlers pipeline

obd2_client/src/handlers/storage_handler.py

@@ -0,0 +1,228 @@
+"""
+Storage Handler - persists OBD2 readings to SQLite.
+
+Implements batching for efficient database writes.
+"""
+
+import threading
+import time
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from .base import BaseHandler, OBD2Reading
+from ..storage.storage import get_storage, Storage
+from ..logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class StorageHandler(BaseHandler):
+    """
+    Handler that saves OBD2 readings to SQLite.
+
+    Features:
+    - Configurable batch size for efficient writes
+    - Automatic flush on interval
+    - Session management integration
+    - Thread-safe batching
+    """
+
+    def __init__(
+        self,
+        enabled: bool = True,
+        batch_size: int = 50,
+        flush_interval: float = 1.0,
+        db_path: Optional[str] = None,
+        auto_session: bool = True,
+    ):
+        """
+        Initialize storage handler.
+
+        Args:
+            enabled: Whether handler is active
+            batch_size: Number of readings to batch before write
+            flush_interval: Maximum time before flushing batch (seconds)
+            db_path: Path to SQLite database
+            auto_session: Automatically start session on first reading
+        """
+        super().__init__(name="storage", enabled=enabled)
+        self._storage: Optional[Storage] = None
+        self._batch_size = batch_size
+        self._flush_interval = flush_interval
+        self._db_path = db_path
+        self._auto_session = auto_session
+        self._batch: List[Dict[str, Any]] = []
+        self._batch_lock = threading.Lock()
+        self._last_flush_time = time.time()
+        self._saved_count = 0
+        self._batch_count = 0
+        self._session_started = False
+
+    def initialize(self) -> bool:
+        """Initialize the handler."""
+        try:
+            self._storage = get_storage(db_path=self._db_path)
+            self._initialized = True
+            logger.info(
+                f"Storage handler initialized: batch_size={self._batch_size}, "
+                f"flush_interval={self._flush_interval}s"
+            )
+            return True
+        except Exception as e:
+            logger.error(f"Failed to initialize storage handler: {e}")
+            return False
+
+    def _ensure_session(self) -> None:
+        """Ensure a session is started."""
+        if self._auto_session and not self._session_started:
+            if self._storage and not self._storage.get_current_session_id():
+                self._storage.start_session()
+                self._session_started = True
+
+    def handle(self, reading: OBD2Reading) -> bool:
+        """
+        Add reading to batch.
+
+        Args:
+            reading: OBD2Reading to save
+
+        Returns:
+            True if reading was accepted
+        """
+        if not self._initialized or not self.enabled:
+            return False
+
+        self._ensure_session()
+
+        with self._batch_lock:
+            self._batch.append({
+                "pid": reading.pid,
+                "name": reading.name,
+                "value": reading.value,
+                "unit": reading.unit,
+                "timestamp": reading.timestamp.isoformat(),
+                "session_id": reading.session_id,
+            })
+
+            should_flush = (
+                len(self._batch) >= self._batch_size or
+                (time.time() - self._last_flush_time) >= self._flush_interval
+            )
+
+            if should_flush:
+                self._do_flush()
+
+        return True
+
+    def handle_batch(self, readings: List[OBD2Reading]) -> int:
+        """
+        Add multiple readings to batch.
+
+        Args:
+            readings: List of OBD2Reading objects
+
+        Returns:
+            Number of readings accepted
+        """
+        if not self._initialized or not self.enabled:
+            return 0
+
+        self._ensure_session()
+
+        with self._batch_lock:
+            for reading in readings:
+                self._batch.append({
+                    "pid": reading.pid,
+                    "name": reading.name,
+                    "value": reading.value,
+                    "unit": reading.unit,
+                    "timestamp": reading.timestamp.isoformat(),
+                    "session_id": reading.session_id,
+                })
+
+            should_flush = (
+                len(self._batch) >= self._batch_size or
+                (time.time() - self._last_flush_time) >= self._flush_interval
+            )
+
+            if should_flush:
+                self._do_flush()
+
+        return len(readings)
+
+    def _do_flush(self) -> None:
+        """Internal flush - must be called with lock held."""
+        if not self._storage or not self._batch:
+            return
+
+        batch_to_save = self._batch
+        self._batch = []
+        self._last_flush_time = time.time()
+
+        try:
+            saved = self._storage.save_readings_batch(batch_to_save)
+            self._saved_count += saved
+            self._batch_count += 1
+            logger.debug(f"Flushed {saved} readings (batch #{self._batch_count})")
+        except Exception as e:
+            logger.error(f"Failed to flush readings: {e}")
+            # Put back failed batch
+            self._batch = batch_to_save + self._batch
+
+    def flush(self) -> None:
+        """Flush pending readings to database."""
+        with self._batch_lock:
+            self._do_flush()
+
+    def shutdown(self) -> None:
+        """Shutdown the handler."""
+        self.flush()
+
+        if self._storage and self._session_started:
+            self._storage.end_session()
+
+        logger.info(
+            f"Storage handler shutdown: saved={self._saved_count}, "
+            f"batches={self._batch_count}"
+        )
+        self._initialized = False
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get handler statistics."""
+        storage_stats = {}
+        if self._storage:
+            storage_stats = self._storage.get_stats()
+
+        with self._batch_lock:
+            pending = len(self._batch)
+
+        return {
+            "name": self.name,
+            "enabled": self.enabled,
+            "initialized": self._initialized,
+            "saved_count": self._saved_count,
+            "batch_count": self._batch_count,
+            "pending_in_batch": pending,
+            "batch_size": self._batch_size,
+            "flush_interval": self._flush_interval,
+            **storage_stats,
+        }
+
+    @property
+    def storage(self) -> Optional[Storage]:
+        """Get the Storage instance."""
+        return self._storage
+
+    def start_session(self) -> Optional[str]:
+        """Manually start a new session."""
+        if self._storage:
+            session_id = self._storage.start_session()
+            self._session_started = True
+            return session_id
+        return None
+
+    def end_session(self) -> None:
+        """Manually end current session."""
+        if self._storage:
+            self._storage.end_session()
+            self._session_started = False