fbuild 1.2.8__py3-none-any.whl → 1.2.15__py3-none-any.whl

fbuild/daemon/firmware_ledger.py

@@ -3,17 +3,18 @@ Firmware Ledger - Track deployed firmware on devices.
 
 This module provides a ledger to track what firmware is currently deployed on each
 device/port, allowing clients to skip re-upload if the same firmware is already running.
-The cache is stored in ~/.fbuild/firmware_ledger.json (or dev path if FBUILD_DEV_MODE)
-and uses file locking for thread-safe access.
+The cache is stored in ~/.fbuild/firmware_ledger.json (or dev path if FBUILD_DEV_MODE).
 
 Features:
 - Port to firmware hash mapping with timestamps
 - Source file hash tracking for change detection
 - Build flags hash for build configuration tracking
 - Automatic stale entry expiration (configurable, default 24 hours)
-- Thread-safe file access with file locking
+- Thread-safe in-process access via threading.Lock
 - Skip re-upload when firmware matches what's deployed
 
+Note: Cross-process synchronization is handled by the daemon which holds locks in memory.
+
 Example:
     >>> from fbuild.daemon.firmware_ledger import FirmwareLedger, compute_firmware_hash
     >>>
@@ -30,7 +31,6 @@ Example:
 import hashlib
 import json
 import os
-import sys
 import threading
 import time
 from dataclasses import dataclass
@@ -131,7 +131,8 @@ class FirmwareLedger:
     """Manages port to firmware mapping with persistent storage.
 
     The ledger stores mappings in ~/.fbuild/firmware_ledger.json (or dev path)
-    and provides thread-safe access through file locking.
+    and provides thread-safe in-process access through threading.Lock.
+    Cross-process synchronization is handled by the daemon which holds locks in memory.
 
     Example:
         >>> ledger = FirmwareLedger()
@@ -196,60 +197,6 @@ class FirmwareLedger:
         except OSError as e:
             raise FirmwareLedgerError(f"Failed to write ledger: {e}") from e
 
-    def _acquire_file_lock(self) -> Any:
-        """Acquire a file lock for cross-process synchronization.
-
-        Returns:
-            Lock file handle (or None on platforms without locking support)
-        """
-        self._ensure_directory()
-        lock_path = self._ledger_path.with_suffix(".lock")
-
-        try:
-            # Open lock file
-            lock_file = open(lock_path, "w", encoding="utf-8")
-
-            # Platform-specific locking
-            if sys.platform == "win32":
-                import msvcrt
-
-                msvcrt.locking(lock_file.fileno(), msvcrt.LK_NBLCK, 1)
-            else:  # pragma: no cover - Unix only
-                import fcntl  # type: ignore[import-not-found]
-
-                fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
-
-            return lock_file
-        except (ImportError, OSError):
-            # Locking not available or failed - continue without lock
-            return None
-
-    def _release_file_lock(self, lock_file: Any) -> None:
-        """Release a file lock.
-
-        Args:
-            lock_file: Lock file handle from _acquire_file_lock
-        """
-        if lock_file is None:
-            return
-
-        try:
-            if sys.platform == "win32":
-                import msvcrt
-
-                try:
-                    msvcrt.locking(lock_file.fileno(), msvcrt.LK_UNLCK, 1)
-                except OSError:
-                    pass
-            else:  # pragma: no cover - Unix only
-                import fcntl  # type: ignore[import-not-found]
-
-                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
-
-            lock_file.close()
-        except (ImportError, OSError):
-            pass
-
     def record_deployment(
         self,
         port: str,
@@ -280,13 +227,9 @@ class FirmwareLedger:
         )
 
         with self._lock:
-            lock_file = self._acquire_file_lock()
-            try:
-                data = self._read_ledger()
-                data[port] = entry.to_dict()
-                self._write_ledger(data)
-            finally:
-                self._release_file_lock(lock_file)
+            data = self._read_ledger()
+            data[port] = entry.to_dict()
+            self._write_ledger(data)
 
     def get_deployment(self, port: str) -> FirmwareEntry | None:
         """Get the deployment entry for a port.
@@ -298,20 +241,16 @@ class FirmwareLedger:
             FirmwareEntry or None if not found or stale
         """
         with self._lock:
-            lock_file = self._acquire_file_lock()
-            try:
-                data = self._read_ledger()
-                entry_data = data.get(port)
-                if entry_data is None:
-                    return None
+            data = self._read_ledger()
+            entry_data = data.get(port)
+            if entry_data is None:
+                return None
 
-                entry = FirmwareEntry.from_dict(entry_data)
-                if entry.is_stale():
-                    return None
+            entry = FirmwareEntry.from_dict(entry_data)
+            if entry.is_stale():
+                return None
 
-                return entry
-            finally:
-                self._release_file_lock(lock_file)
+            return entry
 
     def is_current(
         self,
@@ -384,16 +323,12 @@ class FirmwareLedger:
             True if entry was cleared, False if not found
         """
         with self._lock:
-            lock_file = self._acquire_file_lock()
-            try:
-                data = self._read_ledger()
-                if port in data:
-                    del data[port]
-                    self._write_ledger(data)
-                    return True
-                return False
-            finally:
-                self._release_file_lock(lock_file)
+            data = self._read_ledger()
+            if port in data:
+                del data[port]
+                self._write_ledger(data)
+                return True
+            return False
 
     def clear_all(self) -> int:
         """Clear all entries from the ledger.
@@ -402,14 +337,10 @@ class FirmwareLedger:
             Number of entries cleared
         """
         with self._lock:
-            lock_file = self._acquire_file_lock()
-            try:
-                data = self._read_ledger()
-                count = len(data)
-                self._write_ledger({})
-                return count
-            finally:
-                self._release_file_lock(lock_file)
+            data = self._read_ledger()
+            count = len(data)
+            self._write_ledger({})
+            return count
 
     def clear_stale(
         self,
@@ -424,22 +355,18 @@ class FirmwareLedger:
             Number of entries removed
         """
         with self._lock:
-            lock_file = self._acquire_file_lock()
-            try:
-                data = self._read_ledger()
-                original_count = len(data)
-
-                # Filter out stale entries
-                fresh_data = {}
-                for port, entry_data in data.items():
-                    entry = FirmwareEntry.from_dict(entry_data)
-                    if not entry.is_stale(threshold_seconds):
-                        fresh_data[port] = entry_data
-
-                self._write_ledger(fresh_data)
-                return original_count - len(fresh_data)
-            finally:
-                self._release_file_lock(lock_file)
+            data = self._read_ledger()
+            original_count = len(data)
+
+            # Filter out stale entries
+            fresh_data = {}
+            for port, entry_data in data.items():
+                entry = FirmwareEntry.from_dict(entry_data)
+                if not entry.is_stale(threshold_seconds):
+                    fresh_data[port] = entry_data
+
+            self._write_ledger(fresh_data)
+            return original_count - len(fresh_data)
 
     def get_all(self) -> dict[str, FirmwareEntry]:
         """Get all non-stale entries in the ledger.
@@ -448,17 +375,13 @@ class FirmwareLedger:
             Dictionary mapping port names to FirmwareEntry objects
         """
         with self._lock:
-            lock_file = self._acquire_file_lock()
-            try:
-                data = self._read_ledger()
-                result = {}
-                for port, entry_data in data.items():
-                    entry = FirmwareEntry.from_dict(entry_data)
-                    if not entry.is_stale():
-                        result[port] = entry
-                return result
-            finally:
-                self._release_file_lock(lock_file)
+            data = self._read_ledger()
+            result = {}
+            for port, entry_data in data.items():
+                entry = FirmwareEntry.from_dict(entry_data)
+                if not entry.is_stale():
+                    result[port] = entry
+            return result
 
 
 def compute_firmware_hash(firmware_path: Path) -> str: