fbuild 1.1.0__py3-none-any.whl

fbuild/daemon/error_collector.py

@@ -0,0 +1,263 @@
+"""
+Error Collector - Structured error collection for async operations.
+
+This module provides error collection and aggregation for asynchronous build
+operations, replacing simple exception handling with structured error tracking.
+"""
+
+import logging
+import threading
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+class ErrorSeverity(Enum):
+    """Severity level of a build error."""
+
+    WARNING = "warning"
+    ERROR = "error"
+    FATAL = "fatal"
+
+
+@dataclass
+class BuildError:
+    """Single build error."""
+
+    severity: ErrorSeverity
+    phase: str  # "download", "compile", "link", "upload"
+    file_path: Optional[str]
+    error_message: str
+    stderr: Optional[str] = None
+    stdout: Optional[str] = None
+    timestamp: float = field(default_factory=time.time)
+
+    def format(self) -> str:
+        """Format error as human-readable string.
+
+        Returns:
+            Formatted error message
+        """
+        lines = [f"[{self.severity.value.upper()}] {self.phase}: {self.error_message}"]
+
+        if self.file_path:
+            lines.append(f"  File: {self.file_path}")
+
+        if self.stderr:
+            # Truncate stderr to reasonable length
+            stderr_preview = self.stderr[:500]
+            if len(self.stderr) > 500:
+                stderr_preview += "... (truncated)"
+            lines.append(f"  stderr: {stderr_preview}")
+
+        return "\n".join(lines)
+
+
+class ErrorCollector:
+    """Collects errors during async build operations."""
+
+    def __init__(self, max_errors: int = 100):
+        """Initialize error collector.
+
+        Args:
+            max_errors: Maximum number of errors to collect
+        """
+        self.errors: list[BuildError] = []
+        self.lock = threading.Lock()
+        self.max_errors = max_errors
+
+        logging.debug(f"ErrorCollector initialized (max_errors={max_errors})")
+
+    def add_error(self, error: BuildError) -> None:
+        """Add error to collection.
+
+        Args:
+            error: Build error to add
+        """
+        with self.lock:
+            if len(self.errors) >= self.max_errors:
+                logging.warning(f"ErrorCollector full ({self.max_errors} errors), dropping oldest")
+                self.errors.pop(0)
+
+            self.errors.append(error)
+
+    def get_errors(self, severity: Optional[ErrorSeverity] = None) -> list[BuildError]:
+        """Get all errors, optionally filtered by severity.
+
+        Args:
+            severity: Filter by severity (None = all errors)
+
+        Returns:
+            List of build errors
+        """
+        logging.debug(f"Retrieving errors (severity filter: {severity.value if severity else 'None'})")
+        with self.lock:
+            if severity:
+                filtered = [e for e in self.errors if e.severity == severity]
+                logging.debug(f"Filtered {len(filtered)} errors by severity {severity.value} (total: {len(self.errors)})")
+                return filtered
+            logging.debug(f"Returning all {len(self.errors)} errors")
+            return self.errors.copy()
+
+    def get_errors_by_phase(self, phase: str) -> list[BuildError]:
+        """Get errors for a specific phase.
+
+        Args:
+            phase: Phase to filter by
+
+        Returns:
+            List of build errors for the phase
+        """
+        with self.lock:
+            phase_errors = [e for e in self.errors if e.phase == phase]
+            logging.debug(f"Found {len(phase_errors)} errors in phase '{phase}' (total: {len(self.errors)})")
+            return phase_errors
+
+    def has_fatal_errors(self) -> bool:
+        """Check if any fatal errors occurred.
+
+        Returns:
+            True if fatal errors exist
+        """
+        with self.lock:
+            has_fatal = any(e.severity == ErrorSeverity.FATAL for e in self.errors)
+            fatal_count = sum(1 for e in self.errors if e.severity == ErrorSeverity.FATAL)
+            logging.debug(f"Fatal error check result: {has_fatal} ({fatal_count} fatal errors)")
+            return has_fatal
+
+    def has_errors(self) -> bool:
+        """Check if any errors (non-warning) occurred.
+
+        Returns:
+            True if errors exist
+        """
+        logging.debug("Checking for errors (non-warning)")
+        with self.lock:
+            has_errs = any(e.severity in (ErrorSeverity.ERROR, ErrorSeverity.FATAL) for e in self.errors)
+            error_count = sum(1 for e in self.errors if e.severity in (ErrorSeverity.ERROR, ErrorSeverity.FATAL))
+            logging.debug(f"Error check result: {has_errs} ({error_count} errors or fatal)")
+            return has_errs
+
+    def has_warnings(self) -> bool:
+        """Check if any warnings occurred.
+
+        Returns:
+            True if warnings exist
+        """
+        with self.lock:
+            has_warn = any(e.severity == ErrorSeverity.WARNING for e in self.errors)
+            warning_count = sum(1 for e in self.errors if e.severity == ErrorSeverity.WARNING)
+            logging.debug(f"Warning check result: {has_warn} ({warning_count} warnings)")
+            return has_warn
+
+    def get_error_count(self) -> dict[str, int]:
+        """Get count of errors by severity.
+
+        Returns:
+            Dictionary with counts by severity
+        """
+        with self.lock:
+            counts = {
+                "warnings": sum(1 for e in self.errors if e.severity == ErrorSeverity.WARNING),
+                "errors": sum(1 for e in self.errors if e.severity == ErrorSeverity.ERROR),
+                "fatal": sum(1 for e in self.errors if e.severity == ErrorSeverity.FATAL),
+                "total": len(self.errors),
+            }
+        logging.debug(f"Error counts: {counts['total']} total ({counts['fatal']} fatal, {counts['errors']} errors, {counts['warnings']} warnings)")
+        return counts
+
+    def format_errors(self, max_errors: Optional[int] = None) -> str:
+        """Format all errors as human-readable string.
+
+        Args:
+            max_errors: Maximum number of errors to include (None = all)
+
+        Returns:
+            Formatted error report
+        """
+        logging.debug(f"Formatting errors (max_errors: {max_errors})")
+        with self.lock:
+            if not self.errors:
+                return "No errors"
+
+            errors_to_show = self.errors if max_errors is None else self.errors[:max_errors]
+            logging.debug(f"Formatting {len(errors_to_show)} errors (total: {len(self.errors)})")
+            lines = []
+
+            for err in errors_to_show:
+                lines.append(err.format())
+
+            if max_errors and len(self.errors) > max_errors:
+                lines.append(f"\n... and {len(self.errors) - max_errors} more errors")
+
+            # Add summary
+            counts = self.get_error_count()
+            summary = f"\nSummary: {counts['fatal']} fatal, {counts['errors']} errors, {counts['warnings']} warnings"
+            lines.append(summary)
+
+            formatted = "\n\n".join(lines)
+            logging.debug(f"Error formatting complete: {len(lines)} sections, {len(formatted)} characters")
+            return formatted
+
+    def format_summary(self) -> str:
+        """Format a brief summary of errors.
+
+        Returns:
+            Brief error summary
+        """
+        counts = self.get_error_count()
+        if counts["total"] == 0:
+            return "No errors"
+
+        parts = []
+        if counts["fatal"] > 0:
+            parts.append(f"{counts['fatal']} fatal")
+        if counts["errors"] > 0:
+            parts.append(f"{counts['errors']} errors")
+        if counts["warnings"] > 0:
+            parts.append(f"{counts['warnings']} warnings")
+
+        summary = ", ".join(parts)
+        return summary
+
+    def clear(self) -> None:
+        """Clear all collected errors."""
+        with self.lock:
+            error_count = len(self.errors)
+            self.errors.clear()
+
+        if error_count > 0:
+            logging.info(f"Cleared {error_count} errors")
+
+    def get_first_fatal_error(self) -> Optional[BuildError]:
+        """Get the first fatal error encountered.
+
+        Returns:
+            First fatal error or None
+        """
+        with self.lock:
+            for error in self.errors:
+                if error.severity == ErrorSeverity.FATAL:
+                    return error
+        return None
+
+    def get_compilation_errors(self) -> list[BuildError]:
+        """Get all compilation-phase errors.
+
+        Returns:
+            List of compilation errors
+        """
+        compilation_errors = self.get_errors_by_phase("compile")
+        logging.debug(f"Found {len(compilation_errors)} compilation errors")
+        return compilation_errors
+
+    def get_link_errors(self) -> list[BuildError]:
+        """Get all link-phase errors.
+
+        Returns:
+            List of link errors
+        """
+        link_errors = self.get_errors_by_phase("link")
+        logging.debug(f"Found {len(link_errors)} link errors")
+        return link_errors

fbuild/daemon/file_cache.py

@@ -0,0 +1,332 @@
+"""File-level incremental compilation cache.
+
+This module tracks source file changes for incremental compilation, allowing
+the build system to skip recompilation of unchanged files.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import threading
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class FileCache:
+    """Tracks source file changes for incremental compilation.
+
+    Uses SHA256 hashing to detect file changes and maintains a persistent cache
+    on disk. Thread-safe for concurrent use.
+    """
+
+    def __init__(self, cache_file: Path):
+        """Initialize file cache.
+
+        Args:
+            cache_file: Path to cache file (JSON format)
+        """
+        self.cache_file = cache_file
+        self.cache: dict[str, str] = {}
+        self.lock = threading.Lock()
+        self._load_cache()
+        logger.info(f"FileCache initialized with {len(self.cache)} cached entries")
+
+    def _load_cache(self):
+        """Load cache from disk."""
+        if not self.cache_file.exists():
+            return
+
+        try:
+            with open(self.cache_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            logger.debug(f"Parsed {len(data)} cache entries from JSON")
+            self.cache = data
+            logger.info(f"Loaded cache with {len(self.cache)} entries from {self.cache_file}")
+            if len(self.cache) > 0:
+                logger.debug(f"Sample cache keys: {list(self.cache.keys())[:3]}")
+        except json.JSONDecodeError as e:
+            logger.warning(f"Failed to parse cache JSON from {self.cache_file}: {e}")
+            self.cache = {}
+        except IOError as e:
+            logger.warning(f"Failed to read cache file {self.cache_file}: {e}")
+            self.cache = {}
+
+    def _save_cache(self):
+        """Save cache to disk atomically.
+
+        Uses atomic write pattern (temp file + rename) to prevent corruption.
+        """
+        logger.debug(f"Cache entries to save: {len(self.cache)}")
+
+        try:
+            # Ensure cache directory exists
+            self.cache_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write to temporary file
+            temp_file = self.cache_file.with_suffix(".tmp")
+            with open(temp_file, "w", encoding="utf-8") as f:
+                json.dump(self.cache, f, indent=2)
+
+            # Atomic rename
+            temp_file.replace(self.cache_file)
+
+            logger.debug(f"Saved cache with {len(self.cache)} entries to {self.cache_file}")
+
+        except IOError as e:
+            logger.error(f"Failed to save cache to {self.cache_file}: {e}")
+            logger.debug(f"Cache save error details: {type(e).__name__}: {e}")
+
+    def get_file_hash(self, file_path: Path) -> str:
+        """Calculate SHA256 hash of file contents.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            SHA256 hash as hex string
+
+        Raises:
+            FileNotFoundError: If file does not exist
+            IOError: If file cannot be read
+        """
+        sha256 = hashlib.sha256()
+        bytes_read = 0
+
+        try:
+            with open(file_path, "rb") as f:
+                # Read in chunks for memory efficiency
+                for chunk in iter(lambda: f.read(8192), b""):
+                    sha256.update(chunk)
+                    bytes_read += len(chunk)
+
+            hash_value = sha256.hexdigest()
+            logger.debug(f"File hash computed: {hash_value[:16]}... (read {bytes_read} bytes)")
+            return hash_value
+
+        except FileNotFoundError:
+            logger.error(f"File not found for hashing: {file_path}")
+            raise
+        except IOError as e:
+            logger.error(f"Failed to read file for hashing: {file_path}: {e}")
+            raise
+
+    def has_changed(self, file_path: Path) -> bool:
+        """Check if file has changed since last cache update.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            True if file has changed or not in cache, False otherwise
+        """
+
+        if not file_path.exists():
+            logger.warning(f"File does not exist: {file_path}")
+            return True
+
+        file_key = str(file_path.absolute())
+
+        with self.lock:
+            cached_hash = self.cache.get(file_key)
+
+        # File not in cache - consider it changed
+        if cached_hash is None:
+            return True
+
+        try:
+            current_hash = self.get_file_hash(file_path)
+            changed = current_hash != cached_hash
+
+            if changed:
+                logger.debug(f"File changed: {file_path} (cached: {cached_hash[:16]}..., current: {current_hash[:16]}...)")
+            else:
+                logger.debug(f"File unchanged: {file_path}")
+
+            return changed
+
+        except (FileNotFoundError, IOError):
+            # If we can't hash the file, assume it changed
+            return True
+
+    def update(self, file_path: Path):
+        """Update cache with current file hash.
+
+        Args:
+            file_path: Path to file
+        """
+
+        if not file_path.exists():
+            logger.warning(f"Cannot update cache for non-existent file: {file_path}")
+            return
+
+        try:
+            file_key = str(file_path.absolute())
+            current_hash = self.get_file_hash(file_path)
+
+            with self.lock:
+                was_cached = file_key in self.cache
+                self.cache[file_key] = current_hash
+                cache_size = len(self.cache)
+
+            logger.debug(f"Cache entry {'updated' if was_cached else 'added'}: {file_path} (total entries: {cache_size})")
+
+            with self.lock:
+                self._save_cache()
+
+        except (FileNotFoundError, IOError) as e:
+            logger.error(f"Failed to update cache for {file_path}: {e}")
+
+    def update_batch(self, file_paths: list[Path]):
+        """Update cache for multiple files efficiently.
+
+        Args:
+            file_paths: List of file paths to update
+        """
+        logger.info(f"Batch cache update starting: {len(file_paths)} files")
+        updated_count = 0
+        skipped_count = 0
+        failed_count = 0
+
+        for file_path in file_paths:
+            if not file_path.exists():
+                skipped_count += 1
+                continue
+
+            try:
+                file_key = str(file_path.absolute())
+                current_hash = self.get_file_hash(file_path)
+
+                with self.lock:
+                    self.cache[file_key] = current_hash
+                    updated_count += 1
+
+            except (FileNotFoundError, IOError) as e:
+                logger.warning(f"Failed to update cache for {file_path}: {e}")
+                failed_count += 1
+
+        # Save once after all updates
+        logger.debug(f"Saving batch cache update to disk ({updated_count} files updated)")
+        with self.lock:
+            self._save_cache()
+
+        logger.info(f"Batch cache update complete: {updated_count}/{len(file_paths)} files updated, {skipped_count} skipped, {failed_count} failed")
+        logger.debug(f"Total cache entries after batch update: {len(self.cache)}")
+
+    def needs_recompilation(self, source_path: Path, object_path: Path) -> bool:
+        """Check if source file needs recompilation.
+
+        A file needs recompilation if:
+        1. Object file doesn't exist
+        2. Source file has changed (cache check)
+        3. Object file is older than source file (mtime check)
+
+        Args:
+            source_path: Path to source file (.c, .cpp, etc.)
+            object_path: Path to object file (.o)
+
+        Returns:
+            True if recompilation needed, False otherwise
+        """
+
+        # Object doesn't exist - must compile
+        if not object_path.exists():
+            logger.debug("Reason: object file does not exist")
+            return True
+
+        # Source changed - must recompile
+        if self.has_changed(source_path):
+            logger.debug("Reason: source file hash differs from cache")
+            return True
+
+        # Object older than source - must recompile
+        try:
+            source_mtime = source_path.stat().st_mtime
+            object_mtime = object_path.stat().st_mtime
+
+            if object_mtime < source_mtime:
+                logger.debug(f"Reason: object mtime ({object_mtime}) < source mtime ({source_mtime})")
+                return True
+
+        except OSError as e:
+            logger.warning(f"Failed to check file times: {e} - assuming recompilation needed")
+            logger.debug(f"Reason: stat() failed with {type(e).__name__}")
+            return True
+
+        # No recompilation needed
+        logger.debug(f"Skipping unchanged file: {source_path} (all checks passed)")
+        return False
+
+    def invalidate(self, file_path: Path):
+        """Remove file from cache, forcing recompilation on next build.
+
+        Args:
+            file_path: Path to file
+        """
+        file_key = str(file_path.absolute())
+
+        with self.lock:
+            if file_key in self.cache:
+                del self.cache[file_key]
+                self._save_cache()
+                logger.info(f"Invalidated cache entry: {file_path} (total entries: {len(self.cache)})")
+            else:
+                logger.debug(f"Cache entry not found: {file_path}")
+
+    def clear(self):
+        """Clear entire cache."""
+        logger.info(f"Clearing entire cache (current entries: {len(self.cache)})")
+        with self.lock:
+            old_size = len(self.cache)
+            self.cache.clear()
+            self._save_cache()
+            logger.info(f"Cache cleared: removed {old_size} entries")
+
+    def get_statistics(self) -> dict[str, int]:
+        """Get cache statistics.
+
+        Returns:
+            Dictionary with cache statistics
+        """
+        with self.lock:
+            stats = {
+                "total_entries": len(self.cache),
+            }
+        return stats
+
+
+# Global file cache instance (initialized by daemon)
+_file_cache: Optional[FileCache] = None
+
+
+def get_file_cache() -> FileCache:
+    """Get global file cache instance.
+
+    Returns:
+        Global FileCache instance
+
+    Raises:
+        RuntimeError: If file cache not initialized
+    """
+    global _file_cache
+    if _file_cache is None:
+        raise RuntimeError("FileCache not initialized. Call init_file_cache() first.")
+    return _file_cache
+
+
+def init_file_cache(cache_file: Path) -> FileCache:
+    """Initialize global file cache.
+
+    Args:
+        cache_file: Path to cache file
+
+    Returns:
+        Initialized FileCache instance
+    """
+    global _file_cache
+    _file_cache = FileCache(cache_file=cache_file)
+    logger.info(f"FileCache initialized with cache file: {cache_file}")
+    return _file_cache