fbuild 1.2.8__py3-none-any.whl

fbuild/daemon/operation_registry.py

@@ -0,0 +1,288 @@
+"""
+Operation Registry - Structured operation state tracking.
+
+This module provides a registry for tracking all daemon operations (build/deploy/monitor)
+with structured state management, replacing the simple boolean _operation_in_progress flag.
+"""
+
+import logging
+import threading
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+from fbuild.daemon.messages import OperationType
+
+
+class OperationState(Enum):
+    """State of a daemon operation."""
+
+    QUEUED = "queued"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class Operation:
+    """Tracks a daemon operation (build/deploy/monitor)."""
+
+    operation_id: str
+    operation_type: OperationType
+    project_dir: str
+    environment: str
+    state: OperationState
+    request_id: str
+    caller_pid: int
+    created_at: float = field(default_factory=time.time)
+    started_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    error_message: Optional[str] = None
+    result: Optional[Any] = None
+
+    # Subprocess tracking
+    subprocess_ids: list[str] = field(default_factory=list)
+    compilation_job_ids: list[str] = field(default_factory=list)
+
+    def duration(self) -> Optional[float]:
+        """Get operation duration in seconds.
+
+        Returns:
+            Duration in seconds, or None if not complete
+        """
+        if self.started_at and self.completed_at:
+            return self.completed_at - self.started_at
+        return None
+
+    def elapsed_time(self) -> Optional[float]:
+        """Get elapsed time since operation started.
+
+        Returns:
+            Elapsed time in seconds, or None if not started
+        """
+        if self.started_at:
+            return time.time() - self.started_at
+        return None
+
+
+class OperationRegistry:
+    """Registry for tracking all daemon operations."""
+
+    def __init__(self, max_history: int = 100):
+        """Initialize operation registry.
+
+        Args:
+            max_history: Maximum number of completed operations to retain
+        """
+        self.operations: dict[str, Operation] = {}
+        self.lock = threading.Lock()
+        self.max_history = max_history
+        logging.info(f"OperationRegistry initialized (max_history={max_history})")
+
+    def register_operation(self, operation: Operation) -> str:
+        """Register new operation.
+
+        Args:
+            operation: Operation to register
+
+        Returns:
+            Operation ID
+        """
+        logging.debug(f"Operation type: {operation.operation_type.value}, project: {operation.project_dir}, env: {operation.environment}")
+        logging.debug(f"Initial state: {operation.state.value}")
+
+        with self.lock:
+            existing_count = len(self.operations)
+            self.operations[operation.operation_id] = operation
+            logging.debug(f"Operation added to registry, total operations: {existing_count} -> {len(self.operations)}")
+            self._cleanup_old_operations()
+
+        logging.info(f"Registered operation {operation.operation_id}: {operation.operation_type.value} {operation.project_dir}")
+        logging.debug(f"Active operations after registration: {len([op for op in self.operations.values() if op.state in (OperationState.QUEUED, OperationState.RUNNING)])}")
+        return operation.operation_id
+
+    def get_operation(self, operation_id: str) -> Optional[Operation]:
+        """Get operation by ID.
+
+        Args:
+            operation_id: Operation ID to query
+
+        Returns:
+            Operation or None if not found
+        """
+        with self.lock:
+            op = self.operations.get(operation_id)
+            if op:
+                logging.debug(f"Found operation {operation_id}")
+            else:
+                logging.debug(f"Operation {operation_id} not found")
+            return op
+
+    def update_state(self, operation_id: str, state: OperationState, **kwargs: Any) -> None:
+        """Update operation state.
+
+        Args:
+            operation_id: Operation ID to update
+            state: New state
+            **kwargs: Additional fields to update
+        """
+        logging.debug(f"Additional fields to update: {list(kwargs.keys())}")
+
+        with self.lock:
+            if operation_id not in self.operations:
+                logging.warning(f"Cannot update unknown operation: {operation_id}")
+                logging.debug(f"Known operations: {list(self.operations.keys())}")
+                return
+
+            op = self.operations[operation_id]
+            old_state = op.state
+            op.state = state
+
+            # Auto-update timestamps
+            if state == OperationState.RUNNING and op.started_at is None:
+                op.started_at = time.time()
+            elif state in (OperationState.COMPLETED, OperationState.FAILED, OperationState.CANCELLED):
+                if op.completed_at is None:
+                    op.completed_at = time.time()
+
+            # Update additional fields
+            for key, value in kwargs.items():
+                if hasattr(op, key):
+                    setattr(op, key, value)
+
+            logging.info(f"Operation {operation_id} state: {old_state.value} -> {state.value}")
+            if state in (OperationState.COMPLETED, OperationState.FAILED, OperationState.CANCELLED):
+                logging.info(
+                    f"Operation {operation_id} finished: state={state.value}, type={op.operation_type.value}, duration={op.duration():.2f}s"
+                    if op.duration()
+                    else f"Operation {operation_id} finished: state={state.value}"
+                )
+
+    def get_active_operations(self) -> list[Operation]:
+        """Get all active (running/queued) operations.
+
+        Returns:
+            List of active operations
+        """
+        with self.lock:
+            active = [op for op in self.operations.values() if op.state in (OperationState.QUEUED, OperationState.RUNNING)]
+            logging.debug(f"Found {len(active)} active operations (queued or running)")
+            if active:
+                logging.info(f"Active operations: {[op.operation_id for op in active]}")
+            return active
+
+    def get_operations_by_project(self, project_dir: str) -> list[Operation]:
+        """Get all operations for a specific project.
+
+        Args:
+            project_dir: Project directory path
+
+        Returns:
+            List of operations for the project
+        """
+        with self.lock:
+            ops = [op for op in self.operations.values() if op.project_dir == project_dir]
+            logging.debug(f"Found {len(ops)} operations for project {project_dir}")
+            if ops:
+                logging.debug(f"Operation states: {[(op.operation_id, op.state.value) for op in ops]}")
+            return ops
+
+    def is_project_busy(self, project_dir: str) -> bool:
+        """Check if a project has any active operations.
+
+        Args:
+            project_dir: Project directory path
+
+        Returns:
+            True if project has active operations
+        """
+        with self.lock:
+            busy = any(op.project_dir == project_dir and op.state in (OperationState.QUEUED, OperationState.RUNNING) for op in self.operations.values())
+            return busy
+
+    def get_statistics(self) -> dict[str, int]:
+        """Get operation statistics.
+
+        Returns:
+            Dictionary with operation counts by state
+        """
+        with self.lock:
+            stats = {
+                "total_operations": len(self.operations),
+                "queued": sum(1 for op in self.operations.values() if op.state == OperationState.QUEUED),
+                "running": sum(1 for op in self.operations.values() if op.state == OperationState.RUNNING),
+                "completed": sum(1 for op in self.operations.values() if op.state == OperationState.COMPLETED),
+                "failed": sum(1 for op in self.operations.values() if op.state == OperationState.FAILED),
+                "cancelled": sum(1 for op in self.operations.values() if op.state == OperationState.CANCELLED),
+            }
+        if stats["total_operations"] > 0:
+            success_rate = (stats["completed"] / stats["total_operations"]) * 100 if stats["total_operations"] > 0 else 0
+            logging.info(f"Operation success rate: {success_rate:.1f}% ({stats['completed']}/{stats['total_operations']})")
+        return stats
+
+    def _cleanup_old_operations(self) -> None:
+        """Remove old completed operations beyond max_history."""
+        completed_ops = sorted(
+            [op for op in self.operations.values() if op.state in (OperationState.COMPLETED, OperationState.FAILED, OperationState.CANCELLED)],
+            key=lambda x: x.completed_at or 0,
+        )
+
+        logging.debug(f"Checking for old operations to cleanup: {len(completed_ops)} completed, max_history={self.max_history}")
+
+        if len(completed_ops) > self.max_history:
+            to_remove = completed_ops[: len(completed_ops) - self.max_history]
+            logging.debug(f"Removing {len(to_remove)} old operations to maintain max_history limit")
+            for op in to_remove:
+                del self.operations[op.operation_id]
+
+            logging.info(f"Cleaned up {len(to_remove)} old operations (history size: {len(completed_ops)} -> {len(completed_ops) - len(to_remove)})")
+        else:
+            logging.debug(f"No cleanup needed: {len(completed_ops)} operations within max_history={self.max_history}")
+
+    def clear_completed_operations(self, older_than_seconds: Optional[float] = None) -> int:
+        """Clear completed operations.
+
+        Args:
+            older_than_seconds: Only clear operations older than this (None = all)
+
+        Returns:
+            Number of operations cleared
+        """
+        logging.debug(f"Clearing completed operations (older_than: {older_than_seconds}s)" if older_than_seconds else "Clearing all completed operations")
+
+        with self.lock:
+            now = time.time()
+            to_remove = []
+            total_completed = 0
+
+            for op_id, op in self.operations.items():
+                if op.state not in (
+                    OperationState.COMPLETED,
+                    OperationState.FAILED,
+                    OperationState.CANCELLED,
+                ):
+                    continue
+
+                total_completed += 1
+
+                if older_than_seconds is None:
+                    to_remove.append(op_id)
+                    logging.debug(f"Marking operation for removal: {op_id} (no age filter)")
+                elif op.completed_at and (now - op.completed_at) > older_than_seconds:
+                    age = now - op.completed_at
+                    to_remove.append(op_id)
+                    logging.debug(f"Marking operation for removal: {op_id} (age: {age:.1f}s > {older_than_seconds}s)")
+
+            logging.debug(f"Found {len(to_remove)} operations to remove out of {total_completed} completed")
+
+            for op_id in to_remove:
+                del self.operations[op_id]
+
+            if to_remove:
+                logging.info(f"Cleared {len(to_remove)} completed operations (remaining: {len(self.operations)})")
+            else:
+                logging.debug("No completed operations to clear")
+
+            return len(to_remove)

fbuild/daemon/port_state_manager.py

@@ -0,0 +1,249 @@
+"""
+Port State Manager - Tracks COM port state for visibility into daemon operations.
+
+This module provides the PortStateManager class which tracks the state of all
+COM ports in use by the daemon, providing visibility into which ports are in use,
+by whom, and in what state.
+"""
+
+import logging
+import threading
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class PortState(Enum):
+    """State of a serial port in use by the daemon."""
+
+    AVAILABLE = "available"  # Port not in use
+    UPLOADING = "uploading"  # Firmware being uploaded
+    MONITORING = "monitoring"  # Serial monitor active
+    RESERVED = "reserved"  # Reserved but not yet active
+
+
+@dataclass
+class PortInfo:
+    """Information about a port currently in use.
+
+    Attributes:
+        port: Port identifier (e.g., "COM3", "/dev/ttyUSB0")
+        state: Current state of the port
+        client_pid: PID of client using the port
+        project_dir: Project being deployed
+        environment: Environment name
+        operation_id: Request ID for the operation
+        acquired_at: When port was acquired (Unix timestamp)
+        last_activity: Last activity timestamp
+    """
+
+    port: str
+    state: PortState = PortState.AVAILABLE
+    client_pid: int | None = None
+    project_dir: str | None = None
+    environment: str | None = None
+    operation_id: str | None = None
+    acquired_at: float | None = None
+    last_activity: float | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "port": self.port,
+            "state": self.state.value,
+            "client_pid": self.client_pid,
+            "project_dir": self.project_dir,
+            "environment": self.environment,
+            "operation_id": self.operation_id,
+            "acquired_at": self.acquired_at,
+            "last_activity": self.last_activity,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PortInfo":
+        """Create PortInfo from dictionary."""
+        state_str = data.get("state", "available")
+        try:
+            state = PortState(state_str)
+        except ValueError:
+            state = PortState.AVAILABLE
+
+        return cls(
+            port=data["port"],
+            state=state,
+            client_pid=data.get("client_pid"),
+            project_dir=data.get("project_dir"),
+            environment=data.get("environment"),
+            operation_id=data.get("operation_id"),
+            acquired_at=data.get("acquired_at"),
+            last_activity=data.get("last_activity"),
+        )
+
+
+class PortStateManager:
+    """Tracks state of all COM ports in use by the daemon.
+
+    This class provides visibility into which ports are being used, by which
+    clients, and in what state. It is thread-safe and can be accessed from
+    multiple request handlers concurrently.
+
+    Example:
+        >>> manager = PortStateManager()
+        >>> manager.acquire_port(
+        ...     port="COM3",
+        ...     state=PortState.UPLOADING,
+        ...     client_pid=12345,
+        ...     project_dir="/path/to/project",
+        ...     environment="esp32c6",
+        ...     operation_id="deploy_123"
+        ... )
+        >>> info = manager.get_port_info("COM3")
+        >>> print(info.state)  # PortState.UPLOADING
+        >>> manager.update_state("COM3", PortState.MONITORING)
+        >>> manager.release_port("COM3")
+    """
+
+    def __init__(self) -> None:
+        """Initialize the PortStateManager."""
+        self._lock = threading.Lock()
+        self._ports: dict[str, PortInfo] = {}
+
+    def acquire_port(
+        self,
+        port: str,
+        state: PortState,
+        client_pid: int,
+        project_dir: str,
+        environment: str,
+        operation_id: str,
+    ) -> None:
+        """Mark a port as in use.
+
+        Args:
+            port: Port identifier (e.g., "COM3", "/dev/ttyUSB0")
+            state: Initial state for the port
+            client_pid: PID of client using the port
+            project_dir: Project being deployed
+            environment: Environment name
+            operation_id: Request ID for the operation
+        """
+        with self._lock:
+            current_time = time.time()
+            self._ports[port] = PortInfo(
+                port=port,
+                state=state,
+                client_pid=client_pid,
+                project_dir=project_dir,
+                environment=environment,
+                operation_id=operation_id,
+                acquired_at=current_time,
+                last_activity=current_time,
+            )
+            logging.debug(f"Port {port} acquired: state={state.value}, client_pid={client_pid}, operation_id={operation_id}")
+
+    def update_state(self, port: str, state: PortState) -> None:
+        """Update state of a port (e.g., UPLOADING -> MONITORING).
+
+        Args:
+            port: Port identifier
+            state: New state for the port
+        """
+        with self._lock:
+            if port in self._ports:
+                old_state = self._ports[port].state
+                self._ports[port].state = state
+                self._ports[port].last_activity = time.time()
+                logging.debug(f"Port {port} state updated: {old_state.value} -> {state.value}")
+            else:
+                logging.warning(f"Cannot update state for unknown port: {port}")
+
+    def release_port(self, port: str) -> None:
+        """Release a port back to available state.
+
+        Args:
+            port: Port identifier to release
+        """
+        with self._lock:
+            if port in self._ports:
+                info = self._ports[port]
+                del self._ports[port]
+                logging.debug(f"Port {port} released (was {info.state.value}, held for {time.time() - (info.acquired_at or 0):.1f}s)")
+            else:
+                logging.warning(f"Cannot release unknown port: {port}")
+
+    def get_port_info(self, port: str) -> PortInfo | None:
+        """Get info about a specific port.
+
+        Args:
+            port: Port identifier
+
+        Returns:
+            PortInfo for the port, or None if not tracked
+        """
+        with self._lock:
+            info = self._ports.get(port)
+            if info:
+                # Return a copy to avoid race conditions
+                return PortInfo(
+                    port=info.port,
+                    state=info.state,
+                    client_pid=info.client_pid,
+                    project_dir=info.project_dir,
+                    environment=info.environment,
+                    operation_id=info.operation_id,
+                    acquired_at=info.acquired_at,
+                    last_activity=info.last_activity,
+                )
+            return None
+
+    def get_all_ports(self) -> dict[str, PortInfo]:
+        """Get snapshot of all tracked ports.
+
+        Returns:
+            Dictionary mapping port names to PortInfo objects (copies)
+        """
+        with self._lock:
+            return {
+                port: PortInfo(
+                    port=info.port,
+                    state=info.state,
+                    client_pid=info.client_pid,
+                    project_dir=info.project_dir,
+                    environment=info.environment,
+                    operation_id=info.operation_id,
+                    acquired_at=info.acquired_at,
+                    last_activity=info.last_activity,
+                )
+                for port, info in self._ports.items()
+            }
+
+    def is_port_available(self, port: str) -> bool:
+        """Check if port is available for use.
+
+        Args:
+            port: Port identifier
+
+        Returns:
+            True if port is not tracked (available), False if in use
+        """
+        with self._lock:
+            return port not in self._ports
+
+    def get_ports_summary(self) -> dict[str, dict[str, Any]]:
+        """Get a summary of all port states for status reporting.
+
+        Returns:
+            Dictionary mapping port names to their info as dictionaries
+        """
+        with self._lock:
+            return {port: info.to_dict() for port, info in self._ports.items()}
+
+    def get_port_count(self) -> int:
+        """Get the number of ports currently tracked.
+
+        Returns:
+            Number of ports in use
+        """
+        with self._lock:
+            return len(self._ports)