fbuild 1.1.0__py3-none-any.whl

fbuild/daemon/messages.py

@@ -0,0 +1,301 @@
+"""
+Typed message protocol for fbuild daemon operations.
+
+This module defines typed dataclasses for all client-daemon communication,
+ensuring type safety and validation.
+
+Supports:
+- Build operations (compilation and linking)
+- Deploy operations (firmware upload)
+- Monitor operations (serial monitoring)
+- Status updates and progress tracking
+"""
+
+import time
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class DaemonState(Enum):
+    """Daemon state enumeration."""
+
+    IDLE = "idle"
+    DEPLOYING = "deploying"
+    MONITORING = "monitoring"
+    BUILDING = "building"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    UNKNOWN = "unknown"
+
+    @classmethod
+    def from_string(cls, value: str) -> "DaemonState":
+        """Convert string to DaemonState, defaulting to UNKNOWN if invalid."""
+        try:
+            return cls(value)
+        except ValueError:
+            return cls.UNKNOWN
+
+
+class OperationType(Enum):
+    """Type of operation being performed."""
+
+    BUILD = "build"
+    DEPLOY = "deploy"
+    MONITOR = "monitor"
+    BUILD_AND_DEPLOY = "build_and_deploy"
+
+    @classmethod
+    def from_string(cls, value: str) -> "OperationType":
+        """Convert string to OperationType."""
+        return cls(value)
+
+
+@dataclass
+class DeployRequest:
+    """Client → Daemon: Deploy request message.
+
+    Attributes:
+        project_dir: Absolute path to project directory
+        environment: Build environment name
+        port: Serial port for deployment (optional, auto-detect if None)
+        clean_build: Whether to perform clean build
+        monitor_after: Whether to start monitor after deploy
+        monitor_timeout: Timeout for monitor in seconds (if monitor_after=True)
+        monitor_halt_on_error: Pattern to halt on error (if monitor_after=True)
+        monitor_halt_on_success: Pattern to halt on success (if monitor_after=True)
+        monitor_expect: Expected pattern to check at timeout/success (if monitor_after=True)
+        caller_pid: Process ID of requesting client
+        caller_cwd: Working directory of requesting client
+        timestamp: Unix timestamp when request was created
+        request_id: Unique identifier for this request
+    """
+
+    project_dir: str
+    environment: str
+    port: str | None
+    clean_build: bool
+    monitor_after: bool
+    monitor_timeout: float | None
+    monitor_halt_on_error: str | None
+    monitor_halt_on_success: str | None
+    monitor_expect: str | None
+    caller_pid: int
+    caller_cwd: str
+    timestamp: float = field(default_factory=time.time)
+    request_id: str = field(default_factory=lambda: f"deploy_{int(time.time() * 1000)}")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "DeployRequest":
+        """Create DeployRequest from dictionary."""
+        return cls(
+            project_dir=data["project_dir"],
+            environment=data["environment"],
+            port=data.get("port"),
+            clean_build=data.get("clean_build", False),
+            monitor_after=data.get("monitor_after", False),
+            monitor_timeout=data.get("monitor_timeout"),
+            monitor_halt_on_error=data.get("monitor_halt_on_error"),
+            monitor_halt_on_success=data.get("monitor_halt_on_success"),
+            monitor_expect=data.get("monitor_expect"),
+            caller_pid=data["caller_pid"],
+            caller_cwd=data["caller_cwd"],
+            timestamp=data.get("timestamp", time.time()),
+            request_id=data.get("request_id", f"deploy_{int(time.time() * 1000)}"),
+        )
+
+
+@dataclass
+class MonitorRequest:
+    """Client → Daemon: Monitor request message.
+
+    Attributes:
+        project_dir: Absolute path to project directory
+        environment: Build environment name
+        port: Serial port for monitoring (optional, auto-detect if None)
+        baud_rate: Serial baud rate (optional, use config default if None)
+        halt_on_error: Pattern to halt on (error detection)
+        halt_on_success: Pattern to halt on (success detection)
+        expect: Expected pattern to check at timeout/success
+        timeout: Maximum monitoring time in seconds
+        caller_pid: Process ID of requesting client
+        caller_cwd: Working directory of requesting client
+        timestamp: Unix timestamp when request was created
+        request_id: Unique identifier for this request
+    """
+
+    project_dir: str
+    environment: str
+    port: str | None
+    baud_rate: int | None
+    halt_on_error: str | None
+    halt_on_success: str | None
+    expect: str | None
+    timeout: float | None
+    caller_pid: int
+    caller_cwd: str
+    timestamp: float = field(default_factory=time.time)
+    request_id: str = field(default_factory=lambda: f"monitor_{int(time.time() * 1000)}")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "MonitorRequest":
+        """Create MonitorRequest from dictionary."""
+        return cls(
+            project_dir=data["project_dir"],
+            environment=data["environment"],
+            port=data.get("port"),
+            baud_rate=data.get("baud_rate"),
+            halt_on_error=data.get("halt_on_error"),
+            halt_on_success=data.get("halt_on_success"),
+            expect=data.get("expect"),
+            timeout=data.get("timeout"),
+            caller_pid=data["caller_pid"],
+            caller_cwd=data["caller_cwd"],
+            timestamp=data.get("timestamp", time.time()),
+            request_id=data.get("request_id", f"monitor_{int(time.time() * 1000)}"),
+        )
+
+
+@dataclass
+class BuildRequest:
+    """Client → Daemon: Build request message.
+
+    Attributes:
+        project_dir: Absolute path to project directory
+        environment: Build environment name
+        clean_build: Whether to perform clean build
+        verbose: Enable verbose build output
+        caller_pid: Process ID of requesting client
+        caller_cwd: Working directory of requesting client
+        timestamp: Unix timestamp when request was created
+        request_id: Unique identifier for this request
+    """
+
+    project_dir: str
+    environment: str
+    clean_build: bool
+    verbose: bool
+    caller_pid: int
+    caller_cwd: str
+    timestamp: float = field(default_factory=time.time)
+    request_id: str = field(default_factory=lambda: f"build_{int(time.time() * 1000)}")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "BuildRequest":
+        """Create BuildRequest from dictionary."""
+        return cls(
+            project_dir=data["project_dir"],
+            environment=data["environment"],
+            clean_build=data.get("clean_build", False),
+            verbose=data.get("verbose", False),
+            caller_pid=data["caller_pid"],
+            caller_cwd=data["caller_cwd"],
+            timestamp=data.get("timestamp", time.time()),
+            request_id=data.get("request_id", f"build_{int(time.time() * 1000)}"),
+        )
+
+
+@dataclass
+class DaemonStatus:
+    """Daemon → Client: Status update message.
+
+    Attributes:
+        state: Current daemon state
+        message: Human-readable status message
+        updated_at: Unix timestamp of last status update
+        operation_in_progress: Whether an operation is actively running
+        daemon_pid: Process ID of the daemon
+        daemon_started_at: Unix timestamp when daemon started
+        caller_pid: Process ID of client whose request is being processed
+        caller_cwd: Working directory of client whose request is being processed
+        request_id: ID of the request currently being processed
+        request_started_at: Unix timestamp when current request started
+        environment: Environment being processed
+        project_dir: Project directory for current operation
+        current_operation: Detailed description of current operation
+        operation_type: Type of operation (deploy/monitor)
+        output_lines: Recent output lines from the operation
+        exit_code: Process exit code (None if still running)
+        port: Serial port being used
+    """
+
+    state: DaemonState
+    message: str
+    updated_at: float
+    operation_in_progress: bool = False
+    daemon_pid: int | None = None
+    daemon_started_at: float | None = None
+    caller_pid: int | None = None
+    caller_cwd: str | None = None
+    request_id: str | None = None
+    request_started_at: float | None = None
+    environment: str | None = None
+    project_dir: str | None = None
+    current_operation: str | None = None
+    operation_type: OperationType | None = None
+    output_lines: list[str] = field(default_factory=list)
+    exit_code: int | None = None
+    port: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        result = asdict(self)
+        # Convert enums to string values
+        result["state"] = self.state.value
+        if self.operation_type:
+            result["operation_type"] = self.operation_type.value
+        else:
+            result["operation_type"] = None
+        return result
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "DaemonStatus":
+        """Create DaemonStatus from dictionary."""
+        # Convert state string to enum
+        state_str = data.get("state", "unknown")
+        state = DaemonState.from_string(state_str)
+
+        # Convert operation_type string to enum
+        operation_type = None
+        if data.get("operation_type"):
+            operation_type = OperationType.from_string(data["operation_type"])
+
+        return cls(
+            state=state,
+            message=data.get("message", ""),
+            updated_at=data.get("updated_at", time.time()),
+            operation_in_progress=data.get("operation_in_progress", False),
+            daemon_pid=data.get("daemon_pid"),
+            daemon_started_at=data.get("daemon_started_at"),
+            caller_pid=data.get("caller_pid"),
+            caller_cwd=data.get("caller_cwd"),
+            request_id=data.get("request_id"),
+            request_started_at=data.get("request_started_at"),
+            environment=data.get("environment"),
+            project_dir=data.get("project_dir"),
+            current_operation=data.get("current_operation"),
+            operation_type=operation_type,
+            output_lines=data.get("output_lines", []),
+            exit_code=data.get("exit_code"),
+            port=data.get("port"),
+        )
+
+    def is_stale(self, timeout_seconds: float = 30.0) -> bool:
+        """Check if status hasn't been updated recently."""
+        return (time.time() - self.updated_at) > timeout_seconds
+
+    def get_age_seconds(self) -> float:
+        """Get age of this status update in seconds."""
+        return time.time() - self.updated_at

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)