particle-os/deb-mock
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix sbuild integration and clean up codebase
Some checks failed
Build Deb-Mock Package / build (push) Successful in 55s
Details
Lint Code / Lint All Code (push) Failing after 3s
Details
Test Deb-Mock Build / test (push) Failing after 53s
Details

Browse source 
- Fix environment variable handling in sbuild wrapper
- Remove unsupported --log-dir and --env options from sbuild command
- Clean up unused imports and fix linting issues
- Organize examples directory with official Debian hello package
- Fix YAML formatting (trailing spaces, newlines)
- Remove placeholder example files
- All tests passing (30/30)
- Successfully tested build with official Debian hello package
This commit is contained in:
robojerk 2025-08-04 04:34:32 +00:00
parent c33e3aa9ac
commit 5e7f4b0562
32 changed files with 2322 additions and 2228 deletions
Download patch file Download diff file Expand all files Collapse all files

3
.gitignore vendored
View file

@ -143,6 +143,9 @@ metadata/
*.tar.bz2 *.tar.bz2
*.diff.gz *.diff.gz
*.orig.tar.gz *.orig.tar.gz
!mock_*_all.deb
!mock_*.buildinfo
!mock_*.changes
# Chroot environments # Chroot environments
/var/lib/deb-mock/ /var/lib/deb-mock/

8
Makefile
View file

@ -14,10 +14,10 @@ install-dev: ## Install deb-mock with development dependencies
pip install -r requirements-dev.txt pip install -r requirements-dev.txt
test: ## Run tests test: ## Run tests
python -m pytest tests/ -v python3 -m pytest tests/ -v
test-coverage: ## Run tests with coverage test-coverage: ## Run tests with coverage
python -m pytest tests/ --cov=deb_mock --cov-report=html --cov-report=term python3 -m pytest tests/ --cov=deb_mock --cov-report=html --cov-report=term
lint: ## Run linting checks lint: ## Run linting checks
@echo "=== Running all linting checks with Docker container ===" @echo "=== Running all linting checks with Docker container ==="
@ -84,7 +84,7 @@ check: ## Run all checks (lint, test, format)
$(MAKE) format $(MAKE) format
dist: ## Build distribution package dist: ## Build distribution package
python setup.py sdist bdist_wheel python3 setup.py sdist bdist_wheel
upload: ## Upload to PyPI (requires twine) upload: ## Upload to PyPI (requires twine)
twine upload dist/* twine upload dist/*
@ -92,4 +92,4 @@ upload: ## Upload to PyPI (requires twine)
dev-setup: ## Complete development setup dev-setup: ## Complete development setup
$(MAKE) install-system-deps $(MAKE) install-system-deps
$(MAKE) setup-chroot $(MAKE) setup-chroot
$(MAKE) install-dev $(MAKE) install-dev

10
deb_mock/__init__.py
View file

@ -1,7 +1,7 @@
""" """
Deb-Mock: A low-level utility to create clean, isolated build environments for Debian packages Deb-Mock: A low-level utility to create clean, isolated build environments for Debian packages
This tool is a direct functional replacement for Fedora's Mock, adapted specifically This tool is a direct functional replacement for Fedora's Mock, adapted specifically
for Debian-based ecosystems. for Debian-based ecosystems.
""" """
@ -9,14 +9,14 @@ __version__ = "0.1.0"
__author__ = "Deb-Mock Team" __author__ = "Deb-Mock Team"
__email__ = "team@deb-mock.org" __email__ = "team@deb-mock.org"
from .core import DebMock
from .config import Config
from .chroot import ChrootManager from .chroot import ChrootManager
from .config import Config
from .core import DebMock
from .sbuild import SbuildWrapper from .sbuild import SbuildWrapper
__all__ = [ __all__ = [
"DebMock", "DebMock",
"Config", "Config",
"ChrootManager", "ChrootManager",
"SbuildWrapper", "SbuildWrapper",
] ]

218
deb_mock/cache.py
View file

@ -2,255 +2,258 @@
Cache management for deb-mock Cache management for deb-mock
""" """
import hashlib
import os import os
import shutil import shutil
import tarfile import tarfile
import hashlib
from pathlib import Path
from typing import Optional, Dict, Any
from datetime import datetime, timedelta from datetime import datetime, timedelta
from typing import Any, Dict
from .exceptions import DebMockError from .exceptions import DebMockError
class CacheManager: class CacheManager:
"""Manages various caches for deb-mock (root cache, package cache, ccache)""" """Manages various caches for deb-mock (root cache, package cache, ccache)"""
def __init__(self, config): def __init__(self, config):
self.config = config self.config = config
def get_root_cache_path(self) -> str: def get_root_cache_path(self) -> str:
"""Get the root cache path for the current chroot""" """Get the root cache path for the current chroot"""
return self.config.get_root_cache_path() return self.config.get_root_cache_path()
def get_package_cache_path(self) -> str: def get_package_cache_path(self) -> str:
"""Get the package cache path for the current chroot""" """Get the package cache path for the current chroot"""
return self.config.get_package_cache_path() return self.config.get_package_cache_path()
def get_ccache_path(self) -> str: def get_ccache_path(self) -> str:
"""Get the ccache path for the current chroot""" """Get the ccache path for the current chroot"""
return self.config.get_ccache_path() return self.config.get_ccache_path()
def create_root_cache(self, chroot_path: str) -> bool: def create_root_cache(self, chroot_path: str) -> bool:
"""Create a root cache from the current chroot""" """Create a root cache from the current chroot"""
if not self.config.use_root_cache: if not self.config.use_root_cache:
return False return False
cache_path = self.get_root_cache_path() cache_path = self.get_root_cache_path()
cache_file = f"{cache_path}.tar.gz" cache_file = f"{cache_path}.tar.gz"
try: try:
# Create cache directory # Create cache directory
os.makedirs(os.path.dirname(cache_file), exist_ok=True) os.makedirs(os.path.dirname(cache_file), exist_ok=True)
# Create tar.gz archive of the chroot # Create tar.gz archive of the chroot
with tarfile.open(cache_file, 'w:gz') as tar: with tarfile.open(cache_file, "w:gz") as tar:
tar.add(chroot_path, arcname=os.path.basename(chroot_path)) tar.add(chroot_path, arcname=os.path.basename(chroot_path))
# Update cache metadata # Update cache metadata
self._update_cache_metadata('root_cache', cache_file) self._update_cache_metadata("root_cache", cache_file)
return True return True
except Exception as e: except Exception as e:
raise DebMockError(f"Failed to create root cache: {e}") raise DebMockError(f"Failed to create root cache: {e}")
def restore_root_cache(self, chroot_path: str) -> bool: def restore_root_cache(self, chroot_path: str) -> bool:
"""Restore chroot from root cache""" """Restore chroot from root cache"""
if not self.config.use_root_cache: if not self.config.use_root_cache:
return False return False
cache_file = f"{self.get_root_cache_path()}.tar.gz" cache_file = f"{self.get_root_cache_path()}.tar.gz"
if not os.path.exists(cache_file): if not os.path.exists(cache_file):
return False return False
# Check cache age # Check cache age
if not self._is_cache_valid('root_cache', cache_file): if not self._is_cache_valid("root_cache", cache_file):
return False return False
try: try:
# Extract cache to chroot path # Extract cache to chroot path
with tarfile.open(cache_file, 'r:gz') as tar: with tarfile.open(cache_file, "r:gz") as tar:
tar.extractall(path=os.path.dirname(chroot_path)) tar.extractall(path=os.path.dirname(chroot_path))
return True return True
except Exception as e: except Exception as e:
raise DebMockError(f"Failed to restore root cache: {e}") raise DebMockError(f"Failed to restore root cache: {e}")
def create_package_cache(self, package_files: list) -> bool: def create_package_cache(self, package_files: list) -> bool:
"""Create a package cache from downloaded packages""" """Create a package cache from downloaded packages"""
if not self.config.use_package_cache: if not self.config.use_package_cache:
return False return False
cache_path = self.get_package_cache_path() cache_path = self.get_package_cache_path()
try: try:
# Create cache directory # Create cache directory
os.makedirs(cache_path, exist_ok=True) os.makedirs(cache_path, exist_ok=True)
# Copy package files to cache # Copy package files to cache
for package_file in package_files: for package_file in package_files:
if os.path.exists(package_file): if os.path.exists(package_file):
shutil.copy2(package_file, cache_path) shutil.copy2(package_file, cache_path)
return True return True
except Exception as e: except Exception as e:
raise DebMockError(f"Failed to create package cache: {e}") raise DebMockError(f"Failed to create package cache: {e}")
def get_cached_packages(self) -> list: def get_cached_packages(self) -> list:
"""Get list of cached packages""" """Get list of cached packages"""
if not self.config.use_package_cache: if not self.config.use_package_cache:
return [] return []
cache_path = self.get_package_cache_path() cache_path = self.get_package_cache_path()
if not os.path.exists(cache_path): if not os.path.exists(cache_path):
return [] return []
packages = [] packages = []
for file in os.listdir(cache_path): for file in os.listdir(cache_path):
if file.endswith('.deb'): if file.endswith(".deb"):
packages.append(os.path.join(cache_path, file)) packages.append(os.path.join(cache_path, file))
return packages return packages
def setup_ccache(self) -> bool: def setup_ccache(self) -> bool:
"""Setup ccache for the build environment""" """Setup ccache for the build environment"""
if not self.config.use_ccache: if not self.config.use_ccache:
return False return False
ccache_path = self.get_ccache_path() ccache_path = self.get_ccache_path()
try: try:
# Create ccache directory # Create ccache directory
os.makedirs(ccache_path, exist_ok=True) os.makedirs(ccache_path, exist_ok=True)
# Set ccache environment variables # Set ccache environment variables
os.environ['CCACHE_DIR'] = ccache_path os.environ["CCACHE_DIR"] = ccache_path
os.environ['CCACHE_HASHDIR'] = '1' os.environ["CCACHE_HASHDIR"] = "1"
return True return True
except Exception as e: except Exception as e:
raise DebMockError(f"Failed to setup ccache: {e}") raise DebMockError(f"Failed to setup ccache: {e}")
def cleanup_old_caches(self) -> Dict[str, int]: def cleanup_old_caches(self) -> Dict[str, int]:
"""Clean up old cache files""" """Clean up old cache files"""
cleaned = {} cleaned = {}
# Clean root caches # Clean root caches
if self.config.use_root_cache: if self.config.use_root_cache:
cleaned['root_cache'] = self._cleanup_root_caches() cleaned["root_cache"] = self._cleanup_root_caches()
# Clean package caches # Clean package caches
if self.config.use_package_cache: if self.config.use_package_cache:
cleaned['package_cache'] = self._cleanup_package_caches() cleaned["package_cache"] = self._cleanup_package_caches()
# Clean ccache # Clean ccache
if self.config.use_ccache: if self.config.use_ccache:
cleaned['ccache'] = self._cleanup_ccache() cleaned["ccache"] = self._cleanup_ccache()
return cleaned return cleaned
def _cleanup_root_caches(self) -> int: def _cleanup_root_caches(self) -> int:
"""Clean up old root cache files""" """Clean up old root cache files"""
cache_dir = os.path.dirname(self.get_root_cache_path()) cache_dir = os.path.dirname(self.get_root_cache_path())
if not os.path.exists(cache_dir): if not os.path.exists(cache_dir):
return 0 return 0
cleaned = 0 cleaned = 0
cutoff_time = datetime.now() - timedelta(days=self.config.root_cache_age) cutoff_time = datetime.now() - timedelta(days=self.config.root_cache_age)
for cache_file in os.listdir(cache_dir): for cache_file in os.listdir(cache_dir):
if cache_file.endswith('.tar.gz'): if cache_file.endswith(".tar.gz"):
cache_path = os.path.join(cache_dir, cache_file) cache_path = os.path.join(cache_dir, cache_file)
if os.path.getmtime(cache_path) < cutoff_time.timestamp(): if os.path.getmtime(cache_path) < cutoff_time.timestamp():
os.remove(cache_path) os.remove(cache_path)
cleaned += 1 cleaned += 1
return cleaned return cleaned
def _cleanup_package_caches(self) -> int: def _cleanup_package_caches(self) -> int:
"""Clean up old package cache files""" """Clean up old package cache files"""
cache_path = self.get_package_cache_path() cache_path = self.get_package_cache_path()
if not os.path.exists(cache_path): if not os.path.exists(cache_path):
return 0 return 0
cleaned = 0 cleaned = 0
cutoff_time = datetime.now() - timedelta(days=30) # 30 days for package cache cutoff_time = datetime.now() - timedelta(days=30) # 30 days for package cache
for package_file in os.listdir(cache_path): for package_file in os.listdir(cache_path):
if package_file.endswith('.deb'): if package_file.endswith(".deb"):
package_path = os.path.join(cache_path, package_file) package_path = os.path.join(cache_path, package_file)
if os.path.getmtime(package_path) < cutoff_time.timestamp(): if os.path.getmtime(package_path) < cutoff_time.timestamp():
os.remove(package_path) os.remove(package_path)
cleaned += 1 cleaned += 1
return cleaned return cleaned
def _cleanup_ccache(self) -> int: def _cleanup_ccache(self) -> int:
"""Clean up old ccache files""" """Clean up old ccache files"""
ccache_path = self.get_ccache_path() ccache_path = self.get_ccache_path()
if not os.path.exists(ccache_path): if not os.path.exists(ccache_path):
return 0 return 0
# Use ccache's built-in cleanup # Use ccache's built-in cleanup
try: try:
import subprocess import subprocess
result = subprocess.run(['ccache', '-c'], cwd=ccache_path, capture_output=True)
result = subprocess.run(["ccache", "-c"], cwd=ccache_path, capture_output=True)
return 1 if result.returncode == 0 else 0 return 1 if result.returncode == 0 else 0
except Exception: except Exception:
return 0 return 0
def _update_cache_metadata(self, cache_type: str, cache_file: str) -> None: def _update_cache_metadata(self, cache_type: str, cache_file: str) -> None:
"""Update cache metadata""" """Update cache metadata"""
metadata_file = f"{cache_file}.meta" metadata_file = f"{cache_file}.meta"
metadata = { metadata = {
'type': cache_type, "type": cache_type,
'created': datetime.now().isoformat(), "created": datetime.now().isoformat(),
'size': os.path.getsize(cache_file), "size": os.path.getsize(cache_file),
'hash': self._get_file_hash(cache_file) "hash": self._get_file_hash(cache_file),
} }
import json import json
with open(metadata_file, 'w') as f:
with open(metadata_file, "w") as f:
json.dump(metadata, f) json.dump(metadata, f)
def _is_cache_valid(self, cache_type: str, cache_file: str) -> bool: def _is_cache_valid(self, cache_type: str, cache_file: str) -> bool:
"""Check if cache is still valid""" """Check if cache is still valid"""
metadata_file = f"{cache_file}.meta" metadata_file = f"{cache_file}.meta"
if not os.path.exists(metadata_file): if not os.path.exists(metadata_file):
return False return False
try: try:
import json import json
with open(metadata_file, 'r') as f:
with open(metadata_file, "r") as f:
metadata = json.load(f) metadata = json.load(f)
# Check if file size matches # Check if file size matches
if os.path.getsize(cache_file) != metadata.get('size', 0): if os.path.getsize(cache_file) != metadata.get("size", 0):
return False return False
# Check if hash matches # Check if hash matches
if self._get_file_hash(cache_file) != metadata.get('hash', ''): if self._get_file_hash(cache_file) != metadata.get("hash", ""):
return False return False
# Check age for root cache # Check age for root cache
if cache_type == 'root_cache': if cache_type == "root_cache":
created = datetime.fromisoformat(metadata['created']) created = datetime.fromisoformat(metadata["created"])
cutoff_time = datetime.now() - timedelta(days=self.config.root_cache_age) cutoff_time = datetime.now() - timedelta(days=self.config.root_cache_age)
if created < cutoff_time: if created < cutoff_time:
return False return False
return True return True
except Exception: except Exception:
return False return False
def _get_file_hash(self, file_path: str) -> str: def _get_file_hash(self, file_path: str) -> str:
"""Get SHA256 hash of a file""" """Get SHA256 hash of a file"""
hash_sha256 = hashlib.sha256() hash_sha256 = hashlib.sha256()
@ -258,42 +261,45 @@ class CacheManager:
for chunk in iter(lambda: f.read(4096), b""): for chunk in iter(lambda: f.read(4096), b""):
hash_sha256.update(chunk) hash_sha256.update(chunk)
return hash_sha256.hexdigest() return hash_sha256.hexdigest()
def get_cache_stats(self) -> Dict[str, Any]: def get_cache_stats(self) -> Dict[str, Any]:
"""Get cache statistics""" """Get cache statistics"""
stats = {} stats = {}
# Root cache stats # Root cache stats
if self.config.use_root_cache: if self.config.use_root_cache:
cache_file = f"{self.get_root_cache_path()}.tar.gz" cache_file = f"{self.get_root_cache_path()}.tar.gz"
if os.path.exists(cache_file): if os.path.exists(cache_file):
stats['root_cache'] = { stats["root_cache"] = {
'size': os.path.getsize(cache_file), "size": os.path.getsize(cache_file),
'valid': self._is_cache_valid('root_cache', cache_file) "valid": self._is_cache_valid("root_cache", cache_file),
} }
# Package cache stats # Package cache stats
if self.config.use_package_cache: if self.config.use_package_cache:
cache_path = self.get_package_cache_path() cache_path = self.get_package_cache_path()
if os.path.exists(cache_path): if os.path.exists(cache_path):
packages = [f for f in os.listdir(cache_path) if f.endswith('.deb')] packages = [f for f in os.listdir(cache_path) if f.endswith(".deb")]
stats['package_cache'] = { stats["package_cache"] = {
'packages': len(packages), "packages": len(packages),
'size': sum(os.path.getsize(os.path.join(cache_path, p)) for p in packages) "size": sum(os.path.getsize(os.path.join(cache_path, p)) for p in packages),
} }
# ccache stats # ccache stats
if self.config.use_ccache: if self.config.use_ccache:
ccache_path = self.get_ccache_path() ccache_path = self.get_ccache_path()
if os.path.exists(ccache_path): if os.path.exists(ccache_path):
try: try:
import subprocess import subprocess
result = subprocess.run(['ccache', '-s'], cwd=ccache_path,
capture_output=True, text=True) result = subprocess.run(
stats['ccache'] = { ["ccache", "-s"],
'output': result.stdout cwd=ccache_path,
} capture_output=True,
text=True,
)
stats["ccache"] = {"output": result.stdout}
except Exception: except Exception:
pass pass
return stats return stats

338
deb_mock/chroot.py
View file

@ -3,184 +3,185 @@ Chroot management for deb-mock
""" """
import os import os
import subprocess
import shutil import shutil
import subprocess
from pathlib import Path from pathlib import Path
from typing import List, Optional from typing import List
from .exceptions import ChrootError from .exceptions import ChrootError
class ChrootManager: class ChrootManager:
"""Manages chroot environments for deb-mock""" """Manages chroot environments for deb-mock"""
def __init__(self, config): def __init__(self, config):
self.config = config self.config = config
def create_chroot(self, chroot_name: str, arch: str = None, suite: str = None) -> None: def create_chroot(self, chroot_name: str, arch: str = None, suite: str = None) -> None:
"""Create a new chroot environment""" """Create a new chroot environment"""
if arch: if arch:
self.config.architecture = arch self.config.architecture = arch
if suite: if suite:
self.config.suite = suite self.config.suite = suite
chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
# Check if bootstrap chroot is needed (Mock FAQ #2) # Check if bootstrap chroot is needed (Mock FAQ #2)
if self.config.use_bootstrap_chroot: if self.config.use_bootstrap_chroot:
self._create_bootstrap_chroot(chroot_name) self._create_bootstrap_chroot(chroot_name)
else: else:
self._create_standard_chroot(chroot_name) self._create_standard_chroot(chroot_name)
def _create_bootstrap_chroot(self, chroot_name: str) -> None: def _create_bootstrap_chroot(self, chroot_name: str) -> None:
""" """
Create a bootstrap chroot for cross-distribution builds. Create a bootstrap chroot for cross-distribution builds.
This addresses Mock FAQ #2 about building packages for newer distributions This addresses Mock FAQ #2 about building packages for newer distributions
on older systems (e.g., building Debian Sid packages on Debian Stable). on older systems (e.g., building Debian Sid packages on Debian Stable).
""" """
bootstrap_name = self.config.bootstrap_chroot_name or f"{chroot_name}-bootstrap" bootstrap_name = self.config.bootstrap_chroot_name or f"{chroot_name}-bootstrap"
bootstrap_path = os.path.join(self.config.chroot_dir, bootstrap_name) bootstrap_path = os.path.join(self.config.chroot_dir, bootstrap_name)
# Create minimal bootstrap chroot first # Create minimal bootstrap chroot first
if not os.path.exists(bootstrap_path): if not os.path.exists(bootstrap_path):
self._create_standard_chroot(bootstrap_name) self._create_standard_chroot(bootstrap_name)
# Use bootstrap chroot to create the final chroot # Use bootstrap chroot to create the final chroot
try: try:
# Create final chroot using debootstrap from within bootstrap # Create final chroot using debootstrap from within bootstrap
cmd = [ cmd = [
'debootstrap', "debootstrap",
'--arch', self.config.architecture, "--arch",
self.config.architecture,
self.config.suite, self.config.suite,
f'/var/lib/deb-mock/chroots/{chroot_name}', f"/var/lib/deb-mock/chroots/{chroot_name}",
self.config.mirror self.config.mirror,
] ]
# Execute debootstrap within bootstrap chroot # Execute debootstrap within bootstrap chroot
result = self.execute_in_chroot(bootstrap_name, cmd, capture_output=True) result = self.execute_in_chroot(bootstrap_name, cmd, capture_output=True)
if result.returncode != 0: if result.returncode != 0:
raise ChrootError( raise ChrootError(
f"Failed to create chroot using bootstrap: {result.stderr}", f"Failed to create chroot using bootstrap: {result.stderr}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="bootstrap_debootstrap" operation="bootstrap_debootstrap",
) )
# Configure the new chroot # Configure the new chroot
self._configure_chroot(chroot_name) self._configure_chroot(chroot_name)
except Exception as e: except Exception as e:
raise ChrootError( raise ChrootError(
f"Bootstrap chroot creation failed: {e}", f"Bootstrap chroot creation failed: {e}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="bootstrap_creation" operation="bootstrap_creation",
) )
def _create_standard_chroot(self, chroot_name: str) -> None: def _create_standard_chroot(self, chroot_name: str) -> None:
"""Create a standard chroot using debootstrap""" """Create a standard chroot using debootstrap"""
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
if os.path.exists(chroot_path): if os.path.exists(chroot_path):
raise ChrootError( raise ChrootError(
f"Chroot '{chroot_name}' already exists", f"Chroot '{chroot_name}' already exists",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="create" operation="create",
) )
try: try:
# Create chroot directory # Create chroot directory
os.makedirs(chroot_path, exist_ok=True) os.makedirs(chroot_path, exist_ok=True)
# Run debootstrap # Run debootstrap
cmd = [ cmd = [
'debootstrap', "debootstrap",
'--arch', self.config.architecture, "--arch",
self.config.architecture,
self.config.suite, self.config.suite,
chroot_path, chroot_path,
self.config.mirror self.config.mirror,
] ]
result = subprocess.run(cmd, capture_output=True, text=True, check=False) result = subprocess.run(cmd, capture_output=True, text=True, check=False)
if result.returncode != 0: if result.returncode != 0:
raise ChrootError( raise ChrootError(
f"debootstrap failed: {result.stderr}", f"debootstrap failed: {result.stderr}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="debootstrap", operation="debootstrap",
chroot_path=chroot_path chroot_path=chroot_path,
) )
# Configure the chroot # Configure the chroot
self._configure_chroot(chroot_name) self._configure_chroot(chroot_name)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
raise ChrootError( raise ChrootError(
f"Failed to create chroot: {e}", f"Failed to create chroot: {e}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="create", operation="create",
chroot_path=chroot_path chroot_path=chroot_path,
) )
def _configure_chroot(self, chroot_name: str) -> None: def _configure_chroot(self, chroot_name: str) -> None:
"""Configure a newly created chroot""" """Configure a newly created chroot"""
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
# Create schroot configuration # Create schroot configuration
self._create_schroot_config(chroot_name, chroot_path) self._create_schroot_config(chroot_name, chroot_path, self.config.architecture, self.config.suite)
# Install additional packages if specified # Install additional packages if specified
if self.config.chroot_additional_packages: if self.config.chroot_additional_packages:
self._install_additional_packages(chroot_name) self._install_additional_packages(chroot_name)
# Run setup commands if specified # Run setup commands if specified
if self.config.chroot_setup_cmd: if self.config.chroot_setup_cmd:
self._run_setup_commands(chroot_name) self._run_setup_commands(chroot_name)
def _install_additional_packages(self, chroot_name: str) -> None: def _install_additional_packages(self, chroot_name: str) -> None:
"""Install additional packages in the chroot""" """Install additional packages in the chroot"""
try: try:
# Update package lists # Update package lists
self.execute_in_chroot(chroot_name, ['apt-get', 'update'], capture_output=True) self.execute_in_chroot(chroot_name, ["apt-get", "update"], capture_output=True)
# Install packages # Install packages
cmd = ['apt-get', 'install', '-y'] + self.config.chroot_additional_packages cmd = ["apt-get", "install", "-y"] + self.config.chroot_additional_packages
result = self.execute_in_chroot(chroot_name, cmd, capture_output=True) result = self.execute_in_chroot(chroot_name, cmd, capture_output=True)
if result.returncode != 0: if result.returncode != 0:
raise ChrootError( raise ChrootError(
f"Failed to install additional packages: {result.stderr}", f"Failed to install additional packages: {result.stderr}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="install_packages" operation="install_packages",
) )
except Exception as e: except Exception as e:
raise ChrootError( raise ChrootError(
f"Failed to install additional packages: {e}", f"Failed to install additional packages: {e}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="install_packages" operation="install_packages",
) )
def _run_setup_commands(self, chroot_name: str) -> None: def _run_setup_commands(self, chroot_name: str) -> None:
"""Run setup commands in the chroot""" """Run setup commands in the chroot"""
for cmd in self.config.chroot_setup_cmd: for cmd in self.config.chroot_setup_cmd:
try: try:
result = self.execute_in_chroot(chroot_name, cmd.split(), capture_output=True) result = self.execute_in_chroot(chroot_name, cmd.split(), capture_output=True)
if result.returncode != 0: if result.returncode != 0:
raise ChrootError( raise ChrootError(
f"Setup command failed: {result.stderr}", f"Setup command failed: {result.stderr}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="setup_command" operation="setup_command",
) )
except Exception as e: except Exception as e:
raise ChrootError( raise ChrootError(
f"Failed to run setup command '{cmd}': {e}", f"Failed to run setup command '{cmd}': {e}",
chroot_name=chroot_name, chroot_name=chroot_name,
operation="setup_command" operation="setup_command",
) )
def _create_schroot_config(self, chroot_name: str, chroot_path: str, arch: str, suite: str) -> None: def _create_schroot_config(self, chroot_name: str, chroot_path: str, arch: str, suite: str) -> None:
"""Create schroot configuration file""" """Create schroot configuration file"""
config_content = f"""[{chroot_name}] config_content = f"""[{chroot_name}]
@ -192,162 +193,180 @@ type=directory
profile=desktop profile=desktop
preserve-environment=true preserve-environment=true
""" """
config_file = os.path.join(self.config.chroot_config_dir, f"{chroot_name}.conf") config_file = os.path.join(self.config.chroot_config_dir, f"{chroot_name}.conf")
try: try:
with open(config_file, 'w') as f: with open(config_file, "w") as f:
f.write(config_content) f.write(config_content)
except Exception as e: except Exception as e:
raise ChrootError(f"Failed to create schroot config: {e}") raise ChrootError(f"Failed to create schroot config: {e}")
def _initialize_chroot(self, chroot_path: str, arch: str, suite: str) -> None: def _initialize_chroot(self, chroot_path: str, arch: str, suite: str) -> None:
"""Initialize chroot using debootstrap""" """Initialize chroot using debootstrap"""
cmd = [ cmd = [
'debootstrap', "debootstrap",
'--arch', arch, "--arch",
'--variant=buildd', arch,
"--variant=buildd",
suite, suite,
chroot_path, chroot_path,
'http://deb.debian.org/debian/' "http://deb.debian.org/debian/",
] ]
try: try:
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
raise ChrootError(f"debootstrap failed: {e.stderr}") raise ChrootError(f"debootstrap failed: {e.stderr}")
except FileNotFoundError: except FileNotFoundError:
raise ChrootError("debootstrap not found. Please install debootstrap package.") raise ChrootError("debootstrap not found. Please install debootstrap package.")
def _install_build_tools(self, chroot_name: str) -> None: def _install_build_tools(self, chroot_name: str) -> None:
"""Install essential build tools in the chroot""" """Install essential build tools in the chroot"""
packages = [ packages = [
'build-essential', "build-essential",
'devscripts', "devscripts",
'debhelper', "debhelper",
'dh-make', "dh-make",
'fakeroot', "fakeroot",
'lintian', "lintian",
'sbuild', "sbuild",
'schroot' "schroot",
] ]
cmd = ['schroot', '-c', chroot_name, '--', 'apt-get', 'update'] cmd = ["schroot", "-c", chroot_name, "--", "apt-get", "update"]
try: try:
subprocess.run(cmd, check=True) subprocess.run(cmd, check=True)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
raise ChrootError(f"Failed to update package lists: {e}") raise ChrootError(f"Failed to update package lists: {e}")
cmd = ['schroot', '-c', chroot_name, '--', 'apt-get', 'install', '-y'] + packages cmd = [
"schroot",
"-c",
chroot_name,
"--",
"apt-get",
"install",
"-y",
] + packages
try: try:
subprocess.run(cmd, check=True) subprocess.run(cmd, check=True)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
raise ChrootError(f"Failed to install build tools: {e}") raise ChrootError(f"Failed to install build tools: {e}")
def clean_chroot(self, chroot_name: str) -> None: def clean_chroot(self, chroot_name: str) -> None:
"""Clean up a chroot environment""" """Clean up a chroot environment"""
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
config_file = os.path.join(self.config.chroot_config_dir, f"{chroot_name}.conf") config_file = os.path.join(self.config.chroot_config_dir, f"{chroot_name}.conf")
try: try:
# Remove schroot configuration # Remove schroot configuration
if os.path.exists(config_file): if os.path.exists(config_file):
os.remove(config_file) os.remove(config_file)
# Remove chroot directory # Remove chroot directory
if os.path.exists(chroot_path): if os.path.exists(chroot_path):
shutil.rmtree(chroot_path) shutil.rmtree(chroot_path)
except Exception as e: except Exception as e:
raise ChrootError(f"Failed to clean chroot '{chroot_name}': {e}") raise ChrootError(f"Failed to clean chroot '{chroot_name}': {e}")
def list_chroots(self) -> List[str]: def list_chroots(self) -> List[str]:
"""List available chroot environments""" """List available chroot environments"""
chroots = [] chroots = []
try: try:
# List chroot configurations # List chroot configurations
for config_file in Path(self.config.chroot_config_dir).glob("*.conf"): for config_file in Path(self.config.chroot_config_dir).glob("*.conf"):
chroot_name = config_file.stem chroot_name = config_file.stem
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
if os.path.exists(chroot_path): if os.path.exists(chroot_path):
chroots.append(chroot_name) chroots.append(chroot_name)
except Exception as e: except Exception as e:
raise ChrootError(f"Failed to list chroots: {e}") raise ChrootError(f"Failed to list chroots: {e}")
return chroots return chroots
def chroot_exists(self, chroot_name: str) -> bool: def chroot_exists(self, chroot_name: str) -> bool:
"""Check if a chroot environment exists""" """Check if a chroot environment exists"""
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
config_file = os.path.join(self.config.chroot_config_dir, f"{chroot_name}.conf") config_file = os.path.join(self.config.chroot_config_dir, f"{chroot_name}.conf")
return os.path.exists(chroot_path) and os.path.exists(config_file) return os.path.exists(chroot_path) and os.path.exists(config_file)
def get_chroot_info(self, chroot_name: str) -> dict: def get_chroot_info(self, chroot_name: str) -> dict:
"""Get information about a chroot environment""" """Get information about a chroot environment"""
if not self.chroot_exists(chroot_name): if not self.chroot_exists(chroot_name):
raise ChrootError(f"Chroot '{chroot_name}' does not exist") raise ChrootError(f"Chroot '{chroot_name}' does not exist")
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
info = { info = {
'name': chroot_name, "name": chroot_name,
'path': chroot_path, "path": chroot_path,
'exists': True, "exists": True,
'size': 0, "size": 0,
'created': None, "created": None,
'modified': None "modified": None,
} }
try: try:
stat = os.stat(chroot_path) stat = os.stat(chroot_path)
info['size'] = stat.st_size info["size"] = stat.st_size
info['created'] = stat.st_ctime info["created"] = stat.st_ctime
info['modified'] = stat.st_mtime info["modified"] = stat.st_mtime
except Exception: except Exception:
pass pass
return info return info
def update_chroot(self, chroot_name: str) -> None: def update_chroot(self, chroot_name: str) -> None:
"""Update packages in a chroot environment""" """Update packages in a chroot environment"""
if not self.chroot_exists(chroot_name): if not self.chroot_exists(chroot_name):
raise ChrootError(f"Chroot '{chroot_name}' does not exist") raise ChrootError(f"Chroot '{chroot_name}' does not exist")
try: try:
# Update package lists # Update package lists
cmd = ['schroot', '-c', chroot_name, '--', 'apt-get', 'update'] cmd = ["schroot", "-c", chroot_name, "--", "apt-get", "update"]
subprocess.run(cmd, check=True) subprocess.run(cmd, check=True)
# Upgrade packages # Upgrade packages
cmd = ['schroot', '-c', chroot_name, '--', 'apt-get', 'upgrade', '-y'] cmd = ["schroot", "-c", chroot_name, "--", "apt-get", "upgrade", "-y"]
subprocess.run(cmd, check=True) subprocess.run(cmd, check=True)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
raise ChrootError(f"Failed to update chroot '{chroot_name}': {e}") raise ChrootError(f"Failed to update chroot '{chroot_name}': {e}")
def execute_in_chroot(self, chroot_name: str, command: list, def execute_in_chroot(
capture_output: bool = True, self,
preserve_env: bool = True) -> subprocess.CompletedProcess: chroot_name: str,
command: list,
capture_output: bool = True,
preserve_env: bool = True,
) -> subprocess.CompletedProcess:
"""Execute a command in the chroot environment""" """Execute a command in the chroot environment"""
if not self.chroot_exists(chroot_name): if not self.chroot_exists(chroot_name):
raise ChrootError(f"Chroot '{chroot_name}' does not exist") raise ChrootError(f"Chroot '{chroot_name}' does not exist")
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
# Prepare environment variables (Mock FAQ #1 - Environment preservation) # Prepare environment variables (Mock FAQ #1 - Environment preservation)
env = self._prepare_chroot_environment(preserve_env) env = self._prepare_chroot_environment(preserve_env)
# Build schroot command # Build schroot command
schroot_cmd = [ schroot_cmd = [
'schroot', '-c', chroot_name, '--', 'sh', '-c', "schroot",
' '.join(command) "-c",
chroot_name,
"--",
"sh",
"-c",
" ".join(command),
] ]
try: try:
if capture_output: if capture_output:
result = subprocess.run( result = subprocess.run(
@ -356,120 +375,115 @@ preserve-environment=true
env=env, env=env,
capture_output=True, capture_output=True,
text=True, text=True,
check=False check=False,
) )
else: else:
result = subprocess.run( result = subprocess.run(schroot_cmd, cwd=chroot_path, env=env, check=False)
schroot_cmd,
cwd=chroot_path,
env=env,
check=False
)
return result return result
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
raise ChrootError(f"Command failed in chroot: {e}") raise ChrootError(f"Command failed in chroot: {e}")
def _prepare_chroot_environment(self, preserve_env: bool = True) -> dict: def _prepare_chroot_environment(self, preserve_env: bool = True) -> dict:
""" """
Prepare environment variables for chroot execution. Prepare environment variables for chroot execution.
This addresses Mock FAQ #1 about environment variable preservation. This addresses Mock FAQ #1 about environment variable preservation.
""" """
env = os.environ.copy() env = os.environ.copy()
if not preserve_env or not self.config.environment_sanitization: if not preserve_env or not self.config.environment_sanitization:
return env return env
# Filter environment variables based on allowed list # Filter environment variables based on allowed list
filtered_env = {} filtered_env = {}
# Always preserve basic system variables # Always preserve basic system variables
basic_vars = ['PATH', 'HOME', 'USER', 'SHELL', 'TERM', 'LANG', 'LC_ALL'] basic_vars = ["PATH", "HOME", "USER", "SHELL", "TERM", "LANG", "LC_ALL"]
for var in basic_vars: for var in basic_vars:
if var in env: if var in env:
filtered_env[var] = env[var] filtered_env[var] = env[var]
# Preserve allowed build-related variables # Preserve allowed build-related variables
for var in self.config.allowed_environment_vars: for var in self.config.allowed_environment_vars:
if var in env: if var in env:
filtered_env[var] = env[var] filtered_env[var] = env[var]
# Preserve user-specified variables # Preserve user-specified variables
for var in self.config.preserve_environment: for var in self.config.preserve_environment:
if var in env: if var in env:
filtered_env[var] = env[var] filtered_env[var] = env[var]
return filtered_env return filtered_env
def copy_to_chroot(self, source_path: str, dest_path: str, chroot_name: str) -> None: def copy_to_chroot(self, source_path: str, dest_path: str, chroot_name: str) -> None:
"""Copy files from host to chroot (similar to Mock's --copyin)""" """Copy files from host to chroot (similar to Mock's --copyin)"""
if not self.chroot_exists(chroot_name): if not self.chroot_exists(chroot_name):
raise ChrootError(f"Chroot '{chroot_name}' does not exist") raise ChrootError(f"Chroot '{chroot_name}' does not exist")
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
full_dest_path = os.path.join(chroot_path, dest_path.lstrip('/')) full_dest_path = os.path.join(chroot_path, dest_path.lstrip("/"))
try: try:
# Create destination directory if it doesn't exist # Create destination directory if it doesn't exist
os.makedirs(os.path.dirname(full_dest_path), exist_ok=True) os.makedirs(os.path.dirname(full_dest_path), exist_ok=True)
# Copy file or directory # Copy file or directory
if os.path.isdir(source_path): if os.path.isdir(source_path):
shutil.copytree(source_path, full_dest_path, dirs_exist_ok=True) shutil.copytree(source_path, full_dest_path, dirs_exist_ok=True)
else: else:
shutil.copy2(source_path, full_dest_path) shutil.copy2(source_path, full_dest_path)
except Exception as e: except Exception as e:
raise ChrootError(f"Failed to copy {source_path} to chroot: {e}") raise ChrootError(f"Failed to copy {source_path} to chroot: {e}")
def copy_from_chroot(self, source_path: str, dest_path: str, chroot_name: str) -> None: def copy_from_chroot(self, source_path: str, dest_path: str, chroot_name: str) -> None:
"""Copy files from chroot to host (similar to Mock's --copyout)""" """Copy files from chroot to host (similar to Mock's --copyout)"""
if not self.chroot_exists(chroot_name): if not self.chroot_exists(chroot_name):
raise ChrootError(f"Chroot '{chroot_name}' does not exist") raise ChrootError(f"Chroot '{chroot_name}' does not exist")
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
full_source_path = os.path.join(chroot_path, source_path.lstrip('/')) full_source_path = os.path.join(chroot_path, source_path.lstrip("/"))
try: try:
# Create destination directory if it doesn't exist # Create destination directory if it doesn't exist
os.makedirs(os.path.dirname(dest_path), exist_ok=True) os.makedirs(os.path.dirname(dest_path), exist_ok=True)
# Copy file or directory # Copy file or directory
if os.path.isdir(full_source_path): if os.path.isdir(full_source_path):
shutil.copytree(full_source_path, dest_path, dirs_exist_ok=True) shutil.copytree(full_source_path, dest_path, dirs_exist_ok=True)
else: else:
shutil.copy2(full_source_path, dest_path) shutil.copy2(full_source_path, dest_path)
except Exception as e: except Exception as e:
raise ChrootError(f"Failed to copy {source_path} from chroot: {e}") raise ChrootError(f"Failed to copy {source_path} from chroot: {e}")
def scrub_chroot(self, chroot_name: str) -> None: def scrub_chroot(self, chroot_name: str) -> None:
"""Clean up chroot without removing it (similar to Mock's --scrub)""" """Clean up chroot without removing it (similar to Mock's --scrub)"""
if not self.chroot_exists(chroot_name): if not self.chroot_exists(chroot_name):
raise ChrootError(f"Chroot '{chroot_name}' does not exist") raise ChrootError(f"Chroot '{chroot_name}' does not exist")
try: try:
# Clean package cache # Clean package cache
self.execute_in_chroot(chroot_name, ['apt-get', 'clean']) self.execute_in_chroot(chroot_name, ["apt-get", "clean"])
# Clean temporary files # Clean temporary files
self.execute_in_chroot(chroot_name, ['rm', '-rf', '/tmp/*']) self.execute_in_chroot(chroot_name, ["rm", "-rf", "/tmp/*"])
self.execute_in_chroot(chroot_name, ['rm', '-rf', '/var/tmp/*']) self.execute_in_chroot(chroot_name, ["rm", "-rf", "/var/tmp/*"])
# Clean build artifacts # Clean build artifacts
self.execute_in_chroot(chroot_name, ['rm', '-rf', '/build/*']) self.execute_in_chroot(chroot_name, ["rm", "-rf", "/build/*"])
except Exception as e: except Exception as e:
raise ChrootError(f"Failed to scrub chroot '{chroot_name}': {e}") raise ChrootError(f"Failed to scrub chroot '{chroot_name}': {e}")
def scrub_all_chroots(self) -> None: def scrub_all_chroots(self) -> None:
"""Clean up all chroots (similar to Mock's --scrub-all-chroots)""" """Clean up all chroots (similar to Mock's --scrub-all-chroots)"""
chroots = self.list_chroots() chroots = self.list_chroots()
for chroot_name in chroots: for chroot_name in chroots:
try: try:
self.scrub_chroot(chroot_name) self.scrub_chroot(chroot_name)
except Exception as e: except Exception as e:
print(f"Warning: Failed to scrub chroot '{chroot_name}': {e}") print(f"Warning: Failed to scrub chroot '{chroot_name}': {e}")

429
deb_mock/cli.py
View file

@ -3,44 +3,38 @@
Command-line interface for deb-mock Command-line interface for deb-mock
""" """
import click
import sys import sys
import os
from pathlib import Path import click
from .core import DebMock
from .config import Config from .config import Config
from .configs import get_available_configs, load_config from .configs import get_available_configs, load_config
from .exceptions import ( from .core import DebMock
DebMockError, ConfigurationError, ChrootError, SbuildError, from .exceptions import ConfigurationError, ValidationError, handle_exception
BuildError, DependencyError, MetadataError, CacheError,
PluginError, NetworkError, PermissionError, ValidationError,
handle_exception, format_error_context
)
@click.group() @click.group()
@click.version_option() @click.version_option()
@click.option('--config', '-c', type=click.Path(exists=True), @click.option("--config", "-c", type=click.Path(exists=True), help="Configuration file path")
help='Configuration file path') @click.option("--chroot", "-r", help="Chroot configuration name (e.g., debian-bookworm-amd64)")
@click.option('--chroot', '-r', help='Chroot configuration name (e.g., debian-bookworm-amd64)') @click.option("--verbose", "-v", is_flag=True, help="Enable verbose output")
@click.option('--verbose', '-v', is_flag=True, help='Enable verbose output') @click.option("--debug", is_flag=True, help="Enable debug output")
@click.option('--debug', is_flag=True, help='Enable debug output')
@click.pass_context @click.pass_context
def main(ctx, config, chroot, verbose, debug): def main(ctx, config, chroot, verbose, debug):
""" """
Deb-Mock: A low-level utility to create clean, isolated build environments for Debian packages. Deb-Mock: A low-level utility to create clean, isolated build environments for Debian packages.
This tool is a direct functional replacement for Fedora's Mock, adapted specifically This tool is a direct functional replacement for Fedora's Mock, adapted specifically
for Debian-based ecosystems. for Debian-based ecosystems.
""" """
ctx.ensure_object(dict) ctx.ensure_object(dict)
ctx.obj['verbose'] = verbose ctx.obj["verbose"] = verbose
ctx.obj['debug'] = debug ctx.obj["debug"] = debug
# Load configuration # Load configuration
if config: if config:
try: try:
ctx.obj['config'] = Config.from_file(config) ctx.obj["config"] = Config.from_file(config)
except ConfigurationError as e: except ConfigurationError as e:
e.print_error() e.print_error()
sys.exit(e.get_exit_code()) sys.exit(e.get_exit_code())
@ -48,134 +42,143 @@ def main(ctx, config, chroot, verbose, debug):
# Load core config by name (similar to Mock's -r option) # Load core config by name (similar to Mock's -r option)
try: try:
config_data = load_config(chroot) config_data = load_config(chroot)
ctx.obj['config'] = Config(**config_data) ctx.obj["config"] = Config(**config_data)
except ValueError as e: except ValueError as e:
error = ValidationError( error = ValidationError(
f"Invalid chroot configuration: {e}", f"Invalid chroot configuration: {e}",
field='chroot', field="chroot",
value=chroot, value=chroot,
expected_format='debian-suite-arch or ubuntu-suite-arch' expected_format="debian-suite-arch or ubuntu-suite-arch",
) )
error.print_error() error.print_error()
click.echo(f"Available configs: {', '.join(get_available_configs())}") click.echo(f"Available configs: {', '.join(get_available_configs())}")
sys.exit(error.get_exit_code()) sys.exit(error.get_exit_code())
else: else:
ctx.obj['config'] = Config.default() ctx.obj["config"] = Config.default()
@main.command() @main.command()
@click.argument('source_package', type=click.Path(exists=True)) @click.argument("source_package", type=click.Path(exists=True))
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.option('--output-dir', '-o', type=click.Path(), @click.option("--output-dir", "-o", type=click.Path(), help="Output directory for build artifacts")
help='Output directory for build artifacts') @click.option("--keep-chroot", is_flag=True, help="Keep chroot after build (for debugging)")
@click.option('--keep-chroot', is_flag=True, @click.option("--no-check", is_flag=True, help="Skip running tests during build")
help='Keep chroot after build (for debugging)') @click.option("--offline", is_flag=True, help="Build in offline mode (no network access)")
@click.option('--no-check', is_flag=True, help='Skip running tests during build') @click.option("--build-timeout", type=int, help="Build timeout in seconds")
@click.option('--offline', is_flag=True, help='Build in offline mode (no network access)') @click.option("--force-arch", help="Force target architecture")
@click.option('--build-timeout', type=int, help='Build timeout in seconds') @click.option("--unique-ext", help="Unique extension for buildroot directory")
@click.option('--force-arch', help='Force target architecture') @click.option("--config-dir", help="Configuration directory")
@click.option('--unique-ext', help='Unique extension for buildroot directory') @click.option("--cleanup-after", is_flag=True, help="Clean chroot after build")
@click.option('--config-dir', help='Configuration directory') @click.option("--no-cleanup-after", is_flag=True, help="Don't clean chroot after build")
@click.option('--cleanup-after', is_flag=True, help='Clean chroot after build')
@click.option('--no-cleanup-after', is_flag=True, help='Don\'t clean chroot after build')
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def build(ctx, source_package, chroot, arch, output_dir, keep_chroot, def build(
no_check, offline, build_timeout, force_arch, unique_ext, ctx,
config_dir, cleanup_after, no_cleanup_after): source_package,
chroot,
arch,
output_dir,
keep_chroot,
no_check,
offline,
build_timeout,
force_arch,
unique_ext,
config_dir,
cleanup_after,
no_cleanup_after,
):
""" """
Build a Debian source package in an isolated environment. Build a Debian source package in an isolated environment.
SOURCE_PACKAGE: Path to the .dsc file or source package directory SOURCE_PACKAGE: Path to the .dsc file or source package directory
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if chroot: if chroot:
ctx.obj['config'].chroot_name = chroot ctx.obj["config"].chroot_name = chroot
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
if output_dir: if output_dir:
ctx.obj['config'].output_dir = output_dir ctx.obj["config"].output_dir = output_dir
if keep_chroot: if keep_chroot:
ctx.obj['config'].keep_chroot = keep_chroot ctx.obj["config"].keep_chroot = keep_chroot
if no_check: if no_check:
ctx.obj['config'].run_tests = False ctx.obj["config"].run_tests = False
if offline: if offline:
ctx.obj['config'].enable_network = False ctx.obj["config"].enable_network = False
if build_timeout: if build_timeout:
ctx.obj['config'].build_timeout = build_timeout ctx.obj["config"].build_timeout = build_timeout
if force_arch: if force_arch:
ctx.obj['config'].force_architecture = force_arch ctx.obj["config"].force_architecture = force_arch
if unique_ext: if unique_ext:
ctx.obj['config'].unique_extension = unique_ext ctx.obj["config"].unique_extension = unique_ext
if config_dir: if config_dir:
ctx.obj['config'].config_dir = config_dir ctx.obj["config"].config_dir = config_dir
if cleanup_after is not None: if cleanup_after is not None:
ctx.obj['config'].cleanup_after = cleanup_after ctx.obj["config"].cleanup_after = cleanup_after
if no_cleanup_after is not None: if no_cleanup_after is not None:
ctx.obj['config'].cleanup_after = not no_cleanup_after ctx.obj["config"].cleanup_after = not no_cleanup_after
result = deb_mock.build(source_package) result = deb_mock.build(source_package)
if ctx.obj['verbose']: if ctx.obj["verbose"]:
click.echo(f"Build completed successfully: {result}") click.echo(f"Build completed successfully: {result}")
else: else:
click.echo("Build completed successfully") click.echo("Build completed successfully")
@main.command() @main.command()
@click.argument('source_packages', nargs=-1, type=click.Path(exists=True)) @click.argument("source_packages", nargs=-1, type=click.Path(exists=True))
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.option('--output-dir', '-o', type=click.Path(), @click.option("--output-dir", "-o", type=click.Path(), help="Output directory for build artifacts")
help='Output directory for build artifacts') @click.option("--keep-chroot", is_flag=True, help="Keep chroot after build (for debugging)")
@click.option('--keep-chroot', is_flag=True, @click.option(
help='Keep chroot after build (for debugging)') "--continue-on-failure",
@click.option('--continue-on-failure', is_flag=True, is_flag=True,
help='Continue building remaining packages even if one fails') help="Continue building remaining packages even if one fails",
)
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def chain(ctx, source_packages, chroot, arch, output_dir, keep_chroot, continue_on_failure): def chain(ctx, source_packages, chroot, arch, output_dir, keep_chroot, continue_on_failure):
""" """
Build a chain of packages that depend on each other. Build a chain of packages that depend on each other.
SOURCE_PACKAGES: List of .dsc files or source package directories to build in order SOURCE_PACKAGES: List of .dsc files or source package directories to build in order
""" """
if not source_packages: if not source_packages:
raise ValidationError( raise ValidationError(
"No source packages specified", "No source packages specified",
field='source_packages', field="source_packages",
expected_format='list of .dsc files or source directories' expected_format="list of .dsc files or source directories",
) )
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if chroot: if chroot:
ctx.obj['config'].chroot_name = chroot ctx.obj["config"].chroot_name = chroot
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
if output_dir: if output_dir:
ctx.obj['config'].output_dir = output_dir ctx.obj["config"].output_dir = output_dir
if keep_chroot: if keep_chroot:
ctx.obj['config'].keep_chroot = keep_chroot ctx.obj["config"].keep_chroot = keep_chroot
results = deb_mock.build_chain( results = deb_mock.build_chain(list(source_packages), continue_on_failure=continue_on_failure)
list(source_packages),
continue_on_failure=continue_on_failure
)
# Display results # Display results
for result in results: for result in results:
if result['success']: if result["success"]:
click.echo(f"✅ {result['package']} (step {result['order']})") click.echo(f"✅ {result['package']} (step {result['order']})")
else: else:
click.echo(f"❌ {result['package']} (step {result['order']}): {result['error']}") click.echo(f"❌ {result['package']} (step {result['order']}): {result['error']}")
# Check if all builds succeeded # Check if all builds succeeded
failed_builds = [r for r in results if not r['success']] failed_builds = [r for r in results if not r["success"]]
if failed_builds: if failed_builds:
sys.exit(1) sys.exit(1)
else: else:
@ -183,67 +186,71 @@ def chain(ctx, source_packages, chroot, arch, output_dir, keep_chroot, continue_
@main.command() @main.command()
@click.argument('chroot_name') @click.argument("chroot_name")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.option('--suite', help='Debian suite (e.g., bookworm, sid)') @click.option("--suite", help="Debian suite (e.g., bookworm, sid)")
@click.option('--bootstrap', is_flag=True, help='Use bootstrap chroot for cross-distribution builds') @click.option(
@click.option('--bootstrap-chroot', help='Name of bootstrap chroot to use') "--bootstrap",
is_flag=True,
help="Use bootstrap chroot for cross-distribution builds",
)
@click.option("--bootstrap-chroot", help="Name of bootstrap chroot to use")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def init_chroot(ctx, chroot_name, arch, suite, bootstrap, bootstrap_chroot): def init_chroot(ctx, chroot_name, arch, suite, bootstrap, bootstrap_chroot):
""" """
Initialize a new chroot environment for building. Initialize a new chroot environment for building.
CHROOT_NAME: Name of the chroot environment to create CHROOT_NAME: Name of the chroot environment to create
The --bootstrap option is useful for building packages for newer distributions The --bootstrap option is useful for building packages for newer distributions
on older systems (e.g., building Debian Sid packages on Debian Stable). on older systems (e.g., building Debian Sid packages on Debian Stable).
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
if suite: if suite:
ctx.obj['config'].suite = suite ctx.obj["config"].suite = suite
if bootstrap: if bootstrap:
ctx.obj['config'].use_bootstrap_chroot = True ctx.obj["config"].use_bootstrap_chroot = True
if bootstrap_chroot: if bootstrap_chroot:
ctx.obj['config'].bootstrap_chroot_name = bootstrap_chroot ctx.obj["config"].bootstrap_chroot_name = bootstrap_chroot
deb_mock.init_chroot(chroot_name) deb_mock.init_chroot(chroot_name)
click.echo(f"Chroot '{chroot_name}' initialized successfully") click.echo(f"Chroot '{chroot_name}' initialized successfully")
if bootstrap: if bootstrap:
click.echo("Bootstrap chroot was used for cross-distribution compatibility") click.echo("Bootstrap chroot was used for cross-distribution compatibility")
@main.command() @main.command()
@click.argument('chroot_name') @click.argument("chroot_name")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def clean_chroot(ctx, chroot_name): def clean_chroot(ctx, chroot_name):
""" """
Clean up a chroot environment. Clean up a chroot environment.
CHROOT_NAME: Name of the chroot environment to clean CHROOT_NAME: Name of the chroot environment to clean
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
deb_mock.clean_chroot(chroot_name) deb_mock.clean_chroot(chroot_name)
click.echo(f"Chroot '{chroot_name}' cleaned successfully") click.echo(f"Chroot '{chroot_name}' cleaned successfully")
@main.command() @main.command()
@click.argument('chroot_name') @click.argument("chroot_name")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def scrub_chroot(ctx, chroot_name): def scrub_chroot(ctx, chroot_name):
""" """
Clean up a chroot environment without removing it. Clean up a chroot environment without removing it.
CHROOT_NAME: Name of the chroot environment to scrub CHROOT_NAME: Name of the chroot environment to scrub
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
deb_mock.chroot_manager.scrub_chroot(chroot_name) deb_mock.chroot_manager.scrub_chroot(chroot_name)
click.echo(f"Chroot '{chroot_name}' scrubbed successfully") click.echo(f"Chroot '{chroot_name}' scrubbed successfully")
@ -255,73 +262,73 @@ def scrub_all_chroots(ctx):
""" """
Clean up all chroot environments without removing them. Clean up all chroot environments without removing them.
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
deb_mock.chroot_manager.scrub_all_chroots() deb_mock.chroot_manager.scrub_all_chroots()
click.echo("All chroots scrubbed successfully") click.echo("All chroots scrubbed successfully")
@main.command() @main.command()
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--preserve-env', is_flag=True, help='Preserve environment variables in chroot') @click.option("--preserve-env", is_flag=True, help="Preserve environment variables in chroot")
@click.option('--env-var', multiple=True, help='Specific environment variable to preserve') @click.option("--env-var", multiple=True, help="Specific environment variable to preserve")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def shell(ctx, chroot, preserve_env, env_var): def shell(ctx, chroot, preserve_env, env_var):
""" """
Open a shell in the chroot environment. Open a shell in the chroot environment.
Use --preserve-env to preserve environment variables (addresses common Use --preserve-env to preserve environment variables (addresses common
environment variable issues in chroot environments). environment variable issues in chroot environments).
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
chroot_name = chroot or ctx.obj['config'].chroot_name chroot_name = chroot or ctx.obj["config"].chroot_name
# Configure environment preservation # Configure environment preservation
if preserve_env: if preserve_env:
ctx.obj['config'].environment_sanitization = False ctx.obj["config"].environment_sanitization = False
if env_var: if env_var:
ctx.obj['config'].preserve_environment.extend(env_var) ctx.obj["config"].preserve_environment.extend(env_var)
deb_mock.shell(chroot_name) deb_mock.shell(chroot_name)
@main.command() @main.command()
@click.argument('source_path') @click.argument("source_path")
@click.argument('dest_path') @click.argument("dest_path")
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def copyin(ctx, source_path, dest_path, chroot): def copyin(ctx, source_path, dest_path, chroot):
""" """
Copy files from host to chroot. Copy files from host to chroot.
SOURCE_PATH: Path to file/directory on host SOURCE_PATH: Path to file/directory on host
DEST_PATH: Path in chroot where to copy DEST_PATH: Path in chroot where to copy
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
chroot_name = chroot or ctx.obj['config'].chroot_name chroot_name = chroot or ctx.obj["config"].chroot_name
deb_mock.copyin(source_path, dest_path, chroot_name) deb_mock.copyin(source_path, dest_path, chroot_name)
click.echo(f"Copied {source_path} to {dest_path} in chroot '{chroot_name}'") click.echo(f"Copied {source_path} to {dest_path} in chroot '{chroot_name}'")
@main.command() @main.command()
@click.argument('source_path') @click.argument("source_path")
@click.argument('dest_path') @click.argument("dest_path")
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def copyout(ctx, source_path, dest_path, chroot): def copyout(ctx, source_path, dest_path, chroot):
""" """
Copy files from chroot to host. Copy files from chroot to host.
SOURCE_PATH: Path to file/directory in chroot SOURCE_PATH: Path to file/directory in chroot
DEST_PATH: Path on host where to copy DEST_PATH: Path on host where to copy
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
chroot_name = chroot or ctx.obj['config'].chroot_name chroot_name = chroot or ctx.obj["config"].chroot_name
deb_mock.copyout(source_path, dest_path, chroot_name) deb_mock.copyout(source_path, dest_path, chroot_name)
click.echo(f"Copied {source_path} from chroot '{chroot_name}' to {dest_path}") click.echo(f"Copied {source_path} from chroot '{chroot_name}' to {dest_path}")
@ -333,13 +340,13 @@ def list_chroots(ctx):
""" """
List available chroot environments. List available chroot environments.
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
chroots = deb_mock.list_chroots() chroots = deb_mock.list_chroots()
if not chroots: if not chroots:
click.echo("No chroot environments found") click.echo("No chroot environments found")
return return
click.echo("Available chroot environments:") click.echo("Available chroot environments:")
for chroot in chroots: for chroot in chroots:
click.echo(f" - {chroot}") click.echo(f" - {chroot}")
@ -353,13 +360,13 @@ def list_configs(ctx):
List available core configurations. List available core configurations.
""" """
from .configs import list_configs from .configs import list_configs
configs = list_configs() configs = list_configs()
if not configs: if not configs:
click.echo("No core configurations found") click.echo("No core configurations found")
return return
click.echo("Available core configurations:") click.echo("Available core configurations:")
for config_name, config_info in configs.items(): for config_name, config_info in configs.items():
click.echo(f" - {config_name}: {config_info['description']}") click.echo(f" - {config_name}: {config_info['description']}")
@ -373,13 +380,13 @@ def cleanup_caches(ctx):
""" """
Clean up old cache files (similar to Mock's cache management). Clean up old cache files (similar to Mock's cache management).
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
cleaned = deb_mock.cleanup_caches() cleaned = deb_mock.cleanup_caches()
if not cleaned: if not cleaned:
click.echo("No old cache files found to clean") click.echo("No old cache files found to clean")
return return
click.echo("Cleaned up cache files:") click.echo("Cleaned up cache files:")
for cache_type, count in cleaned.items(): for cache_type, count in cleaned.items():
if count > 0: if count > 0:
@ -393,13 +400,13 @@ def cache_stats(ctx):
""" """
Show cache statistics. Show cache statistics.
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
stats = deb_mock.get_cache_stats() stats = deb_mock.get_cache_stats()
if not stats: if not stats:
click.echo("No cache statistics available") click.echo("No cache statistics available")
return return
click.echo("Cache Statistics:") click.echo("Cache Statistics:")
for cache_type, cache_stats in stats.items(): for cache_type, cache_stats in stats.items():
click.echo(f" - {cache_type}:") click.echo(f" - {cache_type}:")
@ -417,7 +424,7 @@ def config(ctx):
""" """
Show current configuration. Show current configuration.
""" """
config = ctx.obj['config'] config = ctx.obj["config"]
click.echo("Current configuration:") click.echo("Current configuration:")
click.echo(f" Chroot name: {config.chroot_name}") click.echo(f" Chroot name: {config.chroot_name}")
click.echo(f" Architecture: {config.architecture}") click.echo(f" Architecture: {config.architecture}")
@ -430,84 +437,84 @@ def config(ctx):
@main.command() @main.command()
@click.argument('source_package', type=click.Path(exists=True)) @click.argument("source_package", type=click.Path(exists=True))
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def install_deps(ctx, source_package, chroot, arch): def install_deps(ctx, source_package, chroot, arch):
""" """
Install build dependencies for a Debian source package. Install build dependencies for a Debian source package.
SOURCE_PACKAGE: Path to the .dsc file or source package directory SOURCE_PACKAGE: Path to the .dsc file or source package directory
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if chroot: if chroot:
ctx.obj['config'].chroot_name = chroot ctx.obj["config"].chroot_name = chroot
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
result = deb_mock.install_dependencies(source_package) result = deb_mock.install_dependencies(source_package)
if ctx.obj['verbose']: if ctx.obj["verbose"]:
click.echo(f"Dependencies installed successfully: {result}") click.echo(f"Dependencies installed successfully: {result}")
else: else:
click.echo("Dependencies installed successfully") click.echo("Dependencies installed successfully")
@main.command() @main.command()
@click.argument('packages', nargs=-1, required=True) @click.argument("packages", nargs=-1, required=True)
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def install(ctx, packages, chroot, arch): def install(ctx, packages, chroot, arch):
""" """
Install packages in the chroot environment. Install packages in the chroot environment.
PACKAGES: List of packages to install PACKAGES: List of packages to install
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if chroot: if chroot:
ctx.obj['config'].chroot_name = chroot ctx.obj["config"].chroot_name = chroot
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
result = deb_mock.install_packages(packages) result = deb_mock.install_packages(packages)
if ctx.obj['verbose']: if ctx.obj["verbose"]:
click.echo(f"Packages installed successfully: {result}") click.echo(f"Packages installed successfully: {result}")
else: else:
click.echo(f"Packages installed successfully: {', '.join(packages)}") click.echo(f"Packages installed successfully: {', '.join(packages)}")
@main.command() @main.command()
@click.argument('packages', nargs=-1) @click.argument("packages", nargs=-1)
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def update(ctx, packages, chroot, arch): def update(ctx, packages, chroot, arch):
""" """
Update packages in the chroot environment. Update packages in the chroot environment.
PACKAGES: List of packages to update (if empty, update all) PACKAGES: List of packages to update (if empty, update all)
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if chroot: if chroot:
ctx.obj['config'].chroot_name = chroot ctx.obj["config"].chroot_name = chroot
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
result = deb_mock.update_packages(packages) result = deb_mock.update_packages(packages)
if ctx.obj['verbose']: if ctx.obj["verbose"]:
click.echo(f"Packages updated successfully: {result}") click.echo(f"Packages updated successfully: {result}")
else: else:
if packages: if packages:
@ -517,71 +524,71 @@ def update(ctx, packages, chroot, arch):
@main.command() @main.command()
@click.argument('packages', nargs=-1, required=True) @click.argument("packages", nargs=-1, required=True)
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def remove(ctx, packages, chroot, arch): def remove(ctx, packages, chroot, arch):
""" """
Remove packages from the chroot environment. Remove packages from the chroot environment.
PACKAGES: List of packages to remove PACKAGES: List of packages to remove
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if chroot: if chroot:
ctx.obj['config'].chroot_name = chroot ctx.obj["config"].chroot_name = chroot
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
result = deb_mock.remove_packages(packages) result = deb_mock.remove_packages(packages)
if ctx.obj['verbose']: if ctx.obj["verbose"]:
click.echo(f"Packages removed successfully: {result}") click.echo(f"Packages removed successfully: {result}")
else: else:
click.echo(f"Packages removed successfully: {', '.join(packages)}") click.echo(f"Packages removed successfully: {', '.join(packages)}")
@main.command() @main.command()
@click.argument('command') @click.argument("command")
@click.option('--chroot', help='Chroot environment to use') @click.option("--chroot", help="Chroot environment to use")
@click.option('--arch', help='Target architecture') @click.option("--arch", help="Target architecture")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def apt_cmd(ctx, command, chroot, arch): def apt_cmd(ctx, command, chroot, arch):
""" """
Execute APT command in the chroot environment. Execute APT command in the chroot environment.
COMMAND: APT command to execute (e.g., "update", "install package") COMMAND: APT command to execute (e.g., "update", "install package")
""" """
deb_mock = DebMock(ctx.obj['config']) deb_mock = DebMock(ctx.obj["config"])
# Override config with command line options # Override config with command line options
if chroot: if chroot:
ctx.obj['config'].chroot_name = chroot ctx.obj["config"].chroot_name = chroot
if arch: if arch:
ctx.obj['config'].architecture = arch ctx.obj["config"].architecture = arch
result = deb_mock.execute_apt_command(command) result = deb_mock.execute_apt_command(command)
if ctx.obj['verbose']: if ctx.obj["verbose"]:
click.echo(f"APT command executed successfully: {result}") click.echo(f"APT command executed successfully: {result}")
else: else:
click.echo(f"APT command executed: {command}") click.echo(f"APT command executed: {command}")
@main.command() @main.command()
@click.option('--expand', is_flag=True, help='Show expanded configuration values') @click.option("--expand", is_flag=True, help="Show expanded configuration values")
@click.pass_context @click.pass_context
@handle_exception @handle_exception
def debug_config(ctx, expand): def debug_config(ctx, expand):
""" """
Show detailed configuration information for debugging. Show detailed configuration information for debugging.
""" """
config = ctx.obj['config'] config = ctx.obj["config"]
if expand: if expand:
# Show expanded configuration (with template values resolved) # Show expanded configuration (with template values resolved)
click.echo("Expanded Configuration:") click.echo("Expanded Configuration:")
@ -599,13 +606,13 @@ def debug_config(ctx, expand):
click.echo(f" chroot_dir: {config.chroot_dir}") click.echo(f" chroot_dir: {config.chroot_dir}")
click.echo(f" cache_dir: {config.cache_dir}") click.echo(f" cache_dir: {config.cache_dir}")
click.echo(f" chroot_home: {config.chroot_home}") click.echo(f" chroot_home: {config.chroot_home}")
# Show plugin configuration # Show plugin configuration
if hasattr(config, 'plugins') and config.plugins: if hasattr(config, "plugins") and config.plugins:
click.echo(" plugins:") click.echo(" plugins:")
for plugin_name, plugin_config in config.plugins.items(): for plugin_name, plugin_config in config.plugins.items():
click.echo(f" {plugin_name}: {plugin_config}") click.echo(f" {plugin_name}: {plugin_config}")
if __name__ == '__main__': if __name__ == "__main__":
main() main()

371
deb_mock/config.py
View file

@ -3,121 +3,138 @@ Configuration management for deb-mock
""" """
import os import os
import yaml
from pathlib import Path from pathlib import Path
from typing import Dict, Any, Optional from typing import Any, Dict
import yaml
from .exceptions import ConfigurationError from .exceptions import ConfigurationError
class Config: class Config:
"""Configuration class for deb-mock""" """Configuration class for deb-mock"""
def __init__(self, **kwargs): def __init__(self, **kwargs):
# Default configuration # Default configuration
self.chroot_name = kwargs.get('chroot_name', 'bookworm-amd64') self.chroot_name = kwargs.get("chroot_name", "bookworm-amd64")
self.architecture = kwargs.get('architecture', 'amd64') self.architecture = kwargs.get("architecture", "amd64")
self.suite = kwargs.get('suite', 'bookworm') self.suite = kwargs.get("suite", "bookworm")
self.output_dir = kwargs.get('output_dir', './output') self.output_dir = kwargs.get("output_dir", "./output")
self.keep_chroot = kwargs.get('keep_chroot', False) self.keep_chroot = kwargs.get("keep_chroot", False)
self.verbose = kwargs.get('verbose', False) self.verbose = kwargs.get("verbose", False)
self.debug = kwargs.get('debug', False) self.debug = kwargs.get("debug", False)
# Chroot configuration # Chroot configuration
self.basedir = kwargs.get('basedir', '/var/lib/deb-mock') self.basedir = kwargs.get("basedir", "/var/lib/deb-mock")
self.chroot_dir = kwargs.get('chroot_dir', '/var/lib/deb-mock/chroots') self.chroot_dir = kwargs.get("chroot_dir", "/var/lib/deb-mock/chroots")
self.chroot_config_dir = kwargs.get('chroot_config_dir', '/etc/schroot/chroot.d') self.chroot_config_dir = kwargs.get("chroot_config_dir", "/etc/schroot/chroot.d")
self.chroot_home = kwargs.get('chroot_home', '/home/build') self.chroot_home = kwargs.get("chroot_home", "/home/build")
# sbuild configuration # sbuild configuration
self.sbuild_config = kwargs.get('sbuild_config', '/etc/sbuild/sbuild.conf') self.sbuild_config = kwargs.get("sbuild_config", "/etc/sbuild/sbuild.conf")
self.sbuild_log_dir = kwargs.get('sbuild_log_dir', '/var/log/sbuild') self.sbuild_log_dir = kwargs.get("sbuild_log_dir", "/var/log/sbuild")
# Build configuration # Build configuration
self.build_deps = kwargs.get('build_deps', []) self.build_deps = kwargs.get("build_deps", [])
self.build_env = kwargs.get('build_env', {}) self.build_env = kwargs.get("build_env", {})
self.build_options = kwargs.get('build_options', []) self.build_options = kwargs.get("build_options", [])
# Metadata configuration # Metadata configuration
self.metadata_dir = kwargs.get('metadata_dir', './metadata') self.metadata_dir = kwargs.get("metadata_dir", "./metadata")
self.capture_logs = kwargs.get('capture_logs', True) self.capture_logs = kwargs.get("capture_logs", True)
self.capture_changes = kwargs.get('capture_changes', True) self.capture_changes = kwargs.get("capture_changes", True)
# Speed optimization (Mock-inspired features) # Speed optimization (Mock-inspired features)
self.cache_dir = kwargs.get('cache_dir', '/var/cache/deb-mock') self.cache_dir = kwargs.get("cache_dir", "/var/cache/deb-mock")
self.use_root_cache = kwargs.get('use_root_cache', True) self.use_root_cache = kwargs.get("use_root_cache", True)
self.root_cache_dir = kwargs.get('root_cache_dir', '/var/cache/deb-mock/root-cache') self.root_cache_dir = kwargs.get("root_cache_dir", "/var/cache/deb-mock/root-cache")
self.root_cache_age = kwargs.get('root_cache_age', 7) # days self.root_cache_age = kwargs.get("root_cache_age", 7) # days
self.use_package_cache = kwargs.get('use_package_cache', True) self.use_package_cache = kwargs.get("use_package_cache", True)
self.package_cache_dir = kwargs.get('package_cache_dir', '/var/cache/deb-mock/package-cache') self.package_cache_dir = kwargs.get("package_cache_dir", "/var/cache/deb-mock/package-cache")
self.use_ccache = kwargs.get('use_ccache', False) self.use_ccache = kwargs.get("use_ccache", False)
self.ccache_dir = kwargs.get('ccache_dir', '/var/cache/deb-mock/ccache') self.ccache_dir = kwargs.get("ccache_dir", "/var/cache/deb-mock/ccache")
self.use_tmpfs = kwargs.get('use_tmpfs', False) self.use_tmpfs = kwargs.get("use_tmpfs", False)
self.tmpfs_size = kwargs.get('tmpfs_size', '2G') self.tmpfs_size = kwargs.get("tmpfs_size", "2G")
# Parallel builds # Parallel builds
self.parallel_jobs = kwargs.get('parallel_jobs', 4) self.parallel_jobs = kwargs.get("parallel_jobs", 4)
self.parallel_compression = kwargs.get('parallel_compression', True) self.parallel_compression = kwargs.get("parallel_compression", True)
# Network and proxy # Network and proxy
self.use_host_resolv = kwargs.get('use_host_resolv', True) self.use_host_resolv = kwargs.get("use_host_resolv", True)
self.http_proxy = kwargs.get('http_proxy', None) self.http_proxy = kwargs.get("http_proxy", None)
self.https_proxy = kwargs.get('https_proxy', None) self.https_proxy = kwargs.get("https_proxy", None)
self.no_proxy = kwargs.get('no_proxy', None) self.no_proxy = kwargs.get("no_proxy", None)
# Mirror configuration # Mirror configuration
self.mirror = kwargs.get('mirror', 'http://deb.debian.org/debian/') self.mirror = kwargs.get("mirror", "http://deb.debian.org/debian/")
self.security_mirror = kwargs.get('security_mirror', None) self.security_mirror = kwargs.get("security_mirror", None)
self.backports_mirror = kwargs.get('backports_mirror', None) self.backports_mirror = kwargs.get("backports_mirror", None)
# Isolation and security # Isolation and security
self.isolation = kwargs.get('isolation', 'schroot') # schroot, simple, nspawn self.isolation = kwargs.get("isolation", "schroot") # schroot, simple, nspawn
self.enable_network = kwargs.get('enable_network', True) self.enable_network = kwargs.get("enable_network", True)
self.selinux_enabled = kwargs.get('selinux_enabled', False) self.selinux_enabled = kwargs.get("selinux_enabled", False)
# Bootstrap chroot support (Mock FAQ #2 - Cross-distribution builds) # Bootstrap chroot support (Mock FAQ #2 - Cross-distribution builds)
self.use_bootstrap_chroot = kwargs.get('use_bootstrap_chroot', False) self.use_bootstrap_chroot = kwargs.get("use_bootstrap_chroot", False)
self.bootstrap_chroot_name = kwargs.get('bootstrap_chroot_name', None) self.bootstrap_chroot_name = kwargs.get("bootstrap_chroot_name", None)
self.bootstrap_arch = kwargs.get('bootstrap_arch', None) self.bootstrap_arch = kwargs.get("bootstrap_arch", None)
self.bootstrap_suite = kwargs.get('bootstrap_suite', None) self.bootstrap_suite = kwargs.get("bootstrap_suite", None)
# Build environment customization # Build environment customization
self.chroot_setup_cmd = kwargs.get('chroot_setup_cmd', []) self.chroot_setup_cmd = kwargs.get("chroot_setup_cmd", [])
self.chroot_additional_packages = kwargs.get('chroot_additional_packages', []) self.chroot_additional_packages = kwargs.get("chroot_additional_packages", [])
# Environment variable preservation (Mock FAQ #1) # Environment variable preservation (Mock FAQ #1)
self.preserve_environment = kwargs.get('preserve_environment', []) self.preserve_environment = kwargs.get("preserve_environment", [])
self.environment_sanitization = kwargs.get('environment_sanitization', True) self.environment_sanitization = kwargs.get("environment_sanitization", True)
self.allowed_environment_vars = kwargs.get('allowed_environment_vars', [ self.allowed_environment_vars = kwargs.get(
'DEB_BUILD_OPTIONS', 'DEB_BUILD_PROFILES', 'CC', 'CXX', 'CFLAGS', 'CXXFLAGS', "allowed_environment_vars",
'LDFLAGS', 'MAKEFLAGS', 'CCACHE_DIR', 'CCACHE_HASHDIR', 'http_proxy', [
'https_proxy', 'no_proxy', 'DISPLAY', 'XAUTHORITY' "DEB_BUILD_OPTIONS",
]) "DEB_BUILD_PROFILES",
"CC",
"CXX",
"CFLAGS",
"CXXFLAGS",
"LDFLAGS",
"MAKEFLAGS",
"CCACHE_DIR",
"CCACHE_HASHDIR",
"http_proxy",
"https_proxy",
"no_proxy",
"DISPLAY",
"XAUTHORITY",
],
)
# Advanced build options (Mock-inspired) # Advanced build options (Mock-inspired)
self.run_tests = kwargs.get('run_tests', True) self.run_tests = kwargs.get("run_tests", True)
self.build_timeout = kwargs.get('build_timeout', 0) # 0 = no timeout self.build_timeout = kwargs.get("build_timeout", 0) # 0 = no timeout
self.force_architecture = kwargs.get('force_architecture', None) self.force_architecture = kwargs.get("force_architecture", None)
self.unique_extension = kwargs.get('unique_extension', None) self.unique_extension = kwargs.get("unique_extension", None)
self.config_dir = kwargs.get('config_dir', None) self.config_dir = kwargs.get("config_dir", None)
self.cleanup_after = kwargs.get('cleanup_after', True) self.cleanup_after = kwargs.get("cleanup_after", True)
# APT configuration # APT configuration
self.apt_sources = kwargs.get('apt_sources', []) self.apt_sources = kwargs.get("apt_sources", [])
self.apt_preferences = kwargs.get('apt_preferences', []) self.apt_preferences = kwargs.get("apt_preferences", [])
self.apt_command = kwargs.get('apt_command', 'apt-get') self.apt_command = kwargs.get("apt_command", "apt-get")
self.apt_install_command = kwargs.get('apt_install_command', 'apt-get install -y') self.apt_install_command = kwargs.get("apt_install_command", "apt-get install -y")
# Plugin configuration # Plugin configuration
self.plugins = kwargs.get('plugins', {}) self.plugins = kwargs.get("plugins", {})
self.plugin_dir = kwargs.get('plugin_dir', '/usr/lib/deb-mock/plugins') self.plugin_dir = kwargs.get("plugin_dir", "/usr/lib/deb-mock/plugins")
@classmethod @classmethod
def from_file(cls, config_path: str) -> 'Config': def from_file(cls, config_path: str) -> "Config":
"""Load configuration from a YAML file""" """Load configuration from a YAML file"""
try: try:
with open(config_path, 'r') as f: with open(config_path, "r") as f:
config_data = yaml.safe_load(f) config_data = yaml.safe_load(f)
return cls(**config_data) return cls(**config_data)
except FileNotFoundError: except FileNotFoundError:
raise ConfigurationError(f"Configuration file not found: {config_path}") raise ConfigurationError(f"Configuration file not found: {config_path}")
@ -125,155 +142,163 @@ class Config:
raise ConfigurationError(f"Invalid YAML in configuration file: {e}") raise ConfigurationError(f"Invalid YAML in configuration file: {e}")
except Exception as e: except Exception as e:
raise ConfigurationError(f"Error loading configuration: {e}") raise ConfigurationError(f"Error loading configuration: {e}")
@classmethod @classmethod
def default(cls) -> 'Config': def default(cls) -> "Config":
"""Create default configuration""" """Create default configuration"""
return cls() return cls()
def to_dict(self) -> Dict[str, Any]: def to_dict(self) -> Dict[str, Any]:
"""Convert configuration to dictionary""" """Convert configuration to dictionary"""
return { return {
'chroot_name': self.chroot_name, "chroot_name": self.chroot_name,
'architecture': self.architecture, "architecture": self.architecture,
'suite': self.suite, "suite": self.suite,
'output_dir': self.output_dir, "output_dir": self.output_dir,
'keep_chroot': self.keep_chroot, "keep_chroot": self.keep_chroot,
'verbose': self.verbose, "verbose": self.verbose,
'debug': self.debug, "debug": self.debug,
'chroot_dir': self.chroot_dir, "chroot_dir": self.chroot_dir,
'chroot_config_dir': self.chroot_config_dir, "chroot_config_dir": self.chroot_config_dir,
'sbuild_config': self.sbuild_config, "sbuild_config": self.sbuild_config,
'sbuild_log_dir': self.sbuild_log_dir, "sbuild_log_dir": self.sbuild_log_dir,
'build_deps': self.build_deps, "build_deps": self.build_deps,
'build_env': self.build_env, "build_env": self.build_env,
'build_options': self.build_options, "build_options": self.build_options,
'metadata_dir': self.metadata_dir, "metadata_dir": self.metadata_dir,
'capture_logs': self.capture_logs, "capture_logs": self.capture_logs,
'capture_changes': self.capture_changes, "capture_changes": self.capture_changes,
'use_root_cache': self.use_root_cache, "use_root_cache": self.use_root_cache,
'root_cache_dir': self.root_cache_dir, "root_cache_dir": self.root_cache_dir,
'root_cache_age': self.root_cache_age, "root_cache_age": self.root_cache_age,
'use_package_cache': self.use_package_cache, "use_package_cache": self.use_package_cache,
'package_cache_dir': self.package_cache_dir, "package_cache_dir": self.package_cache_dir,
'use_ccache': self.use_ccache, "use_ccache": self.use_ccache,
'ccache_dir': self.ccache_dir, "ccache_dir": self.ccache_dir,
'use_tmpfs': self.use_tmpfs, "use_tmpfs": self.use_tmpfs,
'tmpfs_size': self.tmpfs_size, "tmpfs_size": self.tmpfs_size,
'parallel_jobs': self.parallel_jobs, "parallel_jobs": self.parallel_jobs,
'parallel_compression': self.parallel_compression, "parallel_compression": self.parallel_compression,
'use_host_resolv': self.use_host_resolv, "use_host_resolv": self.use_host_resolv,
'http_proxy': self.http_proxy, "http_proxy": self.http_proxy,
'https_proxy': self.https_proxy, "https_proxy": self.https_proxy,
'no_proxy': self.no_proxy, "no_proxy": self.no_proxy,
'mirror': self.mirror, "mirror": self.mirror,
'security_mirror': self.security_mirror, "security_mirror": self.security_mirror,
'backports_mirror': self.backports_mirror, "backports_mirror": self.backports_mirror,
'isolation': self.isolation, "isolation": self.isolation,
'enable_network': self.enable_network, "enable_network": self.enable_network,
'selinux_enabled': self.selinux_enabled, "selinux_enabled": self.selinux_enabled,
'use_bootstrap_chroot': self.use_bootstrap_chroot, "use_bootstrap_chroot": self.use_bootstrap_chroot,
'bootstrap_chroot_name': self.bootstrap_chroot_name, "bootstrap_chroot_name": self.bootstrap_chroot_name,
'bootstrap_arch': self.bootstrap_arch, "bootstrap_arch": self.bootstrap_arch,
'bootstrap_suite': self.bootstrap_suite, "bootstrap_suite": self.bootstrap_suite,
'chroot_setup_cmd': self.chroot_setup_cmd, "chroot_setup_cmd": self.chroot_setup_cmd,
'chroot_additional_packages': self.chroot_additional_packages, "chroot_additional_packages": self.chroot_additional_packages,
'preserve_environment': self.preserve_environment, "preserve_environment": self.preserve_environment,
'environment_sanitization': self.environment_sanitization, "environment_sanitization": self.environment_sanitization,
'allowed_environment_vars': self.allowed_environment_vars, "allowed_environment_vars": self.allowed_environment_vars,
} }
def save(self, config_path: str) -> None: def save(self, config_path: str) -> None:
"""Save configuration to a YAML file""" """Save configuration to a YAML file"""
try: try:
config_dir = Path(config_path).parent config_dir = Path(config_path).parent
config_dir.mkdir(parents=True, exist_ok=True) config_dir.mkdir(parents=True, exist_ok=True)
with open(config_path, 'w') as f: with open(config_path, "w") as f:
yaml.dump(self.to_dict(), f, default_flow_style=False) yaml.dump(self.to_dict(), f, default_flow_style=False)
except Exception as e: except Exception as e:
raise ConfigurationError(f"Error saving configuration: {e}") raise ConfigurationError(f"Error saving configuration: {e}")
def validate(self) -> None: def validate(self) -> None:
"""Validate configuration""" """Validate configuration"""
errors = [] errors = []
# Check required directories # Check required directories
if not os.path.exists(self.chroot_config_dir): if not os.path.exists(self.chroot_config_dir):
errors.append(f"Chroot config directory does not exist: {self.chroot_config_dir}") errors.append(f"Chroot config directory does not exist: {self.chroot_config_dir}")
if not os.path.exists(self.sbuild_config): if not os.path.exists(self.sbuild_config):
errors.append(f"sbuild config file does not exist: {self.sbuild_config}") errors.append(f"sbuild config file does not exist: {self.sbuild_config}")
# Check architecture # Check architecture
valid_architectures = ['amd64', 'i386', 'arm64', 'armhf', 'ppc64el', 's390x'] valid_architectures = ["amd64", "i386", "arm64", "armhf", "ppc64el", "s390x"]
if self.architecture not in valid_architectures: if self.architecture not in valid_architectures:
errors.append(f"Invalid architecture: {self.architecture}") errors.append(f"Invalid architecture: {self.architecture}")
# Check suite # Check suite
valid_suites = ['bookworm', 'sid', 'bullseye', 'buster', 'jammy', 'noble', 'focal'] valid_suites = [
"bookworm",
"sid",
"bullseye",
"buster",
"jammy",
"noble",
"focal",
]
if self.suite not in valid_suites: if self.suite not in valid_suites:
errors.append(f"Invalid suite: {self.suite}") errors.append(f"Invalid suite: {self.suite}")
# Check isolation method # Check isolation method
valid_isolation = ['schroot', 'simple', 'nspawn'] valid_isolation = ["schroot", "simple", "nspawn"]
if self.isolation not in valid_isolation: if self.isolation not in valid_isolation:
errors.append(f"Invalid isolation method: {self.isolation}") errors.append(f"Invalid isolation method: {self.isolation}")
# Check parallel jobs # Check parallel jobs
if self.parallel_jobs < 1: if self.parallel_jobs < 1:
errors.append("Parallel jobs must be at least 1") errors.append("Parallel jobs must be at least 1")
if errors: if errors:
raise ConfigurationError(f"Configuration validation failed:\n" + "\n".join(errors)) raise ConfigurationError("Configuration validation failed:\n" + "\n".join(errors))
def get_chroot_path(self) -> str: def get_chroot_path(self) -> str:
"""Get the full path to the chroot directory""" """Get the full path to the chroot directory"""
return os.path.join(self.chroot_dir, self.chroot_name) return os.path.join(self.chroot_dir, self.chroot_name)
def get_output_path(self) -> str: def get_output_path(self) -> str:
"""Get the full path to the output directory""" """Get the full path to the output directory"""
return os.path.abspath(self.output_dir) return os.path.abspath(self.output_dir)
def get_metadata_path(self) -> str: def get_metadata_path(self) -> str:
"""Get the full path to the metadata directory""" """Get the full path to the metadata directory"""
return os.path.abspath(self.metadata_dir) return os.path.abspath(self.metadata_dir)
def get_root_cache_path(self) -> str: def get_root_cache_path(self) -> str:
"""Get the full path to the root cache directory""" """Get the full path to the root cache directory"""
return os.path.join(self.root_cache_dir, self.chroot_name) return os.path.join(self.root_cache_dir, self.chroot_name)
def get_package_cache_path(self) -> str: def get_package_cache_path(self) -> str:
"""Get the full path to the package cache directory""" """Get the full path to the package cache directory"""
return os.path.join(self.package_cache_dir, self.chroot_name) return os.path.join(self.package_cache_dir, self.chroot_name)
def get_ccache_path(self) -> str: def get_ccache_path(self) -> str:
"""Get the full path to the ccache directory""" """Get the full path to the ccache directory"""
return os.path.join(self.ccache_dir, self.chroot_name) return os.path.join(self.ccache_dir, self.chroot_name)
def setup_build_environment(self) -> Dict[str, str]: def setup_build_environment(self) -> Dict[str, str]:
"""Setup build environment variables""" """Setup build environment variables"""
env = {} env = {}
# Set parallel build options # Set parallel build options
if self.parallel_jobs > 1: if self.parallel_jobs > 1:
env['DEB_BUILD_OPTIONS'] = f"parallel={self.parallel_jobs},nocheck" env["DEB_BUILD_OPTIONS"] = f"parallel={self.parallel_jobs},nocheck"
env['MAKEFLAGS'] = f"-j{self.parallel_jobs}" env["MAKEFLAGS"] = f"-j{self.parallel_jobs}"
# Set ccache if enabled # Set ccache if enabled
if self.use_ccache: if self.use_ccache:
env['CCACHE_DIR'] = self.get_ccache_path() env["CCACHE_DIR"] = self.get_ccache_path()
env['CCACHE_HASHDIR'] = '1' env["CCACHE_HASHDIR"] = "1"
# Set proxy if configured # Set proxy if configured
if self.http_proxy: if self.http_proxy:
env['http_proxy'] = self.http_proxy env["http_proxy"] = self.http_proxy
if self.https_proxy: if self.https_proxy:
env['https_proxy'] = self.https_proxy env["https_proxy"] = self.https_proxy
if self.no_proxy: if self.no_proxy:
env['no_proxy'] = self.no_proxy env["no_proxy"] = self.no_proxy
# Merge with user-defined build environment # Merge with user-defined build environment
env.update(self.build_env) env.update(self.build_env)
return env return env

23
deb_mock/configs/__init__.py
View file

@ -5,14 +5,15 @@ This package provides default configuration files for various Debian-based Linux
similar to Mock's mock-core-configs package. similar to Mock's mock-core-configs package.
""" """
import os
import yaml
from pathlib import Path from pathlib import Path
from typing import Dict, List, Optional from typing import Dict, List
import yaml
# Base directory for config files # Base directory for config files
CONFIGS_DIR = Path(__file__).parent CONFIGS_DIR = Path(__file__).parent
def get_available_configs() -> List[str]: def get_available_configs() -> List[str]:
"""Get list of available configuration names""" """Get list of available configuration names"""
configs = [] configs = []
@ -21,15 +22,17 @@ def get_available_configs() -> List[str]:
configs.append(config_file.stem) configs.append(config_file.stem)
return sorted(configs) return sorted(configs)
def load_config(config_name: str) -> Dict: def load_config(config_name: str) -> Dict:
"""Load a configuration by name""" """Load a configuration by name"""
config_file = CONFIGS_DIR / f"{config_name}.yaml" config_file = CONFIGS_DIR / f"{config_name}.yaml"
if not config_file.exists(): if not config_file.exists():
raise ValueError(f"Configuration '{config_name}' not found") raise ValueError(f"Configuration '{config_name}' not found")
with open(config_file, 'r') as f: with open(config_file, "r") as f:
return yaml.safe_load(f) return yaml.safe_load(f)
def list_configs() -> Dict[str, Dict]: def list_configs() -> Dict[str, Dict]:
"""List all available configurations with their details""" """List all available configurations with their details"""
configs = {} configs = {}
@ -37,11 +40,11 @@ def list_configs() -> Dict[str, Dict]:
try: try:
config = load_config(config_name) config = load_config(config_name)
configs[config_name] = { configs[config_name] = {
'description': config.get('description', ''), "description": config.get("description", ""),
'suite': config.get('suite', ''), "suite": config.get("suite", ""),
'architecture': config.get('architecture', ''), "architecture": config.get("architecture", ""),
'mirror': config.get('mirror', '') "mirror": config.get("mirror", ""),
} }
except Exception: except Exception:
continue continue
return configs return configs

3
deb_mock/configs/debian-bookworm-amd64.yaml
View file

@ -32,4 +32,5 @@ output_dir: "./output"
metadata_dir: "./metadata" metadata_dir: "./metadata"
keep_chroot: false keep_chroot: false
verbose: false verbose: false
debug: false debug: false

3
deb_mock/configs/debian-sid-amd64.yaml
View file

@ -32,4 +32,5 @@ output_dir: "./output"
metadata_dir: "./metadata" metadata_dir: "./metadata"
keep_chroot: false keep_chroot: false
verbose: false verbose: false
debug: false debug: false

3
deb_mock/configs/ubuntu-jammy-amd64.yaml
View file

@ -32,4 +32,5 @@ output_dir: "./output"
metadata_dir: "./metadata" metadata_dir: "./metadata"
keep_chroot: false keep_chroot: false
verbose: false verbose: false
debug: false debug: false

3
deb_mock/configs/ubuntu-noble-amd64.yaml
View file

@ -32,4 +32,5 @@ output_dir: "./output"
metadata_dir: "./metadata" metadata_dir: "./metadata"
keep_chroot: false keep_chroot: false
verbose: false verbose: false
debug: false debug: false

428
deb_mock/core.py
View file

@ -3,34 +3,33 @@ Core DebMock class for orchestrating the build process
""" """
import os import os
import json
import shutil
from pathlib import Path from pathlib import Path
from typing import Dict, Any, Optional, List from typing import Any, Dict, List, Optional
from .config import Config
from .chroot import ChrootManager
from .sbuild import SbuildWrapper
from .metadata import MetadataManager
from .cache import CacheManager from .cache import CacheManager
from .exceptions import DebMockError, BuildError, ChrootError, SbuildError from .chroot import ChrootManager
from .config import Config
from .exceptions import ChrootError
from .metadata import MetadataManager
from .sbuild import SbuildWrapper
class DebMock: class DebMock:
"""Main DebMock class for orchestrating package builds""" """Main DebMock class for orchestrating package builds"""
def __init__(self, config: Config): def __init__(self, config: Config):
self.config = config self.config = config
self.chroot_manager = ChrootManager(config) self.chroot_manager = ChrootManager(config)
self.sbuild_wrapper = SbuildWrapper(config) self.sbuild_wrapper = SbuildWrapper(config)
self.metadata_manager = MetadataManager(config) self.metadata_manager = MetadataManager(config)
self.cache_manager = CacheManager(config) self.cache_manager = CacheManager(config)
# Validate configuration # Validate configuration
self.config.validate() self.config.validate()
# Setup caches # Setup caches
self._setup_caches() self._setup_caches()
def _setup_caches(self) -> None: def _setup_caches(self) -> None:
"""Setup cache directories and ccache""" """Setup cache directories and ccache"""
try: try:
@ -40,300 +39,283 @@ class DebMock:
except Exception as e: except Exception as e:
# Log warning but continue # Log warning but continue
print(f"Warning: Failed to setup caches: {e}") print(f"Warning: Failed to setup caches: {e}")
def build(self, source_package: str, **kwargs) -> Dict[str, Any]: def build(self, source_package: str, **kwargs) -> Dict[str, Any]:
"""Build a Debian source package in an isolated environment""" """Build a Debian source package in an isolated environment"""
# Ensure chroot exists # Ensure chroot exists
chroot_name = kwargs.get('chroot_name', self.config.chroot_name) chroot_name = kwargs.get("chroot_name", self.config.chroot_name)
chroot_path = self.config.get_chroot_path() chroot_path = self.config.get_chroot_path()
# Try to restore from cache first # Try to restore from cache first
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
if not self.cache_manager.restore_root_cache(chroot_path): if not self.cache_manager.restore_root_cache(chroot_path):
self.chroot_manager.create_chroot(chroot_name) self.chroot_manager.create_chroot(chroot_name)
# Check build dependencies # Check build dependencies
deps_check = self.sbuild_wrapper.check_dependencies(source_package, chroot_name) deps_check = self.sbuild_wrapper.check_dependencies(source_package, chroot_name)
if not deps_check['satisfied']: if not deps_check["satisfied"]:
# Try to install missing dependencies # Try to install missing dependencies
if deps_check['missing']: if deps_check["missing"]:
self.sbuild_wrapper.install_build_dependencies(deps_check['missing'], chroot_name) self.sbuild_wrapper.install_build_dependencies(deps_check["missing"], chroot_name)
# Setup build environment # Setup build environment
build_env = self.config.setup_build_environment() build_env = self.config.setup_build_environment()
# Build the package # Build the package
build_result = self.sbuild_wrapper.build_package( build_result = self.sbuild_wrapper.build_package(source_package, chroot_name, build_env=build_env, **kwargs)
source_package,
chroot_name,
build_env=build_env,
**kwargs
)
# Create cache after successful build # Create cache after successful build
if build_result.get('success', False): if build_result.get("success", False):
self.cache_manager.create_root_cache(chroot_path) self.cache_manager.create_root_cache(chroot_path)
# Capture and store metadata # Capture and store metadata
metadata = self._capture_build_metadata(build_result, source_package) metadata = self._capture_build_metadata(build_result, source_package)
self.metadata_manager.store_metadata(metadata) self.metadata_manager.store_metadata(metadata)
# Clean up chroot if not keeping it # Clean up chroot if not keeping it
if not kwargs.get('keep_chroot', self.config.keep_chroot): if not kwargs.get("keep_chroot", self.config.keep_chroot):
self.chroot_manager.clean_chroot(chroot_name) self.chroot_manager.clean_chroot(chroot_name)
return build_result return build_result
def build_chain(self, source_packages: List[str], **kwargs) -> List[Dict[str, Any]]: def build_chain(self, source_packages: List[str], **kwargs) -> List[Dict[str, Any]]:
"""Build a chain of packages that depend on each other (similar to Mock's --chain)""" """Build a chain of packages that depend on each other (similar to Mock's --chain)"""
results = [] results = []
chroot_name = kwargs.get('chroot_name', self.config.chroot_name) chroot_name = kwargs.get("chroot_name", self.config.chroot_name)
chroot_path = self.config.get_chroot_path() chroot_path = self.config.get_chroot_path()
# Try to restore from cache first # Try to restore from cache first
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
if not self.cache_manager.restore_root_cache(chroot_path): if not self.cache_manager.restore_root_cache(chroot_path):
self.chroot_manager.create_chroot(chroot_name) self.chroot_manager.create_chroot(chroot_name)
# Setup build environment # Setup build environment
build_env = self.config.setup_build_environment() build_env = self.config.setup_build_environment()
for i, source_package in enumerate(source_packages): for i, source_package in enumerate(source_packages):
try: try:
# Build the package # Build the package
result = self.sbuild_wrapper.build_package( result = self.sbuild_wrapper.build_package(source_package, chroot_name, build_env=build_env, **kwargs)
source_package,
chroot_name, results.append(
build_env=build_env, {
**kwargs "package": source_package,
"success": True,
"result": result,
"order": i + 1,
}
) )
results.append({
'package': source_package,
'success': True,
'result': result,
'order': i + 1
})
# Install the built package in the chroot for subsequent builds # Install the built package in the chroot for subsequent builds
if result.get('artifacts'): if result.get("artifacts"):
self._install_built_package(result['artifacts'], chroot_name) self._install_built_package(result["artifacts"], chroot_name)
except Exception as e: except Exception as e:
results.append({ results.append(
'package': source_package, {
'success': False, "package": source_package,
'error': str(e), "success": False,
'order': i + 1 "error": str(e),
}) "order": i + 1,
}
)
# Stop chain on failure unless continue_on_failure is specified # Stop chain on failure unless continue_on_failure is specified
if not kwargs.get('continue_on_failure', False): if not kwargs.get("continue_on_failure", False):
break break
# Create cache after successful chain build # Create cache after successful chain build
if any(r['success'] for r in results): if any(r["success"] for r in results):
self.cache_manager.create_root_cache(chroot_path) self.cache_manager.create_root_cache(chroot_path)
return results return results
def _install_built_package(self, artifacts: List[str], chroot_name: str) -> None: def _install_built_package(self, artifacts: List[str], chroot_name: str) -> None:
"""Install a built package in the chroot for chain building""" """Install a built package in the chroot for chain building"""
# Find .deb files in artifacts # Find .deb files in artifacts
deb_files = [art for art in artifacts if art.endswith('.deb')] deb_files = [art for art in artifacts if art.endswith(".deb")]
if not deb_files: if not deb_files:
return return
# Copy .deb files to chroot and install them # Copy .deb files to chroot and install them
for deb_file in deb_files: for deb_file in deb_files:
try: try:
# Copy to chroot # Copy to chroot
chroot_deb_path = f"/tmp/{os.path.basename(deb_file)}" chroot_deb_path = f"/tmp/{os.path.basename(deb_file)}"
self.chroot_manager.copy_to_chroot(deb_file, chroot_deb_path, chroot_name) self.chroot_manager.copy_to_chroot(deb_file, chroot_deb_path, chroot_name)
# Install in chroot # Install in chroot
self.chroot_manager.execute_in_chroot( self.chroot_manager.execute_in_chroot(
chroot_name, chroot_name, ["dpkg", "-i", chroot_deb_path], capture_output=False
['dpkg', '-i', chroot_deb_path],
capture_output=False
) )
# Clean up # Clean up
self.chroot_manager.execute_in_chroot( self.chroot_manager.execute_in_chroot(chroot_name, ["rm", "-f", chroot_deb_path], capture_output=False)
chroot_name,
['rm', '-f', chroot_deb_path],
capture_output=False
)
except Exception as e: except Exception as e:
# Log warning but continue # Log warning but continue
print(f"Warning: Failed to install {deb_file} in chroot: {e}") print(f"Warning: Failed to install {deb_file} in chroot: {e}")
def init_chroot(self, chroot_name: str, arch: str = None, suite: str = None) -> None: def init_chroot(self, chroot_name: str, arch: str = None, suite: str = None) -> None:
"""Initialize a new chroot environment""" """Initialize a new chroot environment"""
self.chroot_manager.create_chroot(chroot_name, arch, suite) self.chroot_manager.create_chroot(chroot_name, arch, suite)
# Create cache after successful chroot creation # Create cache after successful chroot creation
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
self.cache_manager.create_root_cache(chroot_path) self.cache_manager.create_root_cache(chroot_path)
def clean_chroot(self, chroot_name: str) -> None: def clean_chroot(self, chroot_name: str) -> None:
"""Clean up a chroot environment""" """Clean up a chroot environment"""
self.chroot_manager.clean_chroot(chroot_name) self.chroot_manager.clean_chroot(chroot_name)
def list_chroots(self) -> list: def list_chroots(self) -> list:
"""List available chroot environments""" """List available chroot environments"""
return self.chroot_manager.list_chroots() return self.chroot_manager.list_chroots()
def update_chroot(self, chroot_name: str) -> None: def update_chroot(self, chroot_name: str) -> None:
"""Update packages in a chroot environment""" """Update packages in a chroot environment"""
self.chroot_manager.update_chroot(chroot_name) self.chroot_manager.update_chroot(chroot_name)
# Update cache after successful update # Update cache after successful update
chroot_path = os.path.join(self.config.chroot_dir, chroot_name) chroot_path = os.path.join(self.config.chroot_dir, chroot_name)
self.cache_manager.create_root_cache(chroot_path) self.cache_manager.create_root_cache(chroot_path)
def get_chroot_info(self, chroot_name: str) -> dict: def get_chroot_info(self, chroot_name: str) -> dict:
"""Get information about a chroot environment""" """Get information about a chroot environment"""
return self.chroot_manager.get_chroot_info(chroot_name) return self.chroot_manager.get_chroot_info(chroot_name)
def shell(self, chroot_name: str = None) -> None: def shell(self, chroot_name: str = None) -> None:
"""Open a shell in the chroot environment (similar to Mock's --shell)""" """Open a shell in the chroot environment (similar to Mock's --shell)"""
if chroot_name is None: if chroot_name is None:
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
raise ChrootError(f"Chroot '{chroot_name}' does not exist") raise ChrootError(f"Chroot '{chroot_name}' does not exist")
# Execute shell in chroot # Execute shell in chroot
self.chroot_manager.execute_in_chroot( self.chroot_manager.execute_in_chroot(chroot_name, ["/bin/bash"], capture_output=False)
chroot_name,
['/bin/bash'],
capture_output=False
)
def copyout(self, source_path: str, dest_path: str, chroot_name: str = None) -> None: def copyout(self, source_path: str, dest_path: str, chroot_name: str = None) -> None:
"""Copy files from chroot to host (similar to Mock's --copyout)""" """Copy files from chroot to host (similar to Mock's --copyout)"""
if chroot_name is None: if chroot_name is None:
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
self.chroot_manager.copy_from_chroot(source_path, dest_path, chroot_name) self.chroot_manager.copy_from_chroot(source_path, dest_path, chroot_name)
def copyin(self, source_path: str, dest_path: str, chroot_name: str = None) -> None: def copyin(self, source_path: str, dest_path: str, chroot_name: str = None) -> None:
"""Copy files from host to chroot (similar to Mock's --copyin)""" """Copy files from host to chroot (similar to Mock's --copyin)"""
if chroot_name is None: if chroot_name is None:
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
self.chroot_manager.copy_to_chroot(source_path, dest_path, chroot_name) self.chroot_manager.copy_to_chroot(source_path, dest_path, chroot_name)
def cleanup_caches(self) -> Dict[str, int]: def cleanup_caches(self) -> Dict[str, int]:
"""Clean up old cache files (similar to Mock's cache management)""" """Clean up old cache files (similar to Mock's cache management)"""
return self.cache_manager.cleanup_old_caches() return self.cache_manager.cleanup_old_caches()
def get_cache_stats(self) -> Dict[str, Any]: def get_cache_stats(self) -> Dict[str, Any]:
"""Get cache statistics""" """Get cache statistics"""
return self.cache_manager.get_cache_stats() return self.cache_manager.get_cache_stats()
def _capture_build_metadata(self, build_result: Dict[str, Any], source_package: str) -> Dict[str, Any]: def _capture_build_metadata(self, build_result: Dict[str, Any], source_package: str) -> Dict[str, Any]:
"""Capture comprehensive build metadata""" """Capture comprehensive build metadata"""
metadata = { metadata = {
'source_package': source_package, "source_package": source_package,
'build_result': build_result, "build_result": build_result,
'config': self.config.to_dict(), "config": self.config.to_dict(),
'artifacts': build_result.get('artifacts', []), "artifacts": build_result.get("artifacts", []),
'build_metadata': build_result.get('metadata', {}), "build_metadata": build_result.get("metadata", {}),
'timestamp': self._get_timestamp(), "timestamp": self._get_timestamp(),
'build_success': build_result.get('success', False), "build_success": build_result.get("success", False),
'cache_info': self.get_cache_stats() "cache_info": self.get_cache_stats(),
} }
# Add artifact details # Add artifact details
metadata['artifact_details'] = self._get_artifact_details(build_result.get('artifacts', [])) metadata["artifact_details"] = self._get_artifact_details(build_result.get("artifacts", []))
return metadata return metadata
def _get_timestamp(self) -> str: def _get_timestamp(self) -> str:
"""Get current timestamp""" """Get current timestamp"""
from datetime import datetime from datetime import datetime
return datetime.now().isoformat() return datetime.now().isoformat()
def _get_artifact_details(self, artifacts: list) -> list: def _get_artifact_details(self, artifacts: list) -> list:
"""Get detailed information about build artifacts""" """Get detailed information about build artifacts"""
details = [] details = []
for artifact_path in artifacts: for artifact_path in artifacts:
if os.path.exists(artifact_path): if os.path.exists(artifact_path):
stat = os.stat(artifact_path) stat = os.stat(artifact_path)
details.append({ details.append(
'path': artifact_path, {
'name': os.path.basename(artifact_path), "path": artifact_path,
'size': stat.st_size, "name": os.path.basename(artifact_path),
'modified': stat.st_mtime, "size": stat.st_size,
'type': self._get_artifact_type(artifact_path) "modified": stat.st_mtime,
}) "type": self._get_artifact_type(artifact_path),
}
)
return details return details
def _get_artifact_type(self, artifact_path: str) -> str: def _get_artifact_type(self, artifact_path: str) -> str:
"""Determine the type of build artifact""" """Determine the type of build artifact"""
ext = Path(artifact_path).suffix.lower() ext = Path(artifact_path).suffix.lower()
if ext == '.deb': if ext == ".deb":
return 'deb_package' return "deb_package"
elif ext == '.changes': elif ext == ".changes":
return 'changes_file' return "changes_file"
elif ext == '.buildinfo': elif ext == ".buildinfo":
return 'buildinfo_file' return "buildinfo_file"
elif ext == '.dsc': elif ext == ".dsc":
return 'source_package' return "source_package"
else: else:
return 'other' return "other"
def verify_reproducible_build(self, source_package: str, **kwargs) -> Dict[str, Any]: def verify_reproducible_build(self, source_package: str, **kwargs) -> Dict[str, Any]:
"""Verify that a build is reproducible by building twice and comparing results""" """Verify that a build is reproducible by building twice and comparing results"""
# First build # First build
result1 = self.build(source_package, **kwargs) result1 = self.build(source_package, **kwargs)
# Clean chroot for second build # Clean chroot for second build
chroot_name = kwargs.get('chroot_name', self.config.chroot_name) chroot_name = kwargs.get("chroot_name", self.config.chroot_name)
if self.chroot_manager.chroot_exists(chroot_name): if self.chroot_manager.chroot_exists(chroot_name):
self.chroot_manager.clean_chroot(chroot_name) self.chroot_manager.clean_chroot(chroot_name)
# Second build # Second build
result2 = self.build(source_package, **kwargs) result2 = self.build(source_package, **kwargs)
# Compare results # Compare results
comparison = self._compare_build_results(result1, result2) comparison = self._compare_build_results(result1, result2)
return { return {
'reproducible': comparison['identical'], "reproducible": comparison["identical"],
'first_build': result1, "first_build": result1,
'second_build': result2, "second_build": result2,
'comparison': comparison "comparison": comparison,
} }
def _compare_build_results(self, result1: Dict[str, Any], result2: Dict[str, Any]) -> Dict[str, Any]: def _compare_build_results(self, result1: Dict[str, Any], result2: Dict[str, Any]) -> Dict[str, Any]:
"""Compare two build results for reproducibility""" """Compare two build results for reproducibility"""
comparison = { comparison = {"identical": True, "differences": [], "artifact_comparison": {}}
'identical': True,
'differences': [],
'artifact_comparison': {}
}
# Compare artifacts # Compare artifacts
artifacts1 = set(result1.get('artifacts', [])) artifacts1 = set(result1.get("artifacts", []))
artifacts2 = set(result2.get('artifacts', [])) artifacts2 = set(result2.get("artifacts", []))
if artifacts1 != artifacts2: if artifacts1 != artifacts2:
comparison['identical'] = False comparison["identical"] = False
comparison['differences'].append('Different artifacts produced') comparison["differences"].append("Different artifacts produced")
# Compare individual artifacts # Compare individual artifacts
common_artifacts = artifacts1.intersection(artifacts2) common_artifacts = artifacts1.intersection(artifacts2)
for artifact in common_artifacts: for artifact in common_artifacts:
@ -341,142 +323,142 @@ class DebMock:
# Compare file hashes # Compare file hashes
hash1 = self._get_file_hash(artifact) hash1 = self._get_file_hash(artifact)
hash2 = self._get_file_hash(artifact) hash2 = self._get_file_hash(artifact)
comparison['artifact_comparison'][artifact] = { comparison["artifact_comparison"][artifact] = {
'identical': hash1 == hash2, "identical": hash1 == hash2,
'hash1': hash1, "hash1": hash1,
'hash2': hash2 "hash2": hash2,
} }
if hash1 != hash2: if hash1 != hash2:
comparison['identical'] = False comparison["identical"] = False
comparison['differences'].append(f'Artifact {artifact} differs') comparison["differences"].append(f"Artifact {artifact} differs")
return comparison return comparison
def _get_file_hash(self, file_path: str) -> str: def _get_file_hash(self, file_path: str) -> str:
"""Get SHA256 hash of a file""" """Get SHA256 hash of a file"""
import hashlib import hashlib
hash_sha256 = hashlib.sha256() hash_sha256 = hashlib.sha256()
with open(file_path, "rb") as f: with open(file_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""): for chunk in iter(lambda: f.read(4096), b""):
hash_sha256.update(chunk) hash_sha256.update(chunk)
return hash_sha256.hexdigest() return hash_sha256.hexdigest()
def get_build_history(self) -> list: def get_build_history(self) -> list:
"""Get build history from metadata store""" """Get build history from metadata store"""
return self.metadata_manager.get_build_history() return self.metadata_manager.get_build_history()
def get_build_info(self, build_id: str) -> Optional[Dict[str, Any]]: def get_build_info(self, build_id: str) -> Optional[Dict[str, Any]]:
"""Get information about a specific build""" """Get information about a specific build"""
return self.metadata_manager.get_build_info(build_id) return self.metadata_manager.get_build_info(build_id)
def install_dependencies(self, source_package: str) -> Dict[str, Any]: def install_dependencies(self, source_package: str) -> Dict[str, Any]:
"""Install build dependencies for a source package""" """Install build dependencies for a source package"""
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
# Ensure chroot exists # Ensure chroot exists
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
self.chroot_manager.create_chroot(chroot_name) self.chroot_manager.create_chroot(chroot_name)
# Check and install dependencies # Check and install dependencies
deps_check = self.sbuild_wrapper.check_dependencies(source_package, chroot_name) deps_check = self.sbuild_wrapper.check_dependencies(source_package, chroot_name)
if deps_check['missing']: if deps_check["missing"]:
result = self.sbuild_wrapper.install_build_dependencies(deps_check['missing'], chroot_name) result = self.sbuild_wrapper.install_build_dependencies(deps_check["missing"], chroot_name)
return { return {
'success': True, "success": True,
'installed': deps_check['missing'], "installed": deps_check["missing"],
'details': result "details": result,
} }
else: else:
return { return {
'success': True, "success": True,
'installed': [], "installed": [],
'message': 'All dependencies already satisfied' "message": "All dependencies already satisfied",
} }
def install_packages(self, packages: List[str]) -> Dict[str, Any]: def install_packages(self, packages: List[str]) -> Dict[str, Any]:
"""Install packages in the chroot environment""" """Install packages in the chroot environment"""
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
# Ensure chroot exists # Ensure chroot exists
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
self.chroot_manager.create_chroot(chroot_name) self.chroot_manager.create_chroot(chroot_name)
# Install packages using APT # Install packages using APT
result = self.chroot_manager.execute_in_chroot( result = self.chroot_manager.execute_in_chroot(
chroot_name, chroot_name,
f"{self.config.apt_install_command} {' '.join(packages)}", f"{self.config.apt_install_command} {' '.join(packages)}",
as_root=True as_root=True,
) )
return { return {
'success': result['returncode'] == 0, "success": result["returncode"] == 0,
'installed': packages, "installed": packages,
'output': result['stdout'], "output": result["stdout"],
'error': result['stderr'] if result['returncode'] != 0 else None "error": result["stderr"] if result["returncode"] != 0 else None,
} }
def update_packages(self, packages: List[str] = None) -> Dict[str, Any]: def update_packages(self, packages: List[str] = None) -> Dict[str, Any]:
"""Update packages in the chroot environment""" """Update packages in the chroot environment"""
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
# Ensure chroot exists # Ensure chroot exists
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
self.chroot_manager.create_chroot(chroot_name) self.chroot_manager.create_chroot(chroot_name)
if packages: if packages:
# Update specific packages # Update specific packages
cmd = f"{self.config.apt_command} install --only-upgrade {' '.join(packages)}" cmd = f"{self.config.apt_command} install --only-upgrade {' '.join(packages)}"
else: else:
# Update all packages # Update all packages
cmd = f"{self.config.apt_command} update && {self.config.apt_command} upgrade -y" cmd = f"{self.config.apt_command} update && {self.config.apt_command} upgrade -y"
result = self.chroot_manager.execute_in_chroot(chroot_name, cmd, as_root=True) result = self.chroot_manager.execute_in_chroot(chroot_name, cmd, as_root=True)
return { return {
'success': result['returncode'] == 0, "success": result["returncode"] == 0,
'updated': packages if packages else 'all', "updated": packages if packages else "all",
'output': result['stdout'], "output": result["stdout"],
'error': result['stderr'] if result['returncode'] != 0 else None "error": result["stderr"] if result["returncode"] != 0 else None,
} }
def remove_packages(self, packages: List[str]) -> Dict[str, Any]: def remove_packages(self, packages: List[str]) -> Dict[str, Any]:
"""Remove packages from the chroot environment""" """Remove packages from the chroot environment"""
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
# Ensure chroot exists # Ensure chroot exists
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
self.chroot_manager.create_chroot(chroot_name) self.chroot_manager.create_chroot(chroot_name)
# Remove packages using APT # Remove packages using APT
cmd = f"{self.config.apt_command} remove -y {' '.join(packages)}" cmd = f"{self.config.apt_command} remove -y {' '.join(packages)}"
result = self.chroot_manager.execute_in_chroot(chroot_name, cmd, as_root=True) result = self.chroot_manager.execute_in_chroot(chroot_name, cmd, as_root=True)
return { return {
'success': result['returncode'] == 0, "success": result["returncode"] == 0,
'removed': packages, "removed": packages,
'output': result['stdout'], "output": result["stdout"],
'error': result['stderr'] if result['returncode'] != 0 else None "error": result["stderr"] if result["returncode"] != 0 else None,
} }
def execute_apt_command(self, command: str) -> Dict[str, Any]: def execute_apt_command(self, command: str) -> Dict[str, Any]:
"""Execute APT command in the chroot environment""" """Execute APT command in the chroot environment"""
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
# Ensure chroot exists # Ensure chroot exists
if not self.chroot_manager.chroot_exists(chroot_name): if not self.chroot_manager.chroot_exists(chroot_name):
self.chroot_manager.create_chroot(chroot_name) self.chroot_manager.create_chroot(chroot_name)
# Execute APT command # Execute APT command
cmd = f"{self.config.apt_command} {command}" cmd = f"{self.config.apt_command} {command}"
result = self.chroot_manager.execute_in_chroot(chroot_name, cmd, as_root=True) result = self.chroot_manager.execute_in_chroot(chroot_name, cmd, as_root=True)
return { return {
'success': result['returncode'] == 0, "success": result["returncode"] == 0,
'command': command, "command": command,
'output': result['stdout'], "output": result["stdout"],
'error': result['stderr'] if result['returncode'] != 0 else None "error": result["stderr"] if result["returncode"] != 0 else None,
} }

313
deb_mock/exceptions.py
View file

@ -5,28 +5,30 @@ This module provides a comprehensive exception hierarchy inspired by Mock's
exception handling system, adapted for Debian-based build environments. exception handling system, adapted for Debian-based build environments.
""" """
import os
import sys
import functools import functools
from typing import Optional, Dict, Any, List import sys
from typing import Any, Dict, List, Optional
class DebMockError(Exception): class DebMockError(Exception):
""" """
Base exception for all deb-mock errors. Base exception for all deb-mock errors.
This is the root exception class that all other deb-mock exceptions This is the root exception class that all other deb-mock exceptions
inherit from. It provides common functionality for error reporting inherit from. It provides common functionality for error reporting
and recovery suggestions. and recovery suggestions.
""" """
def __init__(self, message: str, def __init__(
exit_code: int = 1, self,
context: Optional[Dict[str, Any]] = None, message: str,
suggestions: Optional[List[str]] = None): exit_code: int = 1,
context: Optional[Dict[str, Any]] = None,
suggestions: Optional[List[str]] = None,
):
""" """
Initialize the exception with message and optional context. Initialize the exception with message and optional context.
Args: Args:
message: Human-readable error message message: Human-readable error message
exit_code: Suggested exit code for CLI applications exit_code: Suggested exit code for CLI applications
@ -38,29 +40,29 @@ class DebMockError(Exception):
self.exit_code = exit_code self.exit_code = exit_code
self.context = context or {} self.context = context or {}
self.suggestions = suggestions or [] self.suggestions = suggestions or []
def __str__(self) -> str: def __str__(self) -> str:
"""Return formatted error message with context and suggestions.""" """Return formatted error message with context and suggestions."""
lines = [f"Error: {self.message}"] lines = [f"Error: {self.message}"]
# Add context information if available # Add context information if available
if self.context: if self.context:
lines.append("\nContext:") lines.append("\nContext:")
for key, value in self.context.items(): for key, value in self.context.items():
lines.append(f" {key}: {value}") lines.append(f" {key}: {value}")
# Add suggestions if available # Add suggestions if available
if self.suggestions: if self.suggestions:
lines.append("\nSuggestions:") lines.append("\nSuggestions:")
for i, suggestion in enumerate(self.suggestions, 1): for i, suggestion in enumerate(self.suggestions, 1):
lines.append(f" {i}. {suggestion}") lines.append(f" {i}. {suggestion}")
return "\n".join(lines) return "\n".join(lines)
def print_error(self, file=sys.stderr) -> None: def print_error(self, file=sys.stderr) -> None:
"""Print formatted error message to specified file.""" """Print formatted error message to specified file."""
print(str(self), file=file) print(str(self), file=file)
def get_exit_code(self) -> int: def get_exit_code(self) -> int:
"""Get the suggested exit code for this error.""" """Get the suggested exit code for this error."""
return self.exit_code return self.exit_code
@ -69,293 +71,344 @@ class DebMockError(Exception):
class ConfigurationError(DebMockError): class ConfigurationError(DebMockError):
""" """
Raised when there's an error in configuration. Raised when there's an error in configuration.
This exception is raised when configuration files are invalid, This exception is raised when configuration files are invalid,
missing required options, or contain conflicting settings. missing required options, or contain conflicting settings.
""" """
def __init__(self, message: str, config_file: Optional[str] = None, def __init__(
config_section: Optional[str] = None): self,
message: str,
config_file: Optional[str] = None,
config_section: Optional[str] = None,
):
context = {} context = {}
if config_file: if config_file:
context['config_file'] = config_file context["config_file"] = config_file
if config_section: if config_section:
context['config_section'] = config_section context["config_section"] = config_section
suggestions = [ suggestions = [
"Check the configuration file syntax", "Check the configuration file syntax",
"Verify all required options are set", "Verify all required options are set",
"Ensure configuration values are valid for your system" "Ensure configuration values are valid for your system",
] ]
super().__init__(message, exit_code=2, context=context, suggestions=suggestions) super().__init__(message, exit_code=2, context=context, suggestions=suggestions)
class ChrootError(DebMockError): class ChrootError(DebMockError):
""" """
Raised when there's an error with chroot operations. Raised when there's an error with chroot operations.
This exception covers chroot creation, management, and cleanup errors. This exception covers chroot creation, management, and cleanup errors.
""" """
def __init__(self, message: str, chroot_name: Optional[str] = None, def __init__(
operation: Optional[str] = None, chroot_path: Optional[str] = None): self,
message: str,
chroot_name: Optional[str] = None,
operation: Optional[str] = None,
chroot_path: Optional[str] = None,
):
context = {} context = {}
if chroot_name: if chroot_name:
context['chroot_name'] = chroot_name context["chroot_name"] = chroot_name
if operation: if operation:
context['operation'] = operation context["operation"] = operation
if chroot_path: if chroot_path:
context['chroot_path'] = chroot_path context["chroot_path"] = chroot_path
suggestions = [ suggestions = [
"Ensure you have sufficient disk space", "Ensure you have sufficient disk space",
"Check that you have root privileges for chroot operations", "Check that you have root privileges for chroot operations",
"Verify the chroot name is valid", "Verify the chroot name is valid",
"Try cleaning up existing chroots with 'deb-mock clean-chroot'" "Try cleaning up existing chroots with 'deb-mock clean-chroot'",
] ]
super().__init__(message, exit_code=3, context=context, suggestions=suggestions) super().__init__(message, exit_code=3, context=context, suggestions=suggestions)
class SbuildError(DebMockError): class SbuildError(DebMockError):
""" """
Raised when there's an error with sbuild operations. Raised when there's an error with sbuild operations.
This exception covers sbuild execution, configuration, and result processing. This exception covers sbuild execution, configuration, and result processing.
""" """
def __init__(self, message: str, sbuild_config: Optional[str] = None, def __init__(
build_log: Optional[str] = None, return_code: Optional[int] = None): self,
message: str,
sbuild_config: Optional[str] = None,
build_log: Optional[str] = None,
return_code: Optional[int] = None,
):
context = {} context = {}
if sbuild_config: if sbuild_config:
context['sbuild_config'] = sbuild_config context["sbuild_config"] = sbuild_config
if build_log: if build_log:
context['build_log'] = build_log context["build_log"] = build_log
if return_code is not None: if return_code is not None:
context['return_code'] = return_code context["return_code"] = return_code
suggestions = [ suggestions = [
"Check the build log for detailed error information", "Check the build log for detailed error information",
"Verify that sbuild is properly configured", "Verify that sbuild is properly configured",
"Ensure all build dependencies are available", "Ensure all build dependencies are available",
"Try updating the chroot with 'deb-mock update-chroot'" "Try updating the chroot with 'deb-mock update-chroot'",
] ]
super().__init__(message, exit_code=4, context=context, suggestions=suggestions) super().__init__(message, exit_code=4, context=context, suggestions=suggestions)
class BuildError(DebMockError): class BuildError(DebMockError):
""" """
Raised when a build fails. Raised when a build fails.
This exception is raised when package building fails due to This exception is raised when package building fails due to
compilation errors, missing dependencies, or other build issues. compilation errors, missing dependencies, or other build issues.
""" """
def __init__(self, message: str, source_package: Optional[str] = None, def __init__(
build_log: Optional[str] = None, artifacts: Optional[List[str]] = None): self,
message: str,
source_package: Optional[str] = None,
build_log: Optional[str] = None,
artifacts: Optional[List[str]] = None,
):
context = {} context = {}
if source_package: if source_package:
context['source_package'] = source_package context["source_package"] = source_package
if build_log: if build_log:
context['build_log'] = build_log context["build_log"] = build_log
if artifacts: if artifacts:
context['artifacts'] = artifacts context["artifacts"] = artifacts
suggestions = [ suggestions = [
"Review the build log for specific error messages", "Review the build log for specific error messages",
"Check that all build dependencies are installed", "Check that all build dependencies are installed",
"Verify the source package is valid and complete", "Verify the source package is valid and complete",
"Try building with verbose output: 'deb-mock --verbose build'" "Try building with verbose output: 'deb-mock --verbose build'",
] ]
super().__init__(message, exit_code=5, context=context, suggestions=suggestions) super().__init__(message, exit_code=5, context=context, suggestions=suggestions)
class DependencyError(DebMockError): class DependencyError(DebMockError):
""" """
Raised when there are dependency issues. Raised when there are dependency issues.
This exception covers missing build dependencies, version conflicts, This exception covers missing build dependencies, version conflicts,
and other dependency-related problems. and other dependency-related problems.
""" """
def __init__(self, message: str, missing_packages: Optional[List[str]] = None, def __init__(
conflicting_packages: Optional[List[str]] = None): self,
message: str,
missing_packages: Optional[List[str]] = None,
conflicting_packages: Optional[List[str]] = None,
):
context = {} context = {}
if missing_packages: if missing_packages:
context['missing_packages'] = missing_packages context["missing_packages"] = missing_packages
if conflicting_packages: if conflicting_packages:
context['conflicting_packages'] = conflicting_packages context["conflicting_packages"] = conflicting_packages
suggestions = [ suggestions = [
"Install missing build dependencies", "Install missing build dependencies",
"Resolve package conflicts by updating or removing conflicting packages", "Resolve package conflicts by updating or removing conflicting packages",
"Check that your chroot has access to the required repositories", "Check that your chroot has access to the required repositories",
"Try updating the chroot: 'deb-mock update-chroot'" "Try updating the chroot: 'deb-mock update-chroot'",
] ]
super().__init__(message, exit_code=6, context=context, suggestions=suggestions) super().__init__(message, exit_code=6, context=context, suggestions=suggestions)
class MetadataError(DebMockError): class MetadataError(DebMockError):
""" """
Raised when there's an error with metadata handling. Raised when there's an error with metadata handling.
This exception covers metadata capture, storage, and retrieval errors. This exception covers metadata capture, storage, and retrieval errors.
""" """
def __init__(self, message: str, metadata_file: Optional[str] = None, def __init__(
operation: Optional[str] = None): self,
message: str,
metadata_file: Optional[str] = None,
operation: Optional[str] = None,
):
context = {} context = {}
if metadata_file: if metadata_file:
context['metadata_file'] = metadata_file context["metadata_file"] = metadata_file
if operation: if operation:
context['operation'] = operation context["operation"] = operation
suggestions = [ suggestions = [
"Check that the metadata directory is writable", "Check that the metadata directory is writable",
"Verify that the metadata file format is valid", "Verify that the metadata file format is valid",
"Ensure sufficient disk space for metadata storage" "Ensure sufficient disk space for metadata storage",
] ]
super().__init__(message, exit_code=7, context=context, suggestions=suggestions) super().__init__(message, exit_code=7, context=context, suggestions=suggestions)
class CacheError(DebMockError): class CacheError(DebMockError):
""" """
Raised when there's an error with cache operations. Raised when there's an error with cache operations.
This exception covers root cache, package cache, and ccache errors. This exception covers root cache, package cache, and ccache errors.
""" """
def __init__(self, message: str, cache_type: Optional[str] = None, def __init__(
cache_path: Optional[str] = None, operation: Optional[str] = None): self,
message: str,
cache_type: Optional[str] = None,
cache_path: Optional[str] = None,
operation: Optional[str] = None,
):
context = {} context = {}
if cache_type: if cache_type:
context['cache_type'] = cache_type context["cache_type"] = cache_type
if cache_path: if cache_path:
context['cache_path'] = cache_path context["cache_path"] = cache_path
if operation: if operation:
context['operation'] = operation context["operation"] = operation
suggestions = [ suggestions = [
"Check that cache directories are writable", "Check that cache directories are writable",
"Ensure sufficient disk space for cache operations", "Ensure sufficient disk space for cache operations",
"Try cleaning up old caches: 'deb-mock cleanup-caches'", "Try cleaning up old caches: 'deb-mock cleanup-caches'",
"Verify cache configuration settings" "Verify cache configuration settings",
] ]
super().__init__(message, exit_code=8, context=context, suggestions=suggestions) super().__init__(message, exit_code=8, context=context, suggestions=suggestions)
class PluginError(DebMockError): class PluginError(DebMockError):
""" """
Raised when there's an error with plugin operations. Raised when there's an error with plugin operations.
This exception covers plugin loading, configuration, and execution errors. This exception covers plugin loading, configuration, and execution errors.
""" """
def __init__(self, message: str, plugin_name: Optional[str] = None, def __init__(
plugin_config: Optional[Dict[str, Any]] = None): self,
message: str,
plugin_name: Optional[str] = None,
plugin_config: Optional[Dict[str, Any]] = None,
):
context = {} context = {}
if plugin_name: if plugin_name:
context['plugin_name'] = plugin_name context["plugin_name"] = plugin_name
if plugin_config: if plugin_config:
context['plugin_config'] = plugin_config context["plugin_config"] = plugin_config
suggestions = [ suggestions = [
"Check that the plugin is properly installed", "Check that the plugin is properly installed",
"Verify plugin configuration is valid", "Verify plugin configuration is valid",
"Ensure plugin dependencies are satisfied", "Ensure plugin dependencies are satisfied",
"Try disabling the plugin if it's causing issues" "Try disabling the plugin if it's causing issues",
] ]
super().__init__(message, exit_code=9, context=context, suggestions=suggestions) super().__init__(message, exit_code=9, context=context, suggestions=suggestions)
class NetworkError(DebMockError): class NetworkError(DebMockError):
""" """
Raised when there are network-related errors. Raised when there are network-related errors.
This exception covers repository access, package downloads, and This exception covers repository access, package downloads, and
other network operations. other network operations.
""" """
def __init__(self, message: str, url: Optional[str] = None, def __init__(
proxy: Optional[str] = None, timeout: Optional[int] = None): self,
message: str,
url: Optional[str] = None,
proxy: Optional[str] = None,
timeout: Optional[int] = None,
):
context = {} context = {}
if url: if url:
context['url'] = url context["url"] = url
if proxy: if proxy:
context['proxy'] = proxy context["proxy"] = proxy
if timeout: if timeout:
context['timeout'] = timeout context["timeout"] = timeout
suggestions = [ suggestions = [
"Check your internet connection", "Check your internet connection",
"Verify repository URLs are accessible", "Verify repository URLs are accessible",
"Configure proxy settings if behind a firewall", "Configure proxy settings if behind a firewall",
"Try using a different mirror or repository" "Try using a different mirror or repository",
] ]
super().__init__(message, exit_code=10, context=context, suggestions=suggestions) super().__init__(message, exit_code=10, context=context, suggestions=suggestions)
class PermissionError(DebMockError): class PermissionError(DebMockError):
""" """
Raised when there are permission-related errors. Raised when there are permission-related errors.
This exception covers insufficient privileges for chroot operations, This exception covers insufficient privileges for chroot operations,
file access, and other permission issues. file access, and other permission issues.
""" """
def __init__(self, message: str, operation: Optional[str] = None, def __init__(
path: Optional[str] = None, required_privileges: Optional[str] = None): self,
message: str,
operation: Optional[str] = None,
path: Optional[str] = None,
required_privileges: Optional[str] = None,
):
context = {} context = {}
if operation: if operation:
context['operation'] = operation context["operation"] = operation
if path: if path:
context['path'] = path context["path"] = path
if required_privileges: if required_privileges:
context['required_privileges'] = required_privileges context["required_privileges"] = required_privileges
suggestions = [ suggestions = [
"Run the command with appropriate privileges (sudo)", "Run the command with appropriate privileges (sudo)",
"Check file and directory permissions", "Check file and directory permissions",
"Verify your user is in the required groups", "Verify your user is in the required groups",
"Ensure the target paths are writable" "Ensure the target paths are writable",
] ]
super().__init__(message, exit_code=11, context=context, suggestions=suggestions) super().__init__(message, exit_code=11, context=context, suggestions=suggestions)
class ValidationError(DebMockError): class ValidationError(DebMockError):
""" """
Raised when input validation fails. Raised when input validation fails.
This exception covers validation of source packages, configuration, This exception covers validation of source packages, configuration,
and other input data. and other input data.
""" """
def __init__(self, message: str, field: Optional[str] = None, def __init__(
value: Optional[str] = None, expected_format: Optional[str] = None): self,
message: str,
field: Optional[str] = None,
value: Optional[str] = None,
expected_format: Optional[str] = None,
):
context = {} context = {}
if field: if field:
context['field'] = field context["field"] = field
if value: if value:
context['value'] = value context["value"] = value
if expected_format: if expected_format:
context['expected_format'] = expected_format context["expected_format"] = expected_format
suggestions = [ suggestions = [
"Check the input format and syntax", "Check the input format and syntax",
"Verify that required fields are provided", "Verify that required fields are provided",
"Ensure values are within acceptable ranges", "Ensure values are within acceptable ranges",
"Review the documentation for correct usage" "Review the documentation for correct usage",
] ]
super().__init__(message, exit_code=12, context=context, suggestions=suggestions) super().__init__(message, exit_code=12, context=context, suggestions=suggestions)
@ -363,10 +416,11 @@ class ValidationError(DebMockError):
def handle_exception(func): def handle_exception(func):
""" """
Decorator to handle exceptions and provide consistent error reporting. Decorator to handle exceptions and provide consistent error reporting.
This decorator catches DebMockError exceptions and provides This decorator catches DebMockError exceptions and provides
formatted error output with suggestions for resolution. formatted error output with suggestions for resolution.
""" """
@functools.wraps(func) @functools.wraps(func)
def wrapper(*args, **kwargs): def wrapper(*args, **kwargs):
try: try:
@ -378,26 +432,27 @@ def handle_exception(func):
# Convert unexpected exceptions to DebMockError # Convert unexpected exceptions to DebMockError
error = DebMockError( error = DebMockError(
f"Unexpected error: {str(e)}", f"Unexpected error: {str(e)}",
context={'exception_type': type(e).__name__}, context={"exception_type": type(e).__name__},
suggestions=[ suggestions=[
"This may be a bug in deb-mock", "This may be a bug in deb-mock",
"Check the logs for more details", "Check the logs for more details",
"Report the issue with full error context" "Report the issue with full error context",
] ],
) )
error.print_error() error.print_error()
sys.exit(1) sys.exit(1)
return wrapper return wrapper
def format_error_context(**kwargs) -> Dict[str, Any]: def format_error_context(**kwargs) -> Dict[str, Any]:
""" """
Helper function to format error context information. Helper function to format error context information.
Args: Args:
**kwargs: Key-value pairs for context information **kwargs: Key-value pairs for context information
Returns: Returns:
Formatted context dictionary Formatted context dictionary
""" """
return {k: v for k, v in kwargs.items() if v is not None} return {k: v for k, v in kwargs.items() if v is not None}

189
deb_mock/metadata.py
View file

@ -2,137 +2,133 @@
Metadata management for deb-mock Metadata management for deb-mock
""" """
import os
import json import json
import uuid import uuid
from pathlib import Path
from typing import Dict, Any, List, Optional
from datetime import datetime from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List, Optional
from .exceptions import MetadataError from .exceptions import MetadataError
class MetadataManager: class MetadataManager:
"""Manages build metadata capture and storage""" """Manages build metadata capture and storage"""
def __init__(self, config): def __init__(self, config):
self.config = config self.config = config
self.metadata_dir = Path(config.get_metadata_path()) self.metadata_dir = Path(config.get_metadata_path())
self.metadata_dir.mkdir(parents=True, exist_ok=True) self.metadata_dir.mkdir(parents=True, exist_ok=True)
def store_metadata(self, metadata: Dict[str, Any]) -> str: def store_metadata(self, metadata: Dict[str, Any]) -> str:
"""Store build metadata and return build ID""" """Store build metadata and return build ID"""
# Generate unique build ID # Generate unique build ID
build_id = self._generate_build_id() build_id = self._generate_build_id()
# Add build ID to metadata # Add build ID to metadata
metadata['build_id'] = build_id metadata["build_id"] = build_id
metadata['stored_at'] = datetime.now().isoformat() metadata["stored_at"] = datetime.now().isoformat()
# Create metadata file # Create metadata file
metadata_file = self.metadata_dir / f"{build_id}.json" metadata_file = self.metadata_dir / f"{build_id}.json"
try: try:
with open(metadata_file, 'w') as f: with open(metadata_file, "w") as f:
json.dump(metadata, f, indent=2, default=str) json.dump(metadata, f, indent=2, default=str)
except Exception as e: except Exception as e:
raise MetadataError(f"Failed to store metadata: {e}") raise MetadataError(f"Failed to store metadata: {e}")
# Update build index # Update build index
self._update_build_index(build_id, metadata) self._update_build_index(build_id, metadata)
return build_id return build_id
def get_build_info(self, build_id: str) -> Optional[Dict[str, Any]]: def get_build_info(self, build_id: str) -> Optional[Dict[str, Any]]:
"""Get metadata for a specific build""" """Get metadata for a specific build"""
metadata_file = self.metadata_dir / f"{build_id}.json" metadata_file = self.metadata_dir / f"{build_id}.json"
if not metadata_file.exists(): if not metadata_file.exists():
return None return None
try: try:
with open(metadata_file, 'r') as f: with open(metadata_file, "r") as f:
return json.load(f) return json.load(f)
except Exception as e: except Exception as e:
raise MetadataError(f"Failed to load metadata for build {build_id}: {e}") raise MetadataError(f"Failed to load metadata for build {build_id}: {e}")
def get_build_history(self, limit: int = None) -> List[Dict[str, Any]]: def get_build_history(self, limit: int = None) -> List[Dict[str, Any]]:
"""Get build history, optionally limited to recent builds""" """Get build history, optionally limited to recent builds"""
builds = [] builds = []
# Load build index # Load build index
index_file = self.metadata_dir / "build_index.json" index_file = self.metadata_dir / "build_index.json"
if not index_file.exists(): if not index_file.exists():
return builds return builds
try: try:
with open(index_file, 'r') as f: with open(index_file, "r") as f:
build_index = json.load(f) build_index = json.load(f)
except Exception as e: except Exception as e:
raise MetadataError(f"Failed to load build index: {e}") raise MetadataError(f"Failed to load build index: {e}")
# Sort builds by timestamp (newest first) # Sort builds by timestamp (newest first)
sorted_builds = sorted( sorted_builds = sorted(build_index.values(), key=lambda x: x.get("timestamp", ""), reverse=True)
build_index.values(),
key=lambda x: x.get('timestamp', ''),
reverse=True
)
# Apply limit if specified # Apply limit if specified
if limit: if limit:
sorted_builds = sorted_builds[:limit] sorted_builds = sorted_builds[:limit]
# Load full metadata for each build # Load full metadata for each build
for build_info in sorted_builds: for build_info in sorted_builds:
build_id = build_info.get('build_id') build_id = build_info.get("build_id")
if build_id: if build_id:
full_metadata = self.get_build_info(build_id) full_metadata = self.get_build_info(build_id)
if full_metadata: if full_metadata:
builds.append(full_metadata) builds.append(full_metadata)
return builds return builds
def search_builds(self, criteria: Dict[str, Any]) -> List[Dict[str, Any]]: def search_builds(self, criteria: Dict[str, Any]) -> List[Dict[str, Any]]:
"""Search builds based on criteria""" """Search builds based on criteria"""
builds = [] builds = []
all_builds = self.get_build_history() all_builds = self.get_build_history()
for build in all_builds: for build in all_builds:
if self._matches_criteria(build, criteria): if self._matches_criteria(build, criteria):
builds.append(build) builds.append(build)
return builds return builds
def delete_build_metadata(self, build_id: str) -> bool: def delete_build_metadata(self, build_id: str) -> bool:
"""Delete metadata for a specific build""" """Delete metadata for a specific build"""
metadata_file = self.metadata_dir / f"{build_id}.json" metadata_file = self.metadata_dir / f"{build_id}.json"
if not metadata_file.exists(): if not metadata_file.exists():
return False return False
try: try:
metadata_file.unlink() metadata_file.unlink()
self._remove_from_index(build_id) self._remove_from_index(build_id)
return True return True
except Exception as e: except Exception as e:
raise MetadataError(f"Failed to delete metadata for build {build_id}: {e}") raise MetadataError(f"Failed to delete metadata for build {build_id}: {e}")
def cleanup_old_metadata(self, days: int = 30) -> int: def cleanup_old_metadata(self, days: int = 30) -> int:
"""Clean up metadata older than specified days""" """Clean up metadata older than specified days"""
cutoff_time = datetime.now().timestamp() - (days * 24 * 60 * 60) cutoff_time = datetime.now().timestamp() - (days * 24 * 60 * 60)
deleted_count = 0 deleted_count = 0
all_builds = self.get_build_history() all_builds = self.get_build_history()
for build in all_builds: for build in all_builds:
build_id = build.get('build_id') build_id = build.get("build_id")
timestamp = build.get('timestamp') timestamp = build.get("timestamp")
if timestamp: if timestamp:
try: try:
build_time = datetime.fromisoformat(timestamp).timestamp() build_time = datetime.fromisoformat(timestamp).timestamp()
@ -142,106 +138,107 @@ class MetadataManager:
except ValueError: except ValueError:
# Skip builds with invalid timestamps # Skip builds with invalid timestamps
continue continue
return deleted_count return deleted_count
def export_metadata(self, build_id: str, format: str = 'json') -> str: def export_metadata(self, build_id: str, format: str = "json") -> str:
"""Export build metadata in specified format""" """Export build metadata in specified format"""
metadata = self.get_build_info(build_id) metadata = self.get_build_info(build_id)
if not metadata: if not metadata:
raise MetadataError(f"Build {build_id} not found") raise MetadataError(f"Build {build_id} not found")
if format.lower() == 'json': if format.lower() == "json":
return json.dumps(metadata, indent=2, default=str) return json.dumps(metadata, indent=2, default=str)
elif format.lower() == 'yaml': elif format.lower() == "yaml":
import yaml import yaml
return yaml.dump(metadata, default_flow_style=False) return yaml.dump(metadata, default_flow_style=False)
else: else:
raise MetadataError(f"Unsupported export format: {format}") raise MetadataError(f"Unsupported export format: {format}")
def _generate_build_id(self) -> str: def _generate_build_id(self) -> str:
"""Generate a unique build ID""" """Generate a unique build ID"""
return str(uuid.uuid4()) return str(uuid.uuid4())
def _update_build_index(self, build_id: str, metadata: Dict[str, Any]) -> None: def _update_build_index(self, build_id: str, metadata: Dict[str, Any]) -> None:
"""Update the build index with new build information""" """Update the build index with new build information"""
index_file = self.metadata_dir / "build_index.json" index_file = self.metadata_dir / "build_index.json"
# Load existing index # Load existing index
build_index = {} build_index = {}
if index_file.exists(): if index_file.exists():
try: try:
with open(index_file, 'r') as f: with open(index_file, "r") as f:
build_index = json.load(f) build_index = json.load(f)
except Exception: except Exception:
build_index = {} build_index = {}
# Add new build to index # Add new build to index
build_index[build_id] = { build_index[build_id] = {
'build_id': build_id, "build_id": build_id,
'source_package': metadata.get('source_package', ''), "source_package": metadata.get("source_package", ""),
'timestamp': metadata.get('timestamp', ''), "timestamp": metadata.get("timestamp", ""),
'build_success': metadata.get('build_success', False), "build_success": metadata.get("build_success", False),
'package_name': metadata.get('build_metadata', {}).get('package_name', ''), "package_name": metadata.get("build_metadata", {}).get("package_name", ""),
'package_version': metadata.get('build_metadata', {}).get('package_version', ''), "package_version": metadata.get("build_metadata", {}).get("package_version", ""),
'architecture': metadata.get('build_metadata', {}).get('architecture', ''), "architecture": metadata.get("build_metadata", {}).get("architecture", ""),
'suite': metadata.get('build_metadata', {}).get('suite', '') "suite": metadata.get("build_metadata", {}).get("suite", ""),
} }
# Save updated index # Save updated index
try: try:
with open(index_file, 'w') as f: with open(index_file, "w") as f:
json.dump(build_index, f, indent=2, default=str) json.dump(build_index, f, indent=2, default=str)
except Exception as e: except Exception as e:
raise MetadataError(f"Failed to update build index: {e}") raise MetadataError(f"Failed to update build index: {e}")
def _remove_from_index(self, build_id: str) -> None: def _remove_from_index(self, build_id: str) -> None:
"""Remove a build from the index""" """Remove a build from the index"""
index_file = self.metadata_dir / "build_index.json" index_file = self.metadata_dir / "build_index.json"
if not index_file.exists(): if not index_file.exists():
return return
try: try:
with open(index_file, 'r') as f: with open(index_file, "r") as f:
build_index = json.load(f) build_index = json.load(f)
except Exception: except Exception:
return return
if build_id in build_index: if build_id in build_index:
del build_index[build_id] del build_index[build_id]
try: try:
with open(index_file, 'w') as f: with open(index_file, "w") as f:
json.dump(build_index, f, indent=2, default=str) json.dump(build_index, f, indent=2, default=str)
except Exception as e: except Exception as e:
raise MetadataError(f"Failed to update build index: {e}") raise MetadataError(f"Failed to update build index: {e}")
def _matches_criteria(self, build: Dict[str, Any], criteria: Dict[str, Any]) -> bool: def _matches_criteria(self, build: Dict[str, Any], criteria: Dict[str, Any]) -> bool:
"""Check if a build matches the given criteria""" """Check if a build matches the given criteria"""
for key, value in criteria.items(): for key, value in criteria.items():
if key == 'package_name': if key == "package_name":
build_package = build.get('build_metadata', {}).get('package_name', '') build_package = build.get("build_metadata", {}).get("package_name", "")
if value.lower() not in build_package.lower(): if value.lower() not in build_package.lower():
return False return False
elif key == 'architecture': elif key == "architecture":
build_arch = build.get('build_metadata', {}).get('architecture', '') build_arch = build.get("build_metadata", {}).get("architecture", "")
if value.lower() != build_arch.lower(): if value.lower() != build_arch.lower():
return False return False
elif key == 'suite': elif key == "suite":
build_suite = build.get('build_metadata', {}).get('suite', '') build_suite = build.get("build_metadata", {}).get("suite", "")
if value.lower() != build_suite.lower(): if value.lower() != build_suite.lower():
return False return False
elif key == 'success': elif key == "success":
build_success = build.get('build_success', False) build_success = build.get("build_success", False)
if value != build_success: if value != build_success:
return False return False
elif key == 'date_after': elif key == "date_after":
build_timestamp = build.get('timestamp', '') build_timestamp = build.get("timestamp", "")
if build_timestamp: if build_timestamp:
try: try:
build_time = datetime.fromisoformat(build_timestamp) build_time = datetime.fromisoformat(build_timestamp)
@ -250,8 +247,8 @@ class MetadataManager:
return False return False
except ValueError: except ValueError:
return False return False
elif key == 'date_before': elif key == "date_before":
build_timestamp = build.get('timestamp', '') build_timestamp = build.get("timestamp", "")
if build_timestamp: if build_timestamp:
try: try:
build_time = datetime.fromisoformat(build_timestamp) build_time = datetime.fromisoformat(build_timestamp)
@ -260,5 +257,5 @@ class MetadataManager:
return False return False
except ValueError: except ValueError:
return False return False
return True return True

25
deb_mock/plugins/__init__.py
View file

@ -6,7 +6,6 @@ inspired by Fedora's Mock plugin architecture but adapted for Debian-based syste
""" """
from .hook_manager import HookManager from .hook_manager import HookManager
from .base import BasePlugin
from .registry import PluginRegistry from .registry import PluginRegistry
# Global hook manager instance # Global hook manager instance
@ -15,72 +14,78 @@ hook_manager = HookManager()
# Global plugin registry # Global plugin registry
plugin_registry = PluginRegistry() plugin_registry = PluginRegistry()
# Convenience function for plugins to register hooks # Convenience function for plugins to register hooks
def add_hook(hook_name: str, callback): def add_hook(hook_name: str, callback):
""" """
Register a hook callback. Register a hook callback.
This is the main interface for plugins to register hooks, This is the main interface for plugins to register hooks,
following the same pattern as Mock's plugin system. following the same pattern as Mock's plugin system.
Args: Args:
hook_name: Name of the hook to register for hook_name: Name of the hook to register for
callback: Function to call when hook is triggered callback: Function to call when hook is triggered
""" """
hook_manager.add_hook(hook_name, callback) hook_manager.add_hook(hook_name, callback)
# Convenience function to call hooks # Convenience function to call hooks
def call_hook(hook_name: str, context: dict = None): def call_hook(hook_name: str, context: dict = None):
""" """
Call all registered hooks for a given hook name. Call all registered hooks for a given hook name.
Args: Args:
hook_name: Name of the hook to trigger hook_name: Name of the hook to trigger
context: Context dictionary to pass to hook callbacks context: Context dictionary to pass to hook callbacks
""" """
hook_manager.call_hook(hook_name, context) hook_manager.call_hook(hook_name, context)
# Convenience function to get available hooks # Convenience function to get available hooks
def get_hook_names() -> list: def get_hook_names() -> list:
""" """
Get list of available hook names. Get list of available hook names.
Returns: Returns:
List of hook names that have been registered List of hook names that have been registered
""" """
return hook_manager.get_hook_names() return hook_manager.get_hook_names()
# Convenience function to register plugins # Convenience function to register plugins
def register_plugin(plugin_name: str, plugin_class): def register_plugin(plugin_name: str, plugin_class):
""" """
Register a plugin class. Register a plugin class.
Args: Args:
plugin_name: Name of the plugin plugin_name: Name of the plugin
plugin_class: Plugin class to register plugin_class: Plugin class to register
""" """
plugin_registry.register(plugin_name, plugin_class) plugin_registry.register(plugin_name, plugin_class)
# Convenience function to get registered plugins # Convenience function to get registered plugins
def get_registered_plugins() -> dict: def get_registered_plugins() -> dict:
""" """
Get all registered plugins. Get all registered plugins.
Returns: Returns:
Dictionary of registered plugin names and classes Dictionary of registered plugin names and classes
""" """
return plugin_registry.get_plugins() return plugin_registry.get_plugins()
# Convenience function to create plugin instances # Convenience function to create plugin instances
def create_plugin(plugin_name: str, config): def create_plugin(plugin_name: str, config):
""" """
Create a plugin instance. Create a plugin instance.
Args: Args:
plugin_name: Name of the plugin to create plugin_name: Name of the plugin to create
config: Configuration object config: Configuration object
Returns: Returns:
Plugin instance Plugin instance
""" """
return plugin_registry.create(plugin_name, config, hook_manager) return plugin_registry.create(plugin_name, config, hook_manager)

224
deb_mock/plugins/base.py
View file

@ -6,7 +6,7 @@ inspired by Fedora's Mock plugin architecture but adapted for Debian-based syste
""" """
import logging import logging
from typing import Dict, Any, Optional from typing import Any, Dict
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -14,17 +14,17 @@ logger = logging.getLogger(__name__)
class BasePlugin: class BasePlugin:
""" """
Base class for all Deb-Mock plugins. Base class for all Deb-Mock plugins.
This class provides the foundation for all plugins in the Deb-Mock system, This class provides the foundation for all plugins in the Deb-Mock system,
following the same patterns as Fedora's Mock plugins but adapted for Debian workflows. following the same patterns as Fedora's Mock plugins but adapted for Debian workflows.
Plugins should inherit from this class and override the hook methods they need. Plugins should inherit from this class and override the hook methods they need.
""" """
def __init__(self, config, hook_manager): def __init__(self, config, hook_manager):
""" """
Initialize the plugin. Initialize the plugin.
Args: Args:
config: Configuration object config: Configuration object
hook_manager: Hook manager instance hook_manager: Hook manager instance
@ -33,382 +33,382 @@ class BasePlugin:
self.hook_manager = hook_manager self.hook_manager = hook_manager
self.enabled = self._is_enabled() self.enabled = self._is_enabled()
self.plugin_name = self.__class__.__name__.lower() self.plugin_name = self.__class__.__name__.lower()
# Register hooks if plugin is enabled # Register hooks if plugin is enabled
if self.enabled: if self.enabled:
self._register_hooks() self._register_hooks()
logger.debug(f"Plugin {self.plugin_name} initialized and enabled") logger.debug(f"Plugin {self.plugin_name} initialized and enabled")
else: else:
logger.debug(f"Plugin {self.plugin_name} initialized but disabled") logger.debug(f"Plugin {self.plugin_name} initialized but disabled")
def _is_enabled(self) -> bool: def _is_enabled(self) -> bool:
""" """
Check if plugin is enabled in configuration. Check if plugin is enabled in configuration.
Returns: Returns:
True if plugin is enabled, False otherwise True if plugin is enabled, False otherwise
""" """
plugin_config = getattr(self.config, 'plugins', {}) plugin_config = getattr(self.config, "plugins", {})
plugin_name = self.plugin_name plugin_name = self.plugin_name
# Check if plugin is explicitly enabled # Check if plugin is explicitly enabled
if plugin_name in plugin_config: if plugin_name in plugin_config:
return plugin_config[plugin_name].get('enabled', False) return plugin_config[plugin_name].get("enabled", False)
# Check if plugin is enabled via global plugin settings # Check if plugin is enabled via global plugin settings
return getattr(self.config, 'enable_plugins', {}).get(plugin_name, False) return getattr(self.config, "enable_plugins", {}).get(plugin_name, False)
def _register_hooks(self): def _register_hooks(self):
""" """
Register plugin hooks with the hook manager. Register plugin hooks with the hook manager.
Override this method in subclasses to register specific hooks. Override this method in subclasses to register specific hooks.
""" """
# Override in subclasses to register hooks # Override in subclasses to register hooks
pass pass
def _get_plugin_config(self) -> Dict[str, Any]: def _get_plugin_config(self) -> Dict[str, Any]:
""" """
Get plugin-specific configuration. Get plugin-specific configuration.
Returns: Returns:
Plugin configuration dictionary Plugin configuration dictionary
""" """
plugin_config = getattr(self.config, 'plugins', {}) plugin_config = getattr(self.config, "plugins", {})
return plugin_config.get(self.plugin_name, {}) return plugin_config.get(self.plugin_name, {})
def _log_info(self, message: str): def _log_info(self, message: str):
"""Log an info message with plugin context.""" """Log an info message with plugin context."""
logger.info(f"[{self.plugin_name}] {message}") logger.info(f"[{self.plugin_name}] {message}")
def _log_debug(self, message: str): def _log_debug(self, message: str):
"""Log a debug message with plugin context.""" """Log a debug message with plugin context."""
logger.debug(f"[{self.plugin_name}] {message}") logger.debug(f"[{self.plugin_name}] {message}")
def _log_warning(self, message: str): def _log_warning(self, message: str):
"""Log a warning message with plugin context.""" """Log a warning message with plugin context."""
logger.warning(f"[{self.plugin_name}] {message}") logger.warning(f"[{self.plugin_name}] {message}")
def _log_error(self, message: str): def _log_error(self, message: str):
"""Log an error message with plugin context.""" """Log an error message with plugin context."""
logger.error(f"[{self.plugin_name}] {message}") logger.error(f"[{self.plugin_name}] {message}")
# ============================================================================ # ============================================================================
# Hook Method Stubs - Override in subclasses as needed # Hook Method Stubs - Override in subclasses as needed
# ============================================================================ # ============================================================================
def clean(self, context: Dict[str, Any]) -> None: def clean(self, context: Dict[str, Any]) -> None:
""" """
Clean up plugin resources. Clean up plugin resources.
Called after chroot cleanup. Called after chroot cleanup.
Args: Args:
context: Context dictionary with cleanup information context: Context dictionary with cleanup information
""" """
pass pass
def earlyprebuild(self, context: Dict[str, Any]) -> None: def earlyprebuild(self, context: Dict[str, Any]) -> None:
""" """
Very early build stage. Very early build stage.
Called before SRPM rebuild, before dependencies. Called before SRPM rebuild, before dependencies.
Args: Args:
context: Context dictionary with early build information context: Context dictionary with early build information
""" """
pass pass
def initfailed(self, context: Dict[str, Any]) -> None: def initfailed(self, context: Dict[str, Any]) -> None:
""" """
Chroot initialization failed. Chroot initialization failed.
Called when chroot creation fails. Called when chroot creation fails.
Args: Args:
context: Context dictionary with error information context: Context dictionary with error information
""" """
pass pass
def list_snapshots(self, context: Dict[str, Any]) -> None: def list_snapshots(self, context: Dict[str, Any]) -> None:
""" """
List available snapshots. List available snapshots.
Called when --list-snapshots is used. Called when --list-snapshots is used.
Args: Args:
context: Context dictionary with snapshot information context: Context dictionary with snapshot information
""" """
pass pass
def make_snapshot(self, context: Dict[str, Any]) -> None: def make_snapshot(self, context: Dict[str, Any]) -> None:
""" """
Create a snapshot. Create a snapshot.
Called when snapshot creation is requested. Called when snapshot creation is requested.
Args: Args:
context: Context dictionary with snapshot creation parameters context: Context dictionary with snapshot creation parameters
""" """
pass pass
def mount_root(self, context: Dict[str, Any]) -> None: def mount_root(self, context: Dict[str, Any]) -> None:
""" """
Mount chroot directory. Mount chroot directory.
Called before preinit, chroot exists. Called before preinit, chroot exists.
Args: Args:
context: Context dictionary with mount information context: Context dictionary with mount information
""" """
pass pass
def postbuild(self, context: Dict[str, Any]) -> None: def postbuild(self, context: Dict[str, Any]) -> None:
""" """
After build completion. After build completion.
Called after RPM/SRPM build (success/failure). Called after RPM/SRPM build (success/failure).
Args: Args:
context: Context dictionary with build results context: Context dictionary with build results
""" """
pass pass
def postchroot(self, context: Dict[str, Any]) -> None: def postchroot(self, context: Dict[str, Any]) -> None:
""" """
After chroot command. After chroot command.
Called after mock chroot command. Called after mock chroot command.
Args: Args:
context: Context dictionary with chroot command results context: Context dictionary with chroot command results
""" """
pass pass
def postclean(self, context: Dict[str, Any]) -> None: def postclean(self, context: Dict[str, Any]) -> None:
""" """
After chroot cleanup. After chroot cleanup.
Called after chroot content deletion. Called after chroot content deletion.
Args: Args:
context: Context dictionary with cleanup information context: Context dictionary with cleanup information
""" """
pass pass
def postdeps(self, context: Dict[str, Any]) -> None: def postdeps(self, context: Dict[str, Any]) -> None:
""" """
After dependency installation. After dependency installation.
Called when dependencies installed, before build. Called when dependencies installed, before build.
Args: Args:
context: Context dictionary with dependency information context: Context dictionary with dependency information
""" """
pass pass
def postinit(self, context: Dict[str, Any]) -> None: def postinit(self, context: Dict[str, Any]) -> None:
""" """
After chroot initialization. After chroot initialization.
Called when chroot ready for dependencies. Called when chroot ready for dependencies.
Args: Args:
context: Context dictionary with initialization results context: Context dictionary with initialization results
""" """
pass pass
def postshell(self, context: Dict[str, Any]) -> None: def postshell(self, context: Dict[str, Any]) -> None:
""" """
After shell exit. After shell exit.
Called after mock shell command. Called after mock shell command.
Args: Args:
context: Context dictionary with shell session information context: Context dictionary with shell session information
""" """
pass pass
def postupdate(self, context: Dict[str, Any]) -> None: def postupdate(self, context: Dict[str, Any]) -> None:
""" """
After package updates. After package updates.
Called after successful package updates. Called after successful package updates.
Args: Args:
context: Context dictionary with update information context: Context dictionary with update information
""" """
pass pass
def postumount(self, context: Dict[str, Any]) -> None: def postumount(self, context: Dict[str, Any]) -> None:
""" """
After unmounting. After unmounting.
Called when all inner mounts unmounted. Called when all inner mounts unmounted.
Args: Args:
context: Context dictionary with unmount information context: Context dictionary with unmount information
""" """
pass pass
def postapt(self, context: Dict[str, Any]) -> None: def postapt(self, context: Dict[str, Any]) -> None:
""" """
After APT operations. After APT operations.
Called after any package manager action. Called after any package manager action.
Args: Args:
context: Context dictionary with APT operation results context: Context dictionary with APT operation results
""" """
pass pass
def prebuild(self, context: Dict[str, Any]) -> None: def prebuild(self, context: Dict[str, Any]) -> None:
""" """
Before build starts. Before build starts.
Called after BuildRequires, before RPM build. Called after BuildRequires, before RPM build.
Args: Args:
context: Context dictionary with build preparation information context: Context dictionary with build preparation information
""" """
pass pass
def prechroot(self, context: Dict[str, Any]) -> None: def prechroot(self, context: Dict[str, Any]) -> None:
""" """
Before chroot command. Before chroot command.
Called before mock chroot command. Called before mock chroot command.
Args: Args:
context: Context dictionary with chroot command parameters context: Context dictionary with chroot command parameters
""" """
pass pass
def preinit(self, context: Dict[str, Any]) -> None: def preinit(self, context: Dict[str, Any]) -> None:
""" """
Before chroot initialization. Before chroot initialization.
Called when only chroot/result dirs exist. Called when only chroot/result dirs exist.
Args: Args:
context: Context dictionary with initialization parameters context: Context dictionary with initialization parameters
""" """
pass pass
def preshell(self, context: Dict[str, Any]) -> None: def preshell(self, context: Dict[str, Any]) -> None:
""" """
Before shell prompt. Before shell prompt.
Called before mock shell prompt. Called before mock shell prompt.
Args: Args:
context: Context dictionary with shell session parameters context: Context dictionary with shell session parameters
""" """
pass pass
def preapt(self, context: Dict[str, Any]) -> None: def preapt(self, context: Dict[str, Any]) -> None:
""" """
Before APT operations. Before APT operations.
Called before any package manager action. Called before any package manager action.
Args: Args:
context: Context dictionary with APT operation parameters context: Context dictionary with APT operation parameters
""" """
pass pass
def process_logs(self, context: Dict[str, Any]) -> None: def process_logs(self, context: Dict[str, Any]) -> None:
""" """
Process build logs. Process build logs.
Called after build log completion. Called after build log completion.
Args: Args:
context: Context dictionary with log information context: Context dictionary with log information
""" """
pass pass
def remove_snapshot(self, context: Dict[str, Any]) -> None: def remove_snapshot(self, context: Dict[str, Any]) -> None:
""" """
Remove snapshot. Remove snapshot.
Called when snapshot removal requested. Called when snapshot removal requested.
Args: Args:
context: Context dictionary with snapshot removal parameters context: Context dictionary with snapshot removal parameters
""" """
pass pass
def rollback_to(self, context: Dict[str, Any]) -> None: def rollback_to(self, context: Dict[str, Any]) -> None:
""" """
Rollback to snapshot. Rollback to snapshot.
Called when rollback requested. Called when rollback requested.
Args: Args:
context: Context dictionary with rollback parameters context: Context dictionary with rollback parameters
""" """
pass pass
def scrub(self, context: Dict[str, Any]) -> None: def scrub(self, context: Dict[str, Any]) -> None:
""" """
Scrub chroot. Scrub chroot.
Called when chroot scrubbing requested. Called when chroot scrubbing requested.
Args: Args:
context: Context dictionary with scrub parameters context: Context dictionary with scrub parameters
""" """
pass pass
# ============================================================================ # ============================================================================
# Plugin Lifecycle Methods # Plugin Lifecycle Methods
# ============================================================================ # ============================================================================
def setup(self, context: Dict[str, Any]) -> None: def setup(self, context: Dict[str, Any]) -> None:
""" """
Setup plugin before build. Setup plugin before build.
Called once during plugin initialization. Called once during plugin initialization.
Args: Args:
context: Context dictionary with setup information context: Context dictionary with setup information
""" """
pass pass
def teardown(self, context: Dict[str, Any]) -> None: def teardown(self, context: Dict[str, Any]) -> None:
""" """
Cleanup plugin after build. Cleanup plugin after build.
Called once during plugin cleanup. Called once during plugin cleanup.
Args: Args:
context: Context dictionary with teardown information context: Context dictionary with teardown information
""" """
pass pass
def validate_config(self, config: Any) -> bool: def validate_config(self, config: Any) -> bool:
""" """
Validate plugin configuration. Validate plugin configuration.
Args: Args:
config: Configuration to validate config: Configuration to validate
Returns: Returns:
True if configuration is valid, False otherwise True if configuration is valid, False otherwise
""" """
return True return True
def get_plugin_info(self) -> Dict[str, Any]: def get_plugin_info(self) -> Dict[str, Any]:
""" """
Get plugin information. Get plugin information.
Returns: Returns:
Dictionary with plugin information Dictionary with plugin information
""" """
return { return {
'name': self.plugin_name, "name": self.plugin_name,
'class': self.__class__.__name__, "class": self.__class__.__name__,
'enabled': self.enabled, "enabled": self.enabled,
'docstring': self.__class__.__doc__ or 'No documentation available' "docstring": self.__class__.__doc__ or "No documentation available",
} }

140
deb_mock/plugins/bind_mount.py
View file

@ -5,11 +5,11 @@ This plugin allows mounting host directories into chroot environments,
inspired by Fedora's Mock bind_mount plugin but adapted for Debian-based systems. inspired by Fedora's Mock bind_mount plugin but adapted for Debian-based systems.
""" """
import logging
import os import os
import subprocess import subprocess
import logging
from pathlib import Path from pathlib import Path
from typing import Dict, Any, List, Tuple from typing import Any, Dict, List, Tuple
from .base import BasePlugin from .base import BasePlugin
@ -19,108 +19,108 @@ logger = logging.getLogger(__name__)
class BindMountPlugin(BasePlugin): class BindMountPlugin(BasePlugin):
""" """
Mount host directories into chroot environments. Mount host directories into chroot environments.
This plugin allows users to mount host directories into the chroot This plugin allows users to mount host directories into the chroot
environment, which is useful for development workflows, shared environment, which is useful for development workflows, shared
libraries, and other scenarios where host files need to be accessible libraries, and other scenarios where host files need to be accessible
within the build environment. within the build environment.
""" """
def __init__(self, config, hook_manager): def __init__(self, config, hook_manager):
"""Initialize the BindMount plugin.""" """Initialize the BindMount plugin."""
super().__init__(config, hook_manager) super().__init__(config, hook_manager)
self.mounts = self._get_mounts() self.mounts = self._get_mounts()
self._log_info(f"Initialized with {len(self.mounts)} mount points") self._log_info(f"Initialized with {len(self.mounts)} mount points")
def _register_hooks(self): def _register_hooks(self):
"""Register bind mount hooks.""" """Register bind mount hooks."""
self.hook_manager.add_hook("mount_root", self.mount_root) self.hook_manager.add_hook("mount_root", self.mount_root)
self.hook_manager.add_hook("postumount", self.postumount) self.hook_manager.add_hook("postumount", self.postumount)
self._log_debug("Registered mount_root and postumount hooks") self._log_debug("Registered mount_root and postumount hooks")
def _get_mounts(self) -> List[Tuple[str, str]]: def _get_mounts(self) -> List[Tuple[str, str]]:
""" """
Get mount points from configuration. Get mount points from configuration.
Returns: Returns:
List of (host_path, chroot_path) tuples List of (host_path, chroot_path) tuples
""" """
plugin_config = self._get_plugin_config() plugin_config = self._get_plugin_config()
mounts = [] mounts = []
# Get mounts from configuration # Get mounts from configuration
if 'mounts' in plugin_config: if "mounts" in plugin_config:
for mount_config in plugin_config['mounts']: for mount_config in plugin_config["mounts"]:
if isinstance(mount_config, dict): if isinstance(mount_config, dict):
host_path = mount_config.get('host_path') host_path = mount_config.get("host_path")
chroot_path = mount_config.get('chroot_path') chroot_path = mount_config.get("chroot_path")
elif isinstance(mount_config, (list, tuple)) and len(mount_config) >= 2: elif isinstance(mount_config, (list, tuple)) and len(mount_config) >= 2:
host_path = mount_config[0] host_path = mount_config[0]
chroot_path = mount_config[1] chroot_path = mount_config[1]
else: else:
self._log_warning(f"Invalid mount configuration: {mount_config}") self._log_warning(f"Invalid mount configuration: {mount_config}")
continue continue
if host_path and chroot_path: if host_path and chroot_path:
mounts.append((host_path, chroot_path)) mounts.append((host_path, chroot_path))
# Legacy support for 'dirs' configuration (Mock compatibility) # Legacy support for 'dirs' configuration (Mock compatibility)
if 'dirs' in plugin_config: if "dirs" in plugin_config:
for host_path, chroot_path in plugin_config['dirs']: for host_path, chroot_path in plugin_config["dirs"]:
mounts.append((host_path, chroot_path)) mounts.append((host_path, chroot_path))
return mounts return mounts
def mount_root(self, context: Dict[str, Any]) -> None: def mount_root(self, context: Dict[str, Any]) -> None:
""" """
Mount bind mounts when chroot is mounted. Mount bind mounts when chroot is mounted.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled or not self.mounts: if not self.enabled or not self.mounts:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
self._log_warning("No chroot_path in context, skipping bind mounts") self._log_warning("No chroot_path in context, skipping bind mounts")
return return
self._log_info(f"Setting up {len(self.mounts)} bind mounts") self._log_info(f"Setting up {len(self.mounts)} bind mounts")
for host_path, chroot_mount_path in self.mounts: for host_path, chroot_mount_path in self.mounts:
try: try:
self._setup_bind_mount(host_path, chroot_mount_path, chroot_path) self._setup_bind_mount(host_path, chroot_mount_path, chroot_path)
except Exception as e: except Exception as e:
self._log_error(f"Failed to setup bind mount {host_path} -> {chroot_mount_path}: {e}") self._log_error(f"Failed to setup bind mount {host_path} -> {chroot_mount_path}: {e}")
def postumount(self, context: Dict[str, Any]) -> None: def postumount(self, context: Dict[str, Any]) -> None:
""" """
Unmount bind mounts when chroot is unmounted. Unmount bind mounts when chroot is unmounted.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled or not self.mounts: if not self.enabled or not self.mounts:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
self._log_warning("No chroot_path in context, skipping bind mount cleanup") self._log_warning("No chroot_path in context, skipping bind mount cleanup")
return return
self._log_info(f"Cleaning up {len(self.mounts)} bind mounts") self._log_info(f"Cleaning up {len(self.mounts)} bind mounts")
for host_path, chroot_mount_path in self.mounts: for host_path, chroot_mount_path in self.mounts:
try: try:
self._cleanup_bind_mount(chroot_mount_path, chroot_path) self._cleanup_bind_mount(chroot_mount_path, chroot_path)
except Exception as e: except Exception as e:
self._log_error(f"Failed to cleanup bind mount {chroot_mount_path}: {e}") self._log_error(f"Failed to cleanup bind mount {chroot_mount_path}: {e}")
def _setup_bind_mount(self, host_path: str, chroot_mount_path: str, chroot_path: str) -> None: def _setup_bind_mount(self, host_path: str, chroot_mount_path: str, chroot_path: str) -> None:
""" """
Setup a single bind mount. Setup a single bind mount.
Args: Args:
host_path: Path on the host to mount host_path: Path on the host to mount
chroot_mount_path: Path in the chroot where to mount chroot_mount_path: Path in the chroot where to mount
@ -130,77 +130,77 @@ class BindMountPlugin(BasePlugin):
if not os.path.exists(host_path): if not os.path.exists(host_path):
self._log_warning(f"Host path does not exist: {host_path}") self._log_warning(f"Host path does not exist: {host_path}")
return return
# Create full chroot mount path # Create full chroot mount path
full_chroot_path = os.path.join(chroot_path, chroot_mount_path.lstrip('/')) full_chroot_path = os.path.join(chroot_path, chroot_mount_path.lstrip("/"))
# Create mount point directory if it doesn't exist # Create mount point directory if it doesn't exist
mount_point_dir = os.path.dirname(full_chroot_path) mount_point_dir = os.path.dirname(full_chroot_path)
if not os.path.exists(mount_point_dir): if not os.path.exists(mount_point_dir):
os.makedirs(mount_point_dir, exist_ok=True) os.makedirs(mount_point_dir, exist_ok=True)
self._log_debug(f"Created mount point directory: {mount_point_dir}") self._log_debug(f"Created mount point directory: {mount_point_dir}")
# Create mount point if it's a file # Create mount point if it's a file
if os.path.isfile(host_path) and not os.path.exists(full_chroot_path): if os.path.isfile(host_path) and not os.path.exists(full_chroot_path):
Path(full_chroot_path).touch() Path(full_chroot_path).touch()
self._log_debug(f"Created file mount point: {full_chroot_path}") self._log_debug(f"Created file mount point: {full_chroot_path}")
# Perform the bind mount # Perform the bind mount
try: try:
cmd = ['mount', '--bind', host_path, full_chroot_path] cmd = ["mount", "--bind", host_path, full_chroot_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
self._log_debug(f"Successfully mounted {host_path} -> {full_chroot_path}") self._log_debug(f"Successfully mounted {host_path} -> {full_chroot_path}")
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"Failed to mount {host_path} -> {full_chroot_path}: {e.stderr}") self._log_error(f"Failed to mount {host_path} -> {full_chroot_path}: {e.stderr}")
raise raise
except FileNotFoundError: except FileNotFoundError:
self._log_error("mount command not found - ensure mount is available") self._log_error("mount command not found - ensure mount is available")
raise raise
def _cleanup_bind_mount(self, chroot_mount_path: str, chroot_path: str) -> None: def _cleanup_bind_mount(self, chroot_mount_path: str, chroot_path: str) -> None:
""" """
Cleanup a single bind mount. Cleanup a single bind mount.
Args: Args:
chroot_mount_path: Path in the chroot that was mounted chroot_mount_path: Path in the chroot that was mounted
chroot_path: Base chroot path chroot_path: Base chroot path
""" """
full_chroot_path = os.path.join(chroot_path, chroot_mount_path.lstrip('/')) full_chroot_path = os.path.join(chroot_path, chroot_mount_path.lstrip("/"))
try: try:
cmd = ['umount', full_chroot_path] cmd = ["umount", full_chroot_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
self._log_debug(f"Successfully unmounted: {full_chroot_path}") self._log_debug(f"Successfully unmounted: {full_chroot_path}")
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError:
# Try force unmount if regular unmount fails # Try force unmount if regular unmount fails
try: try:
cmd = ['umount', '-f', full_chroot_path] cmd = ["umount", "-f", full_chroot_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
self._log_debug(f"Successfully force unmounted: {full_chroot_path}") self._log_debug(f"Successfully force unmounted: {full_chroot_path}")
except subprocess.CalledProcessError as e2: except subprocess.CalledProcessError as e2:
self._log_warning(f"Failed to unmount {full_chroot_path}: {e2.stderr}") self._log_warning(f"Failed to unmount {full_chroot_path}: {e2.stderr}")
except FileNotFoundError: except FileNotFoundError:
self._log_error("umount command not found - ensure umount is available") self._log_error("umount command not found - ensure umount is available")
def validate_config(self, config: Any) -> bool: def validate_config(self, config: Any) -> bool:
""" """
Validate plugin configuration. Validate plugin configuration.
Args: Args:
config: Configuration to validate config: Configuration to validate
Returns: Returns:
True if configuration is valid, False otherwise True if configuration is valid, False otherwise
""" """
plugin_config = getattr(config, 'plugins', {}).get('bind_mount', {}) plugin_config = getattr(config, "plugins", {}).get("bind_mount", {})
# Check mounts configuration # Check mounts configuration
if 'mounts' in plugin_config: if "mounts" in plugin_config:
for mount_config in plugin_config['mounts']: for mount_config in plugin_config["mounts"]:
if isinstance(mount_config, dict): if isinstance(mount_config, dict):
if not all(key in mount_config for key in ['host_path', 'chroot_path']): if not all(key in mount_config for key in ["host_path", "chroot_path"]):
self._log_error("Mount configuration missing required keys: host_path, chroot_path") self._log_error("Mount configuration missing required keys: host_path, chroot_path")
return False return False
elif isinstance(mount_config, (list, tuple)): elif isinstance(mount_config, (list, tuple)):
@ -210,27 +210,29 @@ class BindMountPlugin(BasePlugin):
else: else:
self._log_error(f"Invalid mount configuration format: {mount_config}") self._log_error(f"Invalid mount configuration format: {mount_config}")
return False return False
# Check dirs configuration (legacy) # Check dirs configuration (legacy)
if 'dirs' in plugin_config: if "dirs" in plugin_config:
for host_path, chroot_path in plugin_config['dirs']: for host_path, chroot_path in plugin_config["dirs"]:
if not host_path or not chroot_path: if not host_path or not chroot_path:
self._log_error("Invalid dirs configuration: host_path and chroot_path must be non-empty") self._log_error("Invalid dirs configuration: host_path and chroot_path must be non-empty")
return False return False
return True return True
def get_plugin_info(self) -> Dict[str, Any]: def get_plugin_info(self) -> Dict[str, Any]:
""" """
Get plugin information. Get plugin information.
Returns: Returns:
Dictionary with plugin information Dictionary with plugin information
""" """
info = super().get_plugin_info() info = super().get_plugin_info()
info.update({ info.update(
'mounts': self.mounts, {
'mount_count': len(self.mounts), "mounts": self.mounts,
'hooks': ['mount_root', 'postumount'] "mount_count": len(self.mounts),
}) "hooks": ["mount_root", "postumount"],
return info }
)
return info

202
deb_mock/plugins/compress_logs.py
View file

@ -5,11 +5,11 @@ This plugin compresses build logs to save disk space,
inspired by Fedora's Mock compress_logs plugin but adapted for Debian-based systems. inspired by Fedora's Mock compress_logs plugin but adapted for Debian-based systems.
""" """
import logging
import os import os
import subprocess import subprocess
import logging
from pathlib import Path from pathlib import Path
from typing import Dict, Any, List from typing import Any, Dict, List
from .base import BasePlugin from .base import BasePlugin
@ -19,287 +19,291 @@ logger = logging.getLogger(__name__)
class CompressLogsPlugin(BasePlugin): class CompressLogsPlugin(BasePlugin):
""" """
Compress build logs to save disk space. Compress build logs to save disk space.
This plugin automatically compresses build logs after build completion, This plugin automatically compresses build logs after build completion,
which is useful for CI/CD environments and long-term log storage. which is useful for CI/CD environments and long-term log storage.
""" """
def __init__(self, config, hook_manager): def __init__(self, config, hook_manager):
"""Initialize the CompressLogs plugin.""" """Initialize the CompressLogs plugin."""
super().__init__(config, hook_manager) super().__init__(config, hook_manager)
self.compression = self._get_compression_settings() self.compression = self._get_compression_settings()
self._log_info(f"Initialized with compression: {self.compression['method']}") self._log_info(f"Initialized with compression: {self.compression['method']}")
def _register_hooks(self): def _register_hooks(self):
"""Register log compression hooks.""" """Register log compression hooks."""
self.hook_manager.add_hook("process_logs", self.process_logs) self.hook_manager.add_hook("process_logs", self.process_logs)
self._log_debug("Registered process_logs hook") self._log_debug("Registered process_logs hook")
def _get_compression_settings(self) -> Dict[str, Any]: def _get_compression_settings(self) -> Dict[str, Any]:
""" """
Get compression settings from configuration. Get compression settings from configuration.
Returns: Returns:
Dictionary with compression settings Dictionary with compression settings
""" """
plugin_config = self._get_plugin_config() plugin_config = self._get_plugin_config()
return { return {
'method': plugin_config.get('compression', 'gzip'), "method": plugin_config.get("compression", "gzip"),
'level': plugin_config.get('level', 9), "level": plugin_config.get("level", 9),
'extensions': plugin_config.get('extensions', ['.log']), "extensions": plugin_config.get("extensions", [".log"]),
'exclude_patterns': plugin_config.get('exclude_patterns', []), "exclude_patterns": plugin_config.get("exclude_patterns", []),
'min_size': plugin_config.get('min_size', 0), # Minimum file size to compress "min_size": plugin_config.get("min_size", 0), # Minimum file size to compress
'command': plugin_config.get('command', None) # Custom compression command "command": plugin_config.get("command", None), # Custom compression command
} }
def process_logs(self, context: Dict[str, Any]) -> None: def process_logs(self, context: Dict[str, Any]) -> None:
""" """
Compress build logs after build completion. Compress build logs after build completion.
Args: Args:
context: Context dictionary with log information context: Context dictionary with log information
""" """
if not self.enabled: if not self.enabled:
return return
log_dir = context.get('log_dir') log_dir = context.get("log_dir")
if not log_dir: if not log_dir:
self._log_warning("No log_dir in context, skipping log compression") self._log_warning("No log_dir in context, skipping log compression")
return return
if not os.path.exists(log_dir): if not os.path.exists(log_dir):
self._log_warning(f"Log directory does not exist: {log_dir}") self._log_warning(f"Log directory does not exist: {log_dir}")
return return
self._log_info(f"Compressing logs in {log_dir}") self._log_info(f"Compressing logs in {log_dir}")
compressed_count = 0 compressed_count = 0
total_size_saved = 0 total_size_saved = 0
for log_file in self._find_log_files(log_dir): for log_file in self._find_log_files(log_dir):
try: try:
original_size = os.path.getsize(log_file) original_size = os.path.getsize(log_file)
# Check minimum size requirement # Check minimum size requirement
if original_size < self.compression['min_size']: if original_size < self.compression["min_size"]:
self._log_debug(f"Skipping {log_file} (size {original_size} < {self.compression['min_size']})") self._log_debug(f"Skipping {log_file} (size {original_size} < {self.compression['min_size']})")
continue continue
# Check if already compressed # Check if already compressed
if self._is_already_compressed(log_file): if self._is_already_compressed(log_file):
self._log_debug(f"Skipping already compressed file: {log_file}") self._log_debug(f"Skipping already compressed file: {log_file}")
continue continue
# Compress the file # Compress the file
compressed_size = self._compress_file(log_file) compressed_size = self._compress_file(log_file)
if compressed_size is not None: if compressed_size is not None:
compressed_count += 1 compressed_count += 1
size_saved = original_size - compressed_size size_saved = original_size - compressed_size
total_size_saved += size_saved total_size_saved += size_saved
self._log_debug(f"Compressed {log_file}: {original_size} -> {compressed_size} bytes (saved {size_saved})") self._log_debug(
f"Compressed {log_file}: {original_size} -> {compressed_size} bytes (saved {size_saved})"
)
except Exception as e: except Exception as e:
self._log_error(f"Failed to compress {log_file}: {e}") self._log_error(f"Failed to compress {log_file}: {e}")
self._log_info(f"Compressed {compressed_count} files, saved {total_size_saved} bytes") self._log_info(f"Compressed {compressed_count} files, saved {total_size_saved} bytes")
def _find_log_files(self, log_dir: str) -> List[str]: def _find_log_files(self, log_dir: str) -> List[str]:
""" """
Find log files to compress. Find log files to compress.
Args: Args:
log_dir: Directory containing log files log_dir: Directory containing log files
Returns: Returns:
List of log file paths List of log file paths
""" """
log_files = [] log_files = []
for extension in self.compression['extensions']: for extension in self.compression["extensions"]:
pattern = f"*{extension}" pattern = f"*{extension}"
log_files.extend(Path(log_dir).glob(pattern)) log_files.extend(Path(log_dir).glob(pattern))
# Filter out excluded patterns # Filter out excluded patterns
filtered_files = [] filtered_files = []
for log_file in log_files: for log_file in log_files:
if not self._is_excluded(log_file.name): if not self._is_excluded(log_file.name):
filtered_files.append(str(log_file)) filtered_files.append(str(log_file))
return filtered_files return filtered_files
def _is_excluded(self, filename: str) -> bool: def _is_excluded(self, filename: str) -> bool:
""" """
Check if file should be excluded from compression. Check if file should be excluded from compression.
Args: Args:
filename: Name of the file to check filename: Name of the file to check
Returns: Returns:
True if file should be excluded, False otherwise True if file should be excluded, False otherwise
""" """
for pattern in self.compression['exclude_patterns']: for pattern in self.compression["exclude_patterns"]:
if pattern in filename: if pattern in filename:
return True return True
return False return False
def _is_already_compressed(self, file_path: str) -> bool: def _is_already_compressed(self, file_path: str) -> bool:
""" """
Check if file is already compressed. Check if file is already compressed.
Args: Args:
file_path: Path to the file to check file_path: Path to the file to check
Returns: Returns:
True if file is already compressed, False otherwise True if file is already compressed, False otherwise
""" """
compressed_extensions = ['.gz', '.bz2', '.xz', '.lzma', '.zst'] compressed_extensions = [".gz", ".bz2", ".xz", ".lzma", ".zst"]
return any(file_path.endswith(ext) for ext in compressed_extensions) return any(file_path.endswith(ext) for ext in compressed_extensions)
def _compress_file(self, file_path: str) -> int: def _compress_file(self, file_path: str) -> int:
""" """
Compress a single file. Compress a single file.
Args: Args:
file_path: Path to the file to compress file_path: Path to the file to compress
Returns: Returns:
Size of the compressed file, or None if compression failed Size of the compressed file, or None if compression failed
""" """
method = self.compression['method'] method = self.compression["method"]
level = self.compression['level'] level = self.compression["level"]
# Use custom command if specified # Use custom command if specified
if self.compression['command']: if self.compression["command"]:
return self._compress_with_custom_command(file_path) return self._compress_with_custom_command(file_path)
# Use standard compression methods # Use standard compression methods
if method == 'gzip': if method == "gzip":
return self._compress_gzip(file_path, level) return self._compress_gzip(file_path, level)
elif method == 'bzip2': elif method == "bzip2":
return self._compress_bzip2(file_path, level) return self._compress_bzip2(file_path, level)
elif method == 'xz': elif method == "xz":
return self._compress_xz(file_path, level) return self._compress_xz(file_path, level)
elif method == 'zstd': elif method == "zstd":
return self._compress_zstd(file_path, level) return self._compress_zstd(file_path, level)
else: else:
self._log_error(f"Unsupported compression method: {method}") self._log_error(f"Unsupported compression method: {method}")
return None return None
def _compress_gzip(self, file_path: str, level: int) -> int: def _compress_gzip(self, file_path: str, level: int) -> int:
"""Compress file using gzip.""" """Compress file using gzip."""
try: try:
cmd = ['gzip', f'-{level}', file_path] cmd = ["gzip", f"-{level}", file_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
compressed_path = f"{file_path}.gz" compressed_path = f"{file_path}.gz"
return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"gzip compression failed: {e.stderr}") self._log_error(f"gzip compression failed: {e.stderr}")
return None return None
def _compress_bzip2(self, file_path: str, level: int) -> int: def _compress_bzip2(self, file_path: str, level: int) -> int:
"""Compress file using bzip2.""" """Compress file using bzip2."""
try: try:
cmd = ['bzip2', f'-{level}', file_path] cmd = ["bzip2", f"-{level}", file_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
compressed_path = f"{file_path}.bz2" compressed_path = f"{file_path}.bz2"
return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"bzip2 compression failed: {e.stderr}") self._log_error(f"bzip2 compression failed: {e.stderr}")
return None return None
def _compress_xz(self, file_path: str, level: int) -> int: def _compress_xz(self, file_path: str, level: int) -> int:
"""Compress file using xz.""" """Compress file using xz."""
try: try:
cmd = ['xz', f'-{level}', file_path] cmd = ["xz", f"-{level}", file_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
compressed_path = f"{file_path}.xz" compressed_path = f"{file_path}.xz"
return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"xz compression failed: {e.stderr}") self._log_error(f"xz compression failed: {e.stderr}")
return None return None
def _compress_zstd(self, file_path: str, level: int) -> int: def _compress_zstd(self, file_path: str, level: int) -> int:
"""Compress file using zstd.""" """Compress file using zstd."""
try: try:
cmd = ['zstd', f'-{level}', file_path] cmd = ["zstd", f"-{level}", file_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
compressed_path = f"{file_path}.zst" compressed_path = f"{file_path}.zst"
return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None return os.path.getsize(compressed_path) if os.path.exists(compressed_path) else None
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"zstd compression failed: {e.stderr}") self._log_error(f"zstd compression failed: {e.stderr}")
return None return None
def _compress_with_custom_command(self, file_path: str) -> int: def _compress_with_custom_command(self, file_path: str) -> int:
"""Compress file using custom command.""" """Compress file using custom command."""
try: try:
command = self.compression['command'].format(file=file_path) command = self.compression["command"].format(file=file_path)
result = subprocess.run(command, shell=True, capture_output=True, text=True, check=True) subprocess.run(command, shell=True, capture_output=True, text=True, check=True)
# Try to determine compressed file size # Try to determine compressed file size
# This is a best-effort approach since custom commands may vary # This is a best-effort approach since custom commands may vary
for ext in ['.gz', '.bz2', '.xz', '.zst', '.lzma']: for ext in [".gz", ".bz2", ".xz", ".zst", ".lzma"]:
compressed_path = f"{file_path}{ext}" compressed_path = f"{file_path}{ext}"
if os.path.exists(compressed_path): if os.path.exists(compressed_path):
return os.path.getsize(compressed_path) return os.path.getsize(compressed_path)
return None return None
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"Custom compression command failed: {e.stderr}") self._log_error(f"Custom compression command failed: {e.stderr}")
return None return None
def validate_config(self, config: Any) -> bool: def validate_config(self, config: Any) -> bool:
""" """
Validate plugin configuration. Validate plugin configuration.
Args: Args:
config: Configuration to validate config: Configuration to validate
Returns: Returns:
True if configuration is valid, False otherwise True if configuration is valid, False otherwise
""" """
plugin_config = getattr(config, 'plugins', {}).get('compress_logs', {}) plugin_config = getattr(config, "plugins", {}).get("compress_logs", {})
# Validate compression method # Validate compression method
valid_methods = ['gzip', 'bzip2', 'xz', 'zstd'] valid_methods = ["gzip", "bzip2", "xz", "zstd"]
method = plugin_config.get('compression', 'gzip') method = plugin_config.get("compression", "gzip")
if method not in valid_methods and not plugin_config.get('command'): if method not in valid_methods and not plugin_config.get("command"):
self._log_error(f"Invalid compression method: {method}. Valid methods: {valid_methods}") self._log_error(f"Invalid compression method: {method}. Valid methods: {valid_methods}")
return False return False
# Validate compression level # Validate compression level
level = plugin_config.get('level', 9) level = plugin_config.get("level", 9)
if not isinstance(level, int) or level < 1 or level > 9: if not isinstance(level, int) or level < 1 or level > 9:
self._log_error(f"Invalid compression level: {level}. Must be 1-9") self._log_error(f"Invalid compression level: {level}. Must be 1-9")
return False return False
# Validate extensions # Validate extensions
extensions = plugin_config.get('extensions', ['.log']) extensions = plugin_config.get("extensions", [".log"])
if not isinstance(extensions, list): if not isinstance(extensions, list):
self._log_error("Extensions must be a list") self._log_error("Extensions must be a list")
return False return False
# Validate min_size # Validate min_size
min_size = plugin_config.get('min_size', 0) min_size = plugin_config.get("min_size", 0)
if not isinstance(min_size, int) or min_size < 0: if not isinstance(min_size, int) or min_size < 0:
self._log_error(f"Invalid min_size: {min_size}. Must be non-negative integer") self._log_error(f"Invalid min_size: {min_size}. Must be non-negative integer")
return False return False
return True return True
def get_plugin_info(self) -> Dict[str, Any]: def get_plugin_info(self) -> Dict[str, Any]:
""" """
Get plugin information. Get plugin information.
Returns: Returns:
Dictionary with plugin information Dictionary with plugin information
""" """
info = super().get_plugin_info() info = super().get_plugin_info()
info.update({ info.update(
'compression_method': self.compression['method'], {
'compression_level': self.compression['level'], "compression_method": self.compression["method"],
'extensions': self.compression['extensions'], "compression_level": self.compression["level"],
'min_size': self.compression['min_size'], "extensions": self.compression["extensions"],
'hooks': ['process_logs'] "min_size": self.compression["min_size"],
}) "hooks": ["process_logs"],
return info }
)
return info

178
deb_mock/plugins/hook_manager.py
View file

@ -6,7 +6,7 @@ inspired by Fedora's Mock plugin hooks but adapted for Debian-based workflows.
""" """
import logging import logging
from typing import Dict, List, Callable, Any, Optional from typing import Any, Callable, Dict, List, Optional
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -14,73 +14,73 @@ logger = logging.getLogger(__name__)
class HookManager: class HookManager:
""" """
Manages plugin hooks and their execution. Manages plugin hooks and their execution.
This class provides the core functionality for registering and executing This class provides the core functionality for registering and executing
plugin hooks at specific points in the build lifecycle, following the plugin hooks at specific points in the build lifecycle, following the
same pattern as Mock's plugin hook system. same pattern as Mock's plugin hook system.
""" """
def __init__(self): def __init__(self):
"""Initialize the hook manager.""" """Initialize the hook manager."""
self.hooks: Dict[str, List[Callable]] = {} self.hooks: Dict[str, List[Callable]] = {}
self.hook_contexts: Dict[str, Dict[str, Any]] = {} self.hook_contexts: Dict[str, Dict[str, Any]] = {}
# Define available hook points (based on Mock's hook system) # Define available hook points (based on Mock's hook system)
self.available_hooks = { self.available_hooks = {
'clean': 'Clean up plugin resources', "clean": "Clean up plugin resources",
'earlyprebuild': 'Very early build stage', "earlyprebuild": "Very early build stage",
'initfailed': 'Chroot initialization failed', "initfailed": "Chroot initialization failed",
'list_snapshots': 'List available snapshots', "list_snapshots": "List available snapshots",
'make_snapshot': 'Create a snapshot', "make_snapshot": "Create a snapshot",
'mount_root': 'Mount chroot directory', "mount_root": "Mount chroot directory",
'postbuild': 'After build completion', "postbuild": "After build completion",
'postchroot': 'After chroot command', "postchroot": "After chroot command",
'postclean': 'After chroot cleanup', "postclean": "After chroot cleanup",
'postdeps': 'After dependency installation', "postdeps": "After dependency installation",
'postinit': 'After chroot initialization', "postinit": "After chroot initialization",
'postshell': 'After shell exit', "postshell": "After shell exit",
'postupdate': 'After package updates', "postupdate": "After package updates",
'postumount': 'After unmounting', "postumount": "After unmounting",
'postapt': 'After APT operations', "postapt": "After APT operations",
'prebuild': 'Before build starts', "prebuild": "Before build starts",
'prechroot': 'Before chroot command', "prechroot": "Before chroot command",
'preinit': 'Before chroot initialization', "preinit": "Before chroot initialization",
'preshell': 'Before shell prompt', "preshell": "Before shell prompt",
'preapt': 'Before APT operations', "preapt": "Before APT operations",
'process_logs': 'Process build logs', "process_logs": "Process build logs",
'remove_snapshot': 'Remove snapshot', "remove_snapshot": "Remove snapshot",
'rollback_to': 'Rollback to snapshot', "rollback_to": "Rollback to snapshot",
'scrub': 'Scrub chroot' "scrub": "Scrub chroot",
} }
def add_hook(self, hook_name: str, callback: Callable) -> None: def add_hook(self, hook_name: str, callback: Callable) -> None:
""" """
Register a hook callback. Register a hook callback.
Args: Args:
hook_name: Name of the hook to register for hook_name: Name of the hook to register for
callback: Function to call when hook is triggered callback: Function to call when hook is triggered
Raises: Raises:
ValueError: If hook_name is not a valid hook point ValueError: If hook_name is not a valid hook point
""" """
if hook_name not in self.available_hooks: if hook_name not in self.available_hooks:
raise ValueError(f"Invalid hook name: {hook_name}. Available hooks: {list(self.available_hooks.keys())}") raise ValueError(f"Invalid hook name: {hook_name}. Available hooks: {list(self.available_hooks.keys())}")
if hook_name not in self.hooks: if hook_name not in self.hooks:
self.hooks[hook_name] = [] self.hooks[hook_name] = []
self.hooks[hook_name].append(callback) self.hooks[hook_name].append(callback)
logger.debug(f"Registered hook '{hook_name}' with callback {callback.__name__}") logger.debug(f"Registered hook '{hook_name}' with callback {callback.__name__}")
def call_hook(self, hook_name: str, context: Optional[Dict[str, Any]] = None) -> None: def call_hook(self, hook_name: str, context: Optional[Dict[str, Any]] = None) -> None:
""" """
Execute all registered hooks for a given hook name. Execute all registered hooks for a given hook name.
Args: Args:
hook_name: Name of the hook to trigger hook_name: Name of the hook to trigger
context: Context dictionary to pass to hook callbacks context: Context dictionary to pass to hook callbacks
Note: Note:
Hook execution errors are logged but don't fail the build, Hook execution errors are logged but don't fail the build,
following Mock's behavior. following Mock's behavior.
@ -88,36 +88,36 @@ class HookManager:
if hook_name not in self.hooks: if hook_name not in self.hooks:
logger.debug(f"No hooks registered for '{hook_name}'") logger.debug(f"No hooks registered for '{hook_name}'")
return return
context = context or {} context = context or {}
logger.debug(f"Calling {len(self.hooks[hook_name])} hooks for '{hook_name}'") logger.debug(f"Calling {len(self.hooks[hook_name])} hooks for '{hook_name}'")
for i, callback in enumerate(self.hooks[hook_name]): for i, callback in enumerate(self.hooks[hook_name]):
try: try:
logger.debug(f"Executing hook {i+1}/{len(self.hooks[hook_name])}: {callback.__name__}") logger.debug(f"Executing hook {i + 1}/{len(self.hooks[hook_name])}: {callback.__name__}")
callback(context) callback(context)
logger.debug(f"Successfully executed hook: {callback.__name__}") logger.debug(f"Successfully executed hook: {callback.__name__}")
except Exception as e: except Exception as e:
logger.warning(f"Hook '{hook_name}' failed in {callback.__name__}: {e}") logger.warning(f"Hook '{hook_name}' failed in {callback.__name__}: {e}")
# Continue with other hooks - don't fail the build # Continue with other hooks - don't fail the build
def call_hook_with_result(self, hook_name: str, context: Optional[Dict[str, Any]] = None) -> List[Any]: def call_hook_with_result(self, hook_name: str, context: Optional[Dict[str, Any]] = None) -> List[Any]:
""" """
Execute all registered hooks and collect their results. Execute all registered hooks and collect their results.
Args: Args:
hook_name: Name of the hook to trigger hook_name: Name of the hook to trigger
context: Context dictionary to pass to hook callbacks context: Context dictionary to pass to hook callbacks
Returns: Returns:
List of results from hook callbacks (None for failed hooks) List of results from hook callbacks (None for failed hooks)
""" """
if hook_name not in self.hooks: if hook_name not in self.hooks:
return [] return []
context = context or {} context = context or {}
results = [] results = []
for callback in self.hooks[hook_name]: for callback in self.hooks[hook_name]:
try: try:
result = callback(context) result = callback(context)
@ -125,81 +125,78 @@ class HookManager:
except Exception as e: except Exception as e:
logger.warning(f"Hook '{hook_name}' failed in {callback.__name__}: {e}") logger.warning(f"Hook '{hook_name}' failed in {callback.__name__}: {e}")
results.append(None) results.append(None)
return results return results
def get_hook_names(self) -> List[str]: def get_hook_names(self) -> List[str]:
""" """
Get list of available hook names. Get list of available hook names.
Returns: Returns:
List of hook names that have been registered List of hook names that have been registered
""" """
return list(self.hooks.keys()) return list(self.hooks.keys())
def get_available_hooks(self) -> Dict[str, str]: def get_available_hooks(self) -> Dict[str, str]:
""" """
Get all available hook points with descriptions. Get all available hook points with descriptions.
Returns: Returns:
Dictionary mapping hook names to descriptions Dictionary mapping hook names to descriptions
""" """
return self.available_hooks.copy() return self.available_hooks.copy()
def get_hook_info(self, hook_name: str) -> Dict[str, Any]: def get_hook_info(self, hook_name: str) -> Dict[str, Any]:
""" """
Get information about a specific hook. Get information about a specific hook.
Args: Args:
hook_name: Name of the hook hook_name: Name of the hook
Returns: Returns:
Dictionary with hook information Dictionary with hook information
""" """
if hook_name not in self.available_hooks: if hook_name not in self.available_hooks:
return {'error': f'Hook "{hook_name}" not found'} return {"error": f'Hook "{hook_name}" not found'}
info = { info = {
'name': hook_name, "name": hook_name,
'description': self.available_hooks[hook_name], "description": self.available_hooks[hook_name],
'registered_callbacks': len(self.hooks.get(hook_name, [])), "registered_callbacks": len(self.hooks.get(hook_name, [])),
'callbacks': [] "callbacks": [],
} }
if hook_name in self.hooks: if hook_name in self.hooks:
for callback in self.hooks[hook_name]: for callback in self.hooks[hook_name]:
info['callbacks'].append({ info["callbacks"].append({"name": callback.__name__, "module": callback.__module__})
'name': callback.__name__,
'module': callback.__module__
})
return info return info
def remove_hook(self, hook_name: str, callback: Callable) -> bool: def remove_hook(self, hook_name: str, callback: Callable) -> bool:
""" """
Remove a specific hook callback. Remove a specific hook callback.
Args: Args:
hook_name: Name of the hook hook_name: Name of the hook
callback: Callback function to remove callback: Callback function to remove
Returns: Returns:
True if callback was removed, False if not found True if callback was removed, False if not found
""" """
if hook_name not in self.hooks: if hook_name not in self.hooks:
return False return False
try: try:
self.hooks[hook_name].remove(callback) self.hooks[hook_name].remove(callback)
logger.debug(f"Removed hook '{hook_name}' callback {callback.__name__}") logger.debug(f"Removed hook '{hook_name}' callback {callback.__name__}")
return True return True
except ValueError: except ValueError:
return False return False
def clear_hooks(self, hook_name: Optional[str] = None) -> None: def clear_hooks(self, hook_name: Optional[str] = None) -> None:
""" """
Clear all hooks or hooks for a specific hook name. Clear all hooks or hooks for a specific hook name.
Args: Args:
hook_name: Specific hook name to clear, or None to clear all hook_name: Specific hook name to clear, or None to clear all
""" """
@ -209,52 +206,51 @@ class HookManager:
elif hook_name in self.hooks: elif hook_name in self.hooks:
self.hooks[hook_name].clear() self.hooks[hook_name].clear()
logger.debug(f"Cleared hooks for '{hook_name}'") logger.debug(f"Cleared hooks for '{hook_name}'")
def get_hook_statistics(self) -> Dict[str, Any]: def get_hook_statistics(self) -> Dict[str, Any]:
""" """
Get statistics about hook usage. Get statistics about hook usage.
Returns: Returns:
Dictionary with hook statistics Dictionary with hook statistics
""" """
stats = { stats = {
'total_hooks': len(self.hooks), "total_hooks": len(self.hooks),
'total_callbacks': sum(len(callbacks) for callbacks in self.hooks.values()), "total_callbacks": sum(len(callbacks) for callbacks in self.hooks.values()),
'hooks_with_callbacks': len([h for h in self.hooks.values() if h]), "hooks_with_callbacks": len([h for h in self.hooks.values() if h]),
'available_hooks': len(self.available_hooks), "available_hooks": len(self.available_hooks),
'hook_details': {} "hook_details": {},
} }
for hook_name in self.available_hooks: for hook_name in self.available_hooks:
stats['hook_details'][hook_name] = { stats["hook_details"][hook_name] = {
'description': self.available_hooks[hook_name], "description": self.available_hooks[hook_name],
'registered': hook_name in self.hooks, "registered": hook_name in self.hooks,
'callback_count': len(self.hooks.get(hook_name, [])) "callback_count": len(self.hooks.get(hook_name, [])),
} }
return stats return stats
def validate_hook_name(self, hook_name: str) -> bool: def validate_hook_name(self, hook_name: str) -> bool:
""" """
Validate if a hook name is valid. Validate if a hook name is valid.
Args: Args:
hook_name: Name of the hook to validate hook_name: Name of the hook to validate
Returns: Returns:
True if hook name is valid, False otherwise True if hook name is valid, False otherwise
""" """
return hook_name in self.available_hooks return hook_name in self.available_hooks
def get_hook_suggestions(self, partial_name: str) -> List[str]: def get_hook_suggestions(self, partial_name: str) -> List[str]:
""" """
Get hook name suggestions based on partial input. Get hook name suggestions based on partial input.
Args: Args:
partial_name: Partial hook name partial_name: Partial hook name
Returns: Returns:
List of matching hook names List of matching hook names
""" """
return [name for name in self.available_hooks.keys() return [name for name in self.available_hooks.keys() if name.startswith(partial_name)]
if name.startswith(partial_name)]

247
deb_mock/plugins/registry.py
View file

@ -5,9 +5,10 @@ This module provides the plugin registration and management functionality
for the Deb-Mock plugin system, inspired by Fedora's Mock plugin architecture. for the Deb-Mock plugin system, inspired by Fedora's Mock plugin architecture.
""" """
import logging
import importlib import importlib
from typing import Dict, Type, Any, Optional import logging
from typing import Any, Dict, Optional, Type
from .base import BasePlugin from .base import BasePlugin
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
@ -16,102 +17,106 @@ logger = logging.getLogger(__name__)
class PluginRegistry: class PluginRegistry:
""" """
Manages plugin registration and instantiation. Manages plugin registration and instantiation.
This class provides the functionality for registering plugin classes This class provides the functionality for registering plugin classes
and creating plugin instances, following Mock's plugin system pattern. and creating plugin instances, following Mock's plugin system pattern.
""" """
def __init__(self): def __init__(self):
"""Initialize the plugin registry.""" """Initialize the plugin registry."""
self.plugins: Dict[str, Type[BasePlugin]] = {} self.plugins: Dict[str, Type[BasePlugin]] = {}
self.plugin_metadata: Dict[str, Dict[str, Any]] = {} self.plugin_metadata: Dict[str, Dict[str, Any]] = {}
# Auto-register built-in plugins # Auto-register built-in plugins
self._register_builtin_plugins() self._register_builtin_plugins()
def register(self, plugin_name: str, plugin_class: Type[BasePlugin], def register(
metadata: Optional[Dict[str, Any]] = None) -> None: self,
plugin_name: str,
plugin_class: Type[BasePlugin],
metadata: Optional[Dict[str, Any]] = None,
) -> None:
""" """
Register a plugin class. Register a plugin class.
Args: Args:
plugin_name: Name of the plugin plugin_name: Name of the plugin
plugin_class: Plugin class to register plugin_class: Plugin class to register
metadata: Optional metadata about the plugin metadata: Optional metadata about the plugin
Raises: Raises:
ValueError: If plugin_name is already registered ValueError: If plugin_name is already registered
TypeError: If plugin_class is not a subclass of BasePlugin TypeError: If plugin_class is not a subclass of BasePlugin
""" """
if not issubclass(plugin_class, BasePlugin): if not issubclass(plugin_class, BasePlugin):
raise TypeError(f"Plugin class must inherit from BasePlugin") raise TypeError("Plugin class must inherit from BasePlugin")
if plugin_name in self.plugins: if plugin_name in self.plugins:
raise ValueError(f"Plugin '{plugin_name}' is already registered") raise ValueError(f"Plugin '{plugin_name}' is already registered")
self.plugins[plugin_name] = plugin_class self.plugins[plugin_name] = plugin_class
self.plugin_metadata[plugin_name] = metadata or {} self.plugin_metadata[plugin_name] = metadata or {}
logger.debug(f"Registered plugin '{plugin_name}' with class {plugin_class.__name__}") logger.debug(f"Registered plugin '{plugin_name}' with class {plugin_class.__name__}")
def unregister(self, plugin_name: str) -> bool: def unregister(self, plugin_name: str) -> bool:
""" """
Unregister a plugin. Unregister a plugin.
Args: Args:
plugin_name: Name of the plugin to unregister plugin_name: Name of the plugin to unregister
Returns: Returns:
True if plugin was unregistered, False if not found True if plugin was unregistered, False if not found
""" """
if plugin_name not in self.plugins: if plugin_name not in self.plugins:
return False return False
del self.plugins[plugin_name] del self.plugins[plugin_name]
del self.plugin_metadata[plugin_name] del self.plugin_metadata[plugin_name]
logger.debug(f"Unregistered plugin '{plugin_name}'") logger.debug(f"Unregistered plugin '{plugin_name}'")
return True return True
def get_plugin_class(self, plugin_name: str) -> Optional[Type[BasePlugin]]: def get_plugin_class(self, plugin_name: str) -> Optional[Type[BasePlugin]]:
""" """
Get a registered plugin class. Get a registered plugin class.
Args: Args:
plugin_name: Name of the plugin plugin_name: Name of the plugin
Returns: Returns:
Plugin class if found, None otherwise Plugin class if found, None otherwise
""" """
return self.plugins.get(plugin_name) return self.plugins.get(plugin_name)
def get_plugins(self) -> Dict[str, Type[BasePlugin]]: def get_plugins(self) -> Dict[str, Type[BasePlugin]]:
""" """
Get all registered plugins. Get all registered plugins.
Returns: Returns:
Dictionary of registered plugin names and classes Dictionary of registered plugin names and classes
""" """
return self.plugins.copy() return self.plugins.copy()
def get_plugin_names(self) -> list: def get_plugin_names(self) -> list:
""" """
Get list of registered plugin names. Get list of registered plugin names.
Returns: Returns:
List of registered plugin names List of registered plugin names
""" """
return list(self.plugins.keys()) return list(self.plugins.keys())
def create(self, plugin_name: str, config: Any, hook_manager: Any) -> Optional[BasePlugin]: def create(self, plugin_name: str, config: Any, hook_manager: Any) -> Optional[BasePlugin]:
""" """
Create a plugin instance. Create a plugin instance.
Args: Args:
plugin_name: Name of the plugin to create plugin_name: Name of the plugin to create
config: Configuration object config: Configuration object
hook_manager: Hook manager instance hook_manager: Hook manager instance
Returns: Returns:
Plugin instance if successful, None if plugin not found Plugin instance if successful, None if plugin not found
""" """
@ -119,7 +124,7 @@ class PluginRegistry:
if not plugin_class: if not plugin_class:
logger.warning(f"Plugin '{plugin_name}' not found") logger.warning(f"Plugin '{plugin_name}' not found")
return None return None
try: try:
plugin_instance = plugin_class(config, hook_manager) plugin_instance = plugin_class(config, hook_manager)
logger.debug(f"Created plugin instance '{plugin_name}'") logger.debug(f"Created plugin instance '{plugin_name}'")
@ -127,82 +132,82 @@ class PluginRegistry:
except Exception as e: except Exception as e:
logger.error(f"Failed to create plugin '{plugin_name}': {e}") logger.error(f"Failed to create plugin '{plugin_name}': {e}")
return None return None
def create_all_enabled(self, config: Any, hook_manager: Any) -> Dict[str, BasePlugin]: def create_all_enabled(self, config: Any, hook_manager: Any) -> Dict[str, BasePlugin]:
""" """
Create instances of all enabled plugins. Create instances of all enabled plugins.
Args: Args:
config: Configuration object config: Configuration object
hook_manager: Hook manager instance hook_manager: Hook manager instance
Returns: Returns:
Dictionary of plugin names and instances Dictionary of plugin names and instances
""" """
enabled_plugins = {} enabled_plugins = {}
for plugin_name in self.get_plugin_names(): for plugin_name in self.get_plugin_names():
plugin_instance = self.create(plugin_name, config, hook_manager) plugin_instance = self.create(plugin_name, config, hook_manager)
if plugin_instance and plugin_instance.enabled: if plugin_instance and plugin_instance.enabled:
enabled_plugins[plugin_name] = plugin_instance enabled_plugins[plugin_name] = plugin_instance
logger.debug(f"Created {len(enabled_plugins)} enabled plugin instances") logger.debug(f"Created {len(enabled_plugins)} enabled plugin instances")
return enabled_plugins return enabled_plugins
def get_plugin_info(self, plugin_name: str) -> Dict[str, Any]: def get_plugin_info(self, plugin_name: str) -> Dict[str, Any]:
""" """
Get information about a registered plugin. Get information about a registered plugin.
Args: Args:
plugin_name: Name of the plugin plugin_name: Name of the plugin
Returns: Returns:
Dictionary with plugin information Dictionary with plugin information
""" """
if plugin_name not in self.plugins: if plugin_name not in self.plugins:
return {'error': f'Plugin "{plugin_name}" not found'} return {"error": f'Plugin "{plugin_name}" not found'}
plugin_class = self.plugins[plugin_name] plugin_class = self.plugins[plugin_name]
metadata = self.plugin_metadata[plugin_name] metadata = self.plugin_metadata[plugin_name]
info = { info = {
'name': plugin_name, "name": plugin_name,
'class': plugin_class.__name__, "class": plugin_class.__name__,
'module': plugin_class.__module__, "module": plugin_class.__module__,
'metadata': metadata, "metadata": metadata,
'docstring': plugin_class.__doc__ or 'No documentation available' "docstring": plugin_class.__doc__ or "No documentation available",
} }
return info return info
def get_all_plugin_info(self) -> Dict[str, Dict[str, Any]]: def get_all_plugin_info(self) -> Dict[str, Dict[str, Any]]:
""" """
Get information about all registered plugins. Get information about all registered plugins.
Returns: Returns:
Dictionary mapping plugin names to their information Dictionary mapping plugin names to their information
""" """
return {name: self.get_plugin_info(name) for name in self.get_plugin_names()} return {name: self.get_plugin_info(name) for name in self.get_plugin_names()}
def load_plugin_from_module(self, module_name: str, plugin_name: str) -> bool: def load_plugin_from_module(self, module_name: str, plugin_name: str) -> bool:
""" """
Load a plugin from a module. Load a plugin from a module.
Args: Args:
module_name: Name of the module to load module_name: Name of the module to load
plugin_name: Name of the plugin class in the module plugin_name: Name of the plugin class in the module
Returns: Returns:
True if plugin was loaded successfully, False otherwise True if plugin was loaded successfully, False otherwise
""" """
try: try:
module = importlib.import_module(module_name) module = importlib.import_module(module_name)
plugin_class = getattr(module, plugin_name) plugin_class = getattr(module, plugin_name)
# Use module name as plugin name if not specified # Use module name as plugin name if not specified
self.register(plugin_name, plugin_class) self.register(plugin_name, plugin_class)
return True return True
except ImportError as e: except ImportError as e:
logger.error(f"Failed to import module '{module_name}': {e}") logger.error(f"Failed to import module '{module_name}': {e}")
return False return False
@ -212,42 +217,42 @@ class PluginRegistry:
except Exception as e: except Exception as e:
logger.error(f"Failed to load plugin from '{module_name}.{plugin_name}': {e}") logger.error(f"Failed to load plugin from '{module_name}.{plugin_name}': {e}")
return False return False
def load_plugins_from_config(self, config: Any) -> Dict[str, BasePlugin]: def load_plugins_from_config(self, config: Any) -> Dict[str, BasePlugin]:
""" """
Load plugins based on configuration. Load plugins based on configuration.
Args: Args:
config: Configuration object with plugin settings config: Configuration object with plugin settings
Returns: Returns:
Dictionary of loaded plugin instances Dictionary of loaded plugin instances
""" """
loaded_plugins = {} loaded_plugins = {}
if not hasattr(config, 'plugins') or not config.plugins: if not hasattr(config, "plugins") or not config.plugins:
return loaded_plugins return loaded_plugins
for plugin_name, plugin_config in config.plugins.items(): for plugin_name, plugin_config in config.plugins.items():
if not isinstance(plugin_config, dict): if not isinstance(plugin_config, dict):
continue continue
if plugin_config.get('enabled', False): if plugin_config.get("enabled", False):
# Try to load from built-in plugins first # Try to load from built-in plugins first
plugin_instance = self.create(plugin_name, config, None) plugin_instance = self.create(plugin_name, config, None)
if plugin_instance: if plugin_instance:
loaded_plugins[plugin_name] = plugin_instance loaded_plugins[plugin_name] = plugin_instance
else: else:
# Try to load from external module # Try to load from external module
module_name = plugin_config.get('module') module_name = plugin_config.get("module")
if module_name: if module_name:
if self.load_plugin_from_module(module_name, plugin_name): if self.load_plugin_from_module(module_name, plugin_name):
plugin_instance = self.create(plugin_name, config, None) plugin_instance = self.create(plugin_name, config, None)
if plugin_instance: if plugin_instance:
loaded_plugins[plugin_name] = plugin_instance loaded_plugins[plugin_name] = plugin_instance
return loaded_plugins return loaded_plugins
def _register_builtin_plugins(self) -> None: def _register_builtin_plugins(self) -> None:
"""Register built-in plugins.""" """Register built-in plugins."""
try: try:
@ -256,79 +261,101 @@ class PluginRegistry:
from .compress_logs import CompressLogsPlugin from .compress_logs import CompressLogsPlugin
from .root_cache import RootCachePlugin from .root_cache import RootCachePlugin
from .tmpfs import TmpfsPlugin from .tmpfs import TmpfsPlugin
self.register('bind_mount', BindMountPlugin, { self.register(
'description': 'Mount host directories into chroot', "bind_mount",
'hooks': ['mount_root', 'postumount'], BindMountPlugin,
'builtin': True {
}) "description": "Mount host directories into chroot",
"hooks": ["mount_root", "postumount"],
self.register('compress_logs', CompressLogsPlugin, { "builtin": True,
'description': 'Compress build logs to save space', },
'hooks': ['process_logs'], )
'builtin': True
}) self.register(
"compress_logs",
self.register('root_cache', RootCachePlugin, { CompressLogsPlugin,
'description': 'Root cache management for faster builds', {
'hooks': ['preinit', 'postinit', 'postchroot', 'postshell', 'clean'], "description": "Compress build logs to save space",
'builtin': True "hooks": ["process_logs"],
}) "builtin": True,
},
self.register('tmpfs', TmpfsPlugin, { )
'description': 'Use tmpfs for faster I/O operations',
'hooks': ['mount_root', 'postumount'], self.register(
'builtin': True "root_cache",
}) RootCachePlugin,
{
"description": "Root cache management for faster builds",
"hooks": [
"preinit",
"postinit",
"postchroot",
"postshell",
"clean",
],
"builtin": True,
},
)
self.register(
"tmpfs",
TmpfsPlugin,
{
"description": "Use tmpfs for faster I/O operations",
"hooks": ["mount_root", "postumount"],
"builtin": True,
},
)
logger.debug("Registered built-in plugins") logger.debug("Registered built-in plugins")
except ImportError as e: except ImportError as e:
logger.warning(f"Some built-in plugins could not be loaded: {e}") logger.warning(f"Some built-in plugins could not be loaded: {e}")
except Exception as e: except Exception as e:
logger.warning(f"Error registering built-in plugins: {e}") logger.warning(f"Error registering built-in plugins: {e}")
def get_plugin_statistics(self) -> Dict[str, Any]: def get_plugin_statistics(self) -> Dict[str, Any]:
""" """
Get statistics about registered plugins. Get statistics about registered plugins.
Returns: Returns:
Dictionary with plugin statistics Dictionary with plugin statistics
""" """
stats = { stats = {
'total_plugins': len(self.plugins), "total_plugins": len(self.plugins),
'builtin_plugins': len([p for p in self.plugin_metadata.values() if p.get('builtin', False)]), "builtin_plugins": len([p for p in self.plugin_metadata.values() if p.get("builtin", False)]),
'external_plugins': len([p for p in self.plugin_metadata.values() if not p.get('builtin', False)]), "external_plugins": len([p for p in self.plugin_metadata.values() if not p.get("builtin", False)]),
'plugins_by_hook': {} "plugins_by_hook": {},
} }
# Count plugins by hook usage # Count plugins by hook usage
for plugin_name, metadata in self.plugin_metadata.items(): for plugin_name, metadata in self.plugin_metadata.items():
hooks = metadata.get('hooks', []) hooks = metadata.get("hooks", [])
for hook in hooks: for hook in hooks:
if hook not in stats['plugins_by_hook']: if hook not in stats["plugins_by_hook"]:
stats['plugins_by_hook'][hook] = [] stats["plugins_by_hook"][hook] = []
stats['plugins_by_hook'][hook].append(plugin_name) stats["plugins_by_hook"][hook].append(plugin_name)
return stats return stats
def validate_plugin_config(self, plugin_name: str, config: Any) -> bool: def validate_plugin_config(self, plugin_name: str, config: Any) -> bool:
""" """
Validate plugin configuration. Validate plugin configuration.
Args: Args:
plugin_name: Name of the plugin plugin_name: Name of the plugin
config: Configuration to validate config: Configuration to validate
Returns: Returns:
True if configuration is valid, False otherwise True if configuration is valid, False otherwise
""" """
if plugin_name not in self.plugins: if plugin_name not in self.plugins:
return False return False
# Basic validation - plugins can override this method # Basic validation - plugins can override this method
plugin_class = self.plugins[plugin_name] plugin_class = self.plugins[plugin_name]
if hasattr(plugin_class, 'validate_config'): if hasattr(plugin_class, "validate_config"):
return plugin_class.validate_config(config) return plugin_class.validate_config(config)
return True return True

331
deb_mock/plugins/root_cache.py
View file

@ -5,14 +5,11 @@ This plugin provides root cache management for faster builds,
inspired by Fedora's Mock root_cache plugin but adapted for Debian-based systems. inspired by Fedora's Mock root_cache plugin but adapted for Debian-based systems.
""" """
import logging
import os import os
import tarfile import tarfile
import hashlib
import json
import time import time
import logging from typing import Any, Dict
from pathlib import Path
from typing import Dict, Any, Optional
from .base import BasePlugin from .base import BasePlugin
@ -22,19 +19,19 @@ logger = logging.getLogger(__name__)
class RootCachePlugin(BasePlugin): class RootCachePlugin(BasePlugin):
""" """
Root cache management for faster builds. Root cache management for faster builds.
This plugin caches the chroot environment in a compressed tarball, This plugin caches the chroot environment in a compressed tarball,
which can significantly speed up subsequent builds by avoiding which can significantly speed up subsequent builds by avoiding
the need to recreate the entire chroot from scratch. the need to recreate the entire chroot from scratch.
""" """
def __init__(self, config, hook_manager): def __init__(self, config, hook_manager):
"""Initialize the RootCache plugin.""" """Initialize the RootCache plugin."""
super().__init__(config, hook_manager) super().__init__(config, hook_manager)
self.cache_settings = self._get_cache_settings() self.cache_settings = self._get_cache_settings()
self.cache_file = self._get_cache_file_path() self.cache_file = self._get_cache_file_path()
self._log_info(f"Initialized with cache dir: {self.cache_settings['cache_dir']}") self._log_info(f"Initialized with cache dir: {self.cache_settings['cache_dir']}")
def _register_hooks(self): def _register_hooks(self):
"""Register root cache hooks.""" """Register root cache hooks."""
self.hook_manager.add_hook("preinit", self.preinit) self.hook_manager.add_hook("preinit", self.preinit)
@ -43,307 +40,307 @@ class RootCachePlugin(BasePlugin):
self.hook_manager.add_hook("postshell", self.postshell) self.hook_manager.add_hook("postshell", self.postshell)
self.hook_manager.add_hook("clean", self.clean) self.hook_manager.add_hook("clean", self.clean)
self._log_debug("Registered root cache hooks") self._log_debug("Registered root cache hooks")
def _get_cache_settings(self) -> Dict[str, Any]: def _get_cache_settings(self) -> Dict[str, Any]:
""" """
Get cache settings from configuration. Get cache settings from configuration.
Returns: Returns:
Dictionary with cache settings Dictionary with cache settings
""" """
plugin_config = self._get_plugin_config() plugin_config = self._get_plugin_config()
return { return {
'cache_dir': plugin_config.get('cache_dir', '/var/cache/deb-mock/root-cache'), "cache_dir": plugin_config.get("cache_dir", "/var/cache/deb-mock/root-cache"),
'max_age_days': plugin_config.get('max_age_days', 7), "max_age_days": plugin_config.get("max_age_days", 7),
'compression': plugin_config.get('compression', 'gzip'), "compression": plugin_config.get("compression", "gzip"),
'exclude_dirs': plugin_config.get('exclude_dirs', ['/tmp', '/var/tmp', '/var/cache']), "exclude_dirs": plugin_config.get("exclude_dirs", ["/tmp", "/var/tmp", "/var/cache"]),
'exclude_patterns': plugin_config.get('exclude_patterns', ['*.log', '*.tmp']), "exclude_patterns": plugin_config.get("exclude_patterns", ["*.log", "*.tmp"]),
'min_cache_size_mb': plugin_config.get('min_cache_size_mb', 100), "min_cache_size_mb": plugin_config.get("min_cache_size_mb", 100),
'auto_cleanup': plugin_config.get('auto_cleanup', True) "auto_cleanup": plugin_config.get("auto_cleanup", True),
} }
def _get_cache_file_path(self) -> str: def _get_cache_file_path(self) -> str:
""" """
Get the cache file path based on configuration. Get the cache file path based on configuration.
Returns: Returns:
Path to the cache file Path to the cache file
""" """
cache_dir = self.cache_settings['cache_dir'] cache_dir = self.cache_settings["cache_dir"]
compression = self.cache_settings['compression'] compression = self.cache_settings["compression"]
# Create cache directory if it doesn't exist # Create cache directory if it doesn't exist
os.makedirs(cache_dir, exist_ok=True) os.makedirs(cache_dir, exist_ok=True)
# Determine file extension based on compression # Determine file extension based on compression
extensions = { extensions = {
'gzip': '.tar.gz', "gzip": ".tar.gz",
'bzip2': '.tar.bz2', "bzip2": ".tar.bz2",
'xz': '.tar.xz', "xz": ".tar.xz",
'zstd': '.tar.zst' "zstd": ".tar.zst",
} }
ext = extensions.get(compression, '.tar.gz') ext = extensions.get(compression, ".tar.gz")
return os.path.join(cache_dir, f"cache{ext}") return os.path.join(cache_dir, f"cache{ext}")
def preinit(self, context: Dict[str, Any]) -> None: def preinit(self, context: Dict[str, Any]) -> None:
""" """
Restore chroot from cache before initialization. Restore chroot from cache before initialization.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled: if not self.enabled:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
self._log_warning("No chroot_path in context, skipping cache restoration") self._log_warning("No chroot_path in context, skipping cache restoration")
return return
if not self._cache_exists(): if not self._cache_exists():
self._log_debug("No cache file found, will create new chroot") self._log_debug("No cache file found, will create new chroot")
return return
if not self._is_cache_valid(): if not self._is_cache_valid():
self._log_debug("Cache is invalid or expired, will create new chroot") self._log_debug("Cache is invalid or expired, will create new chroot")
return return
self._log_info("Restoring chroot from cache") self._log_info("Restoring chroot from cache")
try: try:
self._restore_from_cache(chroot_path) self._restore_from_cache(chroot_path)
self._log_info("Successfully restored chroot from cache") self._log_info("Successfully restored chroot from cache")
except Exception as e: except Exception as e:
self._log_error(f"Failed to restore from cache: {e}") self._log_error(f"Failed to restore from cache: {e}")
def postinit(self, context: Dict[str, Any]) -> None: def postinit(self, context: Dict[str, Any]) -> None:
""" """
Create cache after successful initialization. Create cache after successful initialization.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled: if not self.enabled:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
self._log_warning("No chroot_path in context, skipping cache creation") self._log_warning("No chroot_path in context, skipping cache creation")
return return
self._log_info("Creating root cache") self._log_info("Creating root cache")
try: try:
self._create_cache(chroot_path) self._create_cache(chroot_path)
self._log_info("Successfully created root cache") self._log_info("Successfully created root cache")
except Exception as e: except Exception as e:
self._log_error(f"Failed to create cache: {e}") self._log_error(f"Failed to create cache: {e}")
def postchroot(self, context: Dict[str, Any]) -> None: def postchroot(self, context: Dict[str, Any]) -> None:
""" """
Update cache after chroot operations. Update cache after chroot operations.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled: if not self.enabled:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
return return
self._log_debug("Updating cache after chroot operations") self._log_debug("Updating cache after chroot operations")
try: try:
self._update_cache(chroot_path) self._update_cache(chroot_path)
except Exception as e: except Exception as e:
self._log_error(f"Failed to update cache: {e}") self._log_error(f"Failed to update cache: {e}")
def postshell(self, context: Dict[str, Any]) -> None: def postshell(self, context: Dict[str, Any]) -> None:
""" """
Update cache after shell operations. Update cache after shell operations.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled: if not self.enabled:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
return return
self._log_debug("Updating cache after shell operations") self._log_debug("Updating cache after shell operations")
try: try:
self._update_cache(chroot_path) self._update_cache(chroot_path)
except Exception as e: except Exception as e:
self._log_error(f"Failed to update cache: {e}") self._log_error(f"Failed to update cache: {e}")
def clean(self, context: Dict[str, Any]) -> None: def clean(self, context: Dict[str, Any]) -> None:
""" """
Clean up cache resources. Clean up cache resources.
Args: Args:
context: Context dictionary with cleanup information context: Context dictionary with cleanup information
""" """
if not self.enabled: if not self.enabled:
return return
if self.cache_settings['auto_cleanup']: if self.cache_settings["auto_cleanup"]:
self._log_info("Cleaning up old caches") self._log_info("Cleaning up old caches")
try: try:
cleaned_count = self._cleanup_old_caches() cleaned_count = self._cleanup_old_caches()
self._log_info(f"Cleaned up {cleaned_count} old cache files") self._log_info(f"Cleaned up {cleaned_count} old cache files")
except Exception as e: except Exception as e:
self._log_error(f"Failed to cleanup old caches: {e}") self._log_error(f"Failed to cleanup old caches: {e}")
def _cache_exists(self) -> bool: def _cache_exists(self) -> bool:
""" """
Check if cache file exists. Check if cache file exists.
Returns: Returns:
True if cache file exists, False otherwise True if cache file exists, False otherwise
""" """
return os.path.exists(self.cache_file) return os.path.exists(self.cache_file)
def _is_cache_valid(self) -> bool: def _is_cache_valid(self) -> bool:
""" """
Check if cache is valid and not expired. Check if cache is valid and not expired.
Returns: Returns:
True if cache is valid, False otherwise True if cache is valid, False otherwise
""" """
if not self._cache_exists(): if not self._cache_exists():
return False return False
# Check file age # Check file age
file_age = time.time() - os.path.getmtime(self.cache_file) file_age = time.time() - os.path.getmtime(self.cache_file)
max_age_seconds = self.cache_settings['max_age_days'] * 24 * 3600 max_age_seconds = self.cache_settings["max_age_days"] * 24 * 3600
if file_age > max_age_seconds: if file_age > max_age_seconds:
self._log_debug(f"Cache is {file_age/3600:.1f} hours old, max age is {max_age_seconds/3600:.1f} hours") self._log_debug(f"Cache is {file_age / 3600:.1f} hours old, max age is {max_age_seconds / 3600:.1f} hours")
return False return False
# Check file size # Check file size
file_size_mb = os.path.getsize(self.cache_file) / (1024 * 1024) file_size_mb = os.path.getsize(self.cache_file) / (1024 * 1024)
min_size_mb = self.cache_settings['min_cache_size_mb'] min_size_mb = self.cache_settings["min_cache_size_mb"]
if file_size_mb < min_size_mb: if file_size_mb < min_size_mb:
self._log_debug(f"Cache size {file_size_mb:.1f}MB is below minimum {min_size_mb}MB") self._log_debug(f"Cache size {file_size_mb:.1f}MB is below minimum {min_size_mb}MB")
return False return False
return True return True
def _restore_from_cache(self, chroot_path: str) -> None: def _restore_from_cache(self, chroot_path: str) -> None:
""" """
Restore chroot from cache. Restore chroot from cache.
Args: Args:
chroot_path: Path to restore chroot to chroot_path: Path to restore chroot to
""" """
if not self._cache_exists(): if not self._cache_exists():
raise FileNotFoundError("Cache file does not exist") raise FileNotFoundError("Cache file does not exist")
# Create chroot directory if it doesn't exist # Create chroot directory if it doesn't exist
os.makedirs(chroot_path, exist_ok=True) os.makedirs(chroot_path, exist_ok=True)
# Extract cache # Extract cache
compression = self.cache_settings['compression'] compression = self.cache_settings["compression"]
if compression == 'gzip': if compression == "gzip":
mode = 'r:gz' mode = "r:gz"
elif compression == 'bzip2': elif compression == "bzip2":
mode = 'r:bz2' mode = "r:bz2"
elif compression == 'xz': elif compression == "xz":
mode = 'r:xz' mode = "r:xz"
elif compression == 'zstd': elif compression == "zstd":
mode = 'r:zstd' mode = "r:zstd"
else: else:
mode = 'r:gz' # Default to gzip mode = "r:gz" # Default to gzip
try: try:
with tarfile.open(self.cache_file, mode) as tar: with tarfile.open(self.cache_file, mode) as tar:
tar.extractall(path=chroot_path) tar.extractall(path=chroot_path)
self._log_debug(f"Successfully extracted cache to {chroot_path}") self._log_debug(f"Successfully extracted cache to {chroot_path}")
except Exception as e: except Exception as e:
self._log_error(f"Failed to extract cache: {e}") self._log_error(f"Failed to extract cache: {e}")
raise raise
def _create_cache(self, chroot_path: str) -> None: def _create_cache(self, chroot_path: str) -> None:
""" """
Create cache from chroot. Create cache from chroot.
Args: Args:
chroot_path: Path to the chroot to cache chroot_path: Path to the chroot to cache
""" """
if not os.path.exists(chroot_path): if not os.path.exists(chroot_path):
raise FileNotFoundError(f"Chroot path does not exist: {chroot_path}") raise FileNotFoundError(f"Chroot path does not exist: {chroot_path}")
# Determine compression mode # Determine compression mode
compression = self.cache_settings['compression'] compression = self.cache_settings["compression"]
if compression == 'gzip': if compression == "gzip":
mode = 'w:gz' mode = "w:gz"
elif compression == 'bzip2': elif compression == "bzip2":
mode = 'w:bz2' mode = "w:bz2"
elif compression == 'xz': elif compression == "xz":
mode = 'w:xz' mode = "w:xz"
elif compression == 'zstd': elif compression == "zstd":
mode = 'w:zstd' mode = "w:zstd"
else: else:
mode = 'w:gz' # Default to gzip mode = "w:gz" # Default to gzip
try: try:
with tarfile.open(self.cache_file, mode) as tar: with tarfile.open(self.cache_file, mode) as tar:
# Add chroot contents to archive # Add chroot contents to archive
tar.add(chroot_path, arcname='', exclude=self._get_exclude_filter()) tar.add(chroot_path, arcname="", exclude=self._get_exclude_filter())
self._log_debug(f"Successfully created cache: {self.cache_file}") self._log_debug(f"Successfully created cache: {self.cache_file}")
except Exception as e: except Exception as e:
self._log_error(f"Failed to create cache: {e}") self._log_error(f"Failed to create cache: {e}")
raise raise
def _update_cache(self, chroot_path: str) -> None: def _update_cache(self, chroot_path: str) -> None:
""" """
Update existing cache. Update existing cache.
Args: Args:
chroot_path: Path to the chroot to update cache from chroot_path: Path to the chroot to update cache from
""" """
# For now, just recreate the cache # For now, just recreate the cache
# In the future, we could implement incremental updates # In the future, we could implement incremental updates
self._create_cache(chroot_path) self._create_cache(chroot_path)
def _cleanup_old_caches(self) -> int: def _cleanup_old_caches(self) -> int:
""" """
Clean up old cache files. Clean up old cache files.
Returns: Returns:
Number of cache files cleaned up Number of cache files cleaned up
""" """
cache_dir = self.cache_settings['cache_dir'] cache_dir = self.cache_settings["cache_dir"]
max_age_seconds = self.cache_settings['max_age_days'] * 24 * 3600 max_age_seconds = self.cache_settings["max_age_days"] * 24 * 3600
current_time = time.time() current_time = time.time()
cleaned_count = 0 cleaned_count = 0
if not os.path.exists(cache_dir): if not os.path.exists(cache_dir):
return 0 return 0
for cache_file in os.listdir(cache_dir): for cache_file in os.listdir(cache_dir):
if not cache_file.startswith('cache'): if not cache_file.startswith("cache"):
continue continue
cache_path = os.path.join(cache_dir, cache_file) cache_path = os.path.join(cache_dir, cache_file)
file_age = current_time - os.path.getmtime(cache_path) file_age = current_time - os.path.getmtime(cache_path)
if file_age > max_age_seconds: if file_age > max_age_seconds:
try: try:
os.remove(cache_path) os.remove(cache_path)
@ -351,110 +348,112 @@ class RootCachePlugin(BasePlugin):
self._log_debug(f"Removed old cache: {cache_file}") self._log_debug(f"Removed old cache: {cache_file}")
except Exception as e: except Exception as e:
self._log_warning(f"Failed to remove old cache {cache_file}: {e}") self._log_warning(f"Failed to remove old cache {cache_file}: {e}")
return cleaned_count return cleaned_count
def _get_exclude_filter(self): def _get_exclude_filter(self):
""" """
Get exclude filter function for tarfile. Get exclude filter function for tarfile.
Returns: Returns:
Function to filter out excluded files/directories Function to filter out excluded files/directories
""" """
exclude_dirs = self.cache_settings['exclude_dirs'] exclude_dirs = self.cache_settings["exclude_dirs"]
exclude_patterns = self.cache_settings['exclude_patterns'] exclude_patterns = self.cache_settings["exclude_patterns"]
def exclude_filter(tarinfo): def exclude_filter(tarinfo):
# Check excluded directories # Check excluded directories
for exclude_dir in exclude_dirs: for exclude_dir in exclude_dirs:
if tarinfo.name.startswith(exclude_dir.lstrip('/')): if tarinfo.name.startswith(exclude_dir.lstrip("/")):
return None return None
# Check excluded patterns # Check excluded patterns
for pattern in exclude_patterns: for pattern in exclude_patterns:
if pattern in tarinfo.name: if pattern in tarinfo.name:
return None return None
return tarinfo return tarinfo
return exclude_filter return exclude_filter
def validate_config(self, config: Any) -> bool: def validate_config(self, config: Any) -> bool:
""" """
Validate plugin configuration. Validate plugin configuration.
Args: Args:
config: Configuration to validate config: Configuration to validate
Returns: Returns:
True if configuration is valid, False otherwise True if configuration is valid, False otherwise
""" """
plugin_config = getattr(config, 'plugins', {}).get('root_cache', {}) plugin_config = getattr(config, "plugins", {}).get("root_cache", {})
# Validate cache_dir # Validate cache_dir
cache_dir = plugin_config.get('cache_dir', '/var/cache/deb-mock/root-cache') cache_dir = plugin_config.get("cache_dir", "/var/cache/deb-mock/root-cache")
if not cache_dir: if not cache_dir:
self._log_error("cache_dir cannot be empty") self._log_error("cache_dir cannot be empty")
return False return False
# Validate max_age_days # Validate max_age_days
max_age_days = plugin_config.get('max_age_days', 7) max_age_days = plugin_config.get("max_age_days", 7)
if not isinstance(max_age_days, int) or max_age_days <= 0: if not isinstance(max_age_days, int) or max_age_days <= 0:
self._log_error(f"Invalid max_age_days: {max_age_days}. Must be positive integer") self._log_error(f"Invalid max_age_days: {max_age_days}. Must be positive integer")
return False return False
# Validate compression # Validate compression
valid_compressions = ['gzip', 'bzip2', 'xz', 'zstd'] valid_compressions = ["gzip", "bzip2", "xz", "zstd"]
compression = plugin_config.get('compression', 'gzip') compression = plugin_config.get("compression", "gzip")
if compression not in valid_compressions: if compression not in valid_compressions:
self._log_error(f"Invalid compression: {compression}. Valid options: {valid_compressions}") self._log_error(f"Invalid compression: {compression}. Valid options: {valid_compressions}")
return False return False
# Validate exclude_dirs # Validate exclude_dirs
exclude_dirs = plugin_config.get('exclude_dirs', ['/tmp', '/var/tmp', '/var/cache']) exclude_dirs = plugin_config.get("exclude_dirs", ["/tmp", "/var/tmp", "/var/cache"])
if not isinstance(exclude_dirs, list): if not isinstance(exclude_dirs, list):
self._log_error("exclude_dirs must be a list") self._log_error("exclude_dirs must be a list")
return False return False
# Validate exclude_patterns # Validate exclude_patterns
exclude_patterns = plugin_config.get('exclude_patterns', ['*.log', '*.tmp']) exclude_patterns = plugin_config.get("exclude_patterns", ["*.log", "*.tmp"])
if not isinstance(exclude_patterns, list): if not isinstance(exclude_patterns, list):
self._log_error("exclude_patterns must be a list") self._log_error("exclude_patterns must be a list")
return False return False
# Validate min_cache_size_mb # Validate min_cache_size_mb
min_cache_size_mb = plugin_config.get('min_cache_size_mb', 100) min_cache_size_mb = plugin_config.get("min_cache_size_mb", 100)
if not isinstance(min_cache_size_mb, (int, float)) or min_cache_size_mb < 0: if not isinstance(min_cache_size_mb, (int, float)) or min_cache_size_mb < 0:
self._log_error(f"Invalid min_cache_size_mb: {min_cache_size_mb}. Must be non-negative number") self._log_error(f"Invalid min_cache_size_mb: {min_cache_size_mb}. Must be non-negative number")
return False return False
# Validate auto_cleanup # Validate auto_cleanup
auto_cleanup = plugin_config.get('auto_cleanup', True) auto_cleanup = plugin_config.get("auto_cleanup", True)
if not isinstance(auto_cleanup, bool): if not isinstance(auto_cleanup, bool):
self._log_error(f"Invalid auto_cleanup: {auto_cleanup}. Must be boolean") self._log_error(f"Invalid auto_cleanup: {auto_cleanup}. Must be boolean")
return False return False
return True return True
def get_plugin_info(self) -> Dict[str, Any]: def get_plugin_info(self) -> Dict[str, Any]:
""" """
Get plugin information. Get plugin information.
Returns: Returns:
Dictionary with plugin information Dictionary with plugin information
""" """
info = super().get_plugin_info() info = super().get_plugin_info()
info.update({ info.update(
'cache_dir': self.cache_settings['cache_dir'], {
'cache_file': self.cache_file, "cache_dir": self.cache_settings["cache_dir"],
'max_age_days': self.cache_settings['max_age_days'], "cache_file": self.cache_file,
'compression': self.cache_settings['compression'], "max_age_days": self.cache_settings["max_age_days"],
'exclude_dirs': self.cache_settings['exclude_dirs'], "compression": self.cache_settings["compression"],
'exclude_patterns': self.cache_settings['exclude_patterns'], "exclude_dirs": self.cache_settings["exclude_dirs"],
'min_cache_size_mb': self.cache_settings['min_cache_size_mb'], "exclude_patterns": self.cache_settings["exclude_patterns"],
'auto_cleanup': self.cache_settings['auto_cleanup'], "min_cache_size_mb": self.cache_settings["min_cache_size_mb"],
'cache_exists': self._cache_exists(), "auto_cleanup": self.cache_settings["auto_cleanup"],
'cache_valid': self._is_cache_valid() if self._cache_exists() else False, "cache_exists": self._cache_exists(),
'hooks': ['preinit', 'postinit', 'postchroot', 'postshell', 'clean'] "cache_valid": (self._is_cache_valid() if self._cache_exists() else False),
}) "hooks": ["preinit", "postinit", "postchroot", "postshell", "clean"],
return info }
)
return info

251
deb_mock/plugins/tmpfs.py
View file

@ -5,10 +5,9 @@ This plugin uses tmpfs for faster I/O operations in chroot,
inspired by Fedora's Mock tmpfs plugin but adapted for Debian-based systems. inspired by Fedora's Mock tmpfs plugin but adapted for Debian-based systems.
""" """
import os
import subprocess
import logging import logging
from typing import Dict, Any, Optional import subprocess
from typing import Any, Dict
from .base import BasePlugin from .base import BasePlugin
@ -18,71 +17,71 @@ logger = logging.getLogger(__name__)
class TmpfsPlugin(BasePlugin): class TmpfsPlugin(BasePlugin):
""" """
Use tmpfs for faster I/O operations in chroot. Use tmpfs for faster I/O operations in chroot.
This plugin mounts a tmpfs filesystem on the chroot directory, This plugin mounts a tmpfs filesystem on the chroot directory,
which can significantly improve build performance by using RAM which can significantly improve build performance by using RAM
instead of disk for temporary files and build artifacts. instead of disk for temporary files and build artifacts.
""" """
def __init__(self, config, hook_manager): def __init__(self, config, hook_manager):
"""Initialize the Tmpfs plugin.""" """Initialize the Tmpfs plugin."""
super().__init__(config, hook_manager) super().__init__(config, hook_manager)
self.tmpfs_settings = self._get_tmpfs_settings() self.tmpfs_settings = self._get_tmpfs_settings()
self.mounted = False self.mounted = False
self._log_info(f"Initialized with size: {self.tmpfs_settings['size']}") self._log_info(f"Initialized with size: {self.tmpfs_settings['size']}")
def _register_hooks(self): def _register_hooks(self):
"""Register tmpfs hooks.""" """Register tmpfs hooks."""
self.hook_manager.add_hook("mount_root", self.mount_root) self.hook_manager.add_hook("mount_root", self.mount_root)
self.hook_manager.add_hook("postumount", self.postumount) self.hook_manager.add_hook("postumount", self.postumount)
self._log_debug("Registered mount_root and postumount hooks") self._log_debug("Registered mount_root and postumount hooks")
def _get_tmpfs_settings(self) -> Dict[str, Any]: def _get_tmpfs_settings(self) -> Dict[str, Any]:
""" """
Get tmpfs settings from configuration. Get tmpfs settings from configuration.
Returns: Returns:
Dictionary with tmpfs settings Dictionary with tmpfs settings
""" """
plugin_config = self._get_plugin_config() plugin_config = self._get_plugin_config()
return { return {
'size': plugin_config.get('size', '2G'), "size": plugin_config.get("size", "2G"),
'mode': plugin_config.get('mode', '0755'), "mode": plugin_config.get("mode", "0755"),
'mount_point': plugin_config.get('mount_point', '/tmp'), "mount_point": plugin_config.get("mount_point", "/tmp"),
'keep_mounted': plugin_config.get('keep_mounted', False), "keep_mounted": plugin_config.get("keep_mounted", False),
'required_ram_mb': plugin_config.get('required_ram_mb', 2048), # 2GB default "required_ram_mb": plugin_config.get("required_ram_mb", 2048), # 2GB default
'max_fs_size': plugin_config.get('max_fs_size', None) "max_fs_size": plugin_config.get("max_fs_size", None),
} }
def mount_root(self, context: Dict[str, Any]) -> None: def mount_root(self, context: Dict[str, Any]) -> None:
""" """
Mount tmpfs when chroot is mounted. Mount tmpfs when chroot is mounted.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled: if not self.enabled:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
self._log_warning("No chroot_path in context, skipping tmpfs mount") self._log_warning("No chroot_path in context, skipping tmpfs mount")
return return
# Check if we have enough RAM # Check if we have enough RAM
if not self._check_ram_requirements(): if not self._check_ram_requirements():
self._log_warning("Insufficient RAM for tmpfs, skipping mount") self._log_warning("Insufficient RAM for tmpfs, skipping mount")
return return
# Check if already mounted # Check if already mounted
if self._is_mounted(chroot_path): if self._is_mounted(chroot_path):
self._log_info(f"Tmpfs already mounted at {chroot_path}") self._log_info(f"Tmpfs already mounted at {chroot_path}")
self.mounted = True self.mounted = True
return return
self._log_info(f"Mounting tmpfs at {chroot_path}") self._log_info(f"Mounting tmpfs at {chroot_path}")
try: try:
self._mount_tmpfs(chroot_path) self._mount_tmpfs(chroot_path)
self.mounted = True self.mounted = True
@ -90,288 +89,284 @@ class TmpfsPlugin(BasePlugin):
except Exception as e: except Exception as e:
self._log_error(f"Failed to mount tmpfs: {e}") self._log_error(f"Failed to mount tmpfs: {e}")
self.mounted = False self.mounted = False
def postumount(self, context: Dict[str, Any]) -> None: def postumount(self, context: Dict[str, Any]) -> None:
""" """
Unmount tmpfs when chroot is unmounted. Unmount tmpfs when chroot is unmounted.
Args: Args:
context: Context dictionary with chroot information context: Context dictionary with chroot information
""" """
if not self.enabled or not self.mounted: if not self.enabled or not self.mounted:
return return
chroot_path = context.get('chroot_path') chroot_path = context.get("chroot_path")
if not chroot_path: if not chroot_path:
self._log_warning("No chroot_path in context, skipping tmpfs unmount") self._log_warning("No chroot_path in context, skipping tmpfs unmount")
return return
# Check if we should keep mounted # Check if we should keep mounted
if self.tmpfs_settings['keep_mounted']: if self.tmpfs_settings["keep_mounted"]:
self._log_info("Keeping tmpfs mounted as requested") self._log_info("Keeping tmpfs mounted as requested")
return return
self._log_info(f"Unmounting tmpfs from {chroot_path}") self._log_info(f"Unmounting tmpfs from {chroot_path}")
try: try:
self._unmount_tmpfs(chroot_path) self._unmount_tmpfs(chroot_path)
self.mounted = False self.mounted = False
self._log_info("Tmpfs unmounted successfully") self._log_info("Tmpfs unmounted successfully")
except Exception as e: except Exception as e:
self._log_error(f"Failed to unmount tmpfs: {e}") self._log_error(f"Failed to unmount tmpfs: {e}")
def _check_ram_requirements(self) -> bool: def _check_ram_requirements(self) -> bool:
""" """
Check if system has enough RAM for tmpfs. Check if system has enough RAM for tmpfs.
Returns: Returns:
True if system has sufficient RAM, False otherwise True if system has sufficient RAM, False otherwise
""" """
try: try:
# Get system RAM in MB # Get system RAM in MB
with open('/proc/meminfo', 'r') as f: with open("/proc/meminfo", "r") as f:
for line in f: for line in f:
if line.startswith('MemTotal:'): if line.startswith("MemTotal:"):
mem_total_kb = int(line.split()[1]) mem_total_kb = int(line.split()[1])
mem_total_mb = mem_total_kb // 1024 mem_total_mb = mem_total_kb // 1024
break break
else: else:
self._log_warning("Could not determine system RAM") self._log_warning("Could not determine system RAM")
return False return False
required_ram = self.tmpfs_settings['required_ram_mb'] required_ram = self.tmpfs_settings["required_ram_mb"]
if mem_total_mb < required_ram: if mem_total_mb < required_ram:
self._log_warning( self._log_warning(f"System has {mem_total_mb}MB RAM, but {required_ram}MB is required for tmpfs")
f"System has {mem_total_mb}MB RAM, but {required_ram}MB is required for tmpfs"
)
return False return False
self._log_debug(f"System RAM: {mem_total_mb}MB, required: {required_ram}MB") self._log_debug(f"System RAM: {mem_total_mb}MB, required: {required_ram}MB")
return True return True
except Exception as e: except Exception as e:
self._log_error(f"Failed to check RAM requirements: {e}") self._log_error(f"Failed to check RAM requirements: {e}")
return False return False
def _is_mounted(self, chroot_path: str) -> bool: def _is_mounted(self, chroot_path: str) -> bool:
""" """
Check if tmpfs is already mounted at the given path. Check if tmpfs is already mounted at the given path.
Args: Args:
chroot_path: Path to check chroot_path: Path to check
Returns: Returns:
True if tmpfs is mounted, False otherwise True if tmpfs is mounted, False otherwise
""" """
try: try:
# Check if the path is a mount point # Check if the path is a mount point
result = subprocess.run( result = subprocess.run(["mountpoint", "-q", chroot_path], capture_output=True, text=True)
['mountpoint', '-q', chroot_path],
capture_output=True,
text=True
)
return result.returncode == 0 return result.returncode == 0
except FileNotFoundError: except FileNotFoundError:
# mountpoint command not available, try alternative method # mountpoint command not available, try alternative method
try: try:
with open('/proc/mounts', 'r') as f: with open("/proc/mounts", "r") as f:
for line in f: for line in f:
parts = line.split() parts = line.split()
if len(parts) >= 2 and parts[1] == chroot_path: if len(parts) >= 2 and parts[1] == chroot_path:
return parts[0] == 'tmpfs' return parts[0] == "tmpfs"
return False return False
except Exception: except Exception:
self._log_warning("Could not check mount status") self._log_warning("Could not check mount status")
return False return False
def _mount_tmpfs(self, chroot_path: str) -> None: def _mount_tmpfs(self, chroot_path: str) -> None:
""" """
Mount tmpfs at the specified path. Mount tmpfs at the specified path.
Args: Args:
chroot_path: Path where to mount tmpfs chroot_path: Path where to mount tmpfs
""" """
# Build mount options # Build mount options
options = [] options = []
# Add mode option # Add mode option
mode = self.tmpfs_settings['mode'] mode = self.tmpfs_settings["mode"]
options.append(f'mode={mode}') options.append(f"mode={mode}")
# Add size option # Add size option
size = self.tmpfs_settings['size'] size = self.tmpfs_settings["size"]
if size: if size:
options.append(f'size={size}') options.append(f"size={size}")
# Add max_fs_size if specified # Add max_fs_size if specified
max_fs_size = self.tmpfs_settings['max_fs_size'] max_fs_size = self.tmpfs_settings["max_fs_size"]
if max_fs_size: if max_fs_size:
options.append(f'size={max_fs_size}') options.append(f"size={max_fs_size}")
# Add noatime for better performance # Add noatime for better performance
options.append('noatime') options.append("noatime")
# Build mount command # Build mount command
mount_cmd = [ mount_cmd = [
'mount', '-n', '-t', 'tmpfs', "mount",
'-o', ','.join(options), "-n",
'deb_mock_tmpfs', chroot_path "-t",
"tmpfs",
"-o",
",".join(options),
"deb_mock_tmpfs",
chroot_path,
] ]
self._log_debug(f"Mount command: {' '.join(mount_cmd)}") self._log_debug(f"Mount command: {' '.join(mount_cmd)}")
try: try:
result = subprocess.run( subprocess.run(mount_cmd, capture_output=True, text=True, check=True)
mount_cmd,
capture_output=True,
text=True,
check=True
)
self._log_debug("Tmpfs mount command executed successfully") self._log_debug("Tmpfs mount command executed successfully")
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"Tmpfs mount failed: {e.stderr}") self._log_error(f"Tmpfs mount failed: {e.stderr}")
raise raise
except FileNotFoundError: except FileNotFoundError:
self._log_error("mount command not found - ensure mount is available") self._log_error("mount command not found - ensure mount is available")
raise raise
def _unmount_tmpfs(self, chroot_path: str) -> None: def _unmount_tmpfs(self, chroot_path: str) -> None:
""" """
Unmount tmpfs from the specified path. Unmount tmpfs from the specified path.
Args: Args:
chroot_path: Path where tmpfs is mounted chroot_path: Path where tmpfs is mounted
""" """
# Try normal unmount first # Try normal unmount first
try: try:
cmd = ['umount', '-n', chroot_path] cmd = ["umount", "-n", chroot_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
self._log_debug("Tmpfs unmounted successfully") self._log_debug("Tmpfs unmounted successfully")
return return
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_warning(f"Normal unmount failed: {e.stderr}") self._log_warning(f"Normal unmount failed: {e.stderr}")
# Try lazy unmount # Try lazy unmount
try: try:
cmd = ['umount', '-n', '-l', chroot_path] cmd = ["umount", "-n", "-l", chroot_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
self._log_debug("Tmpfs lazy unmounted successfully") self._log_debug("Tmpfs lazy unmounted successfully")
return return
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_warning(f"Lazy unmount failed: {e.stderr}") self._log_warning(f"Lazy unmount failed: {e.stderr}")
# Try force unmount as last resort # Try force unmount as last resort
try: try:
cmd = ['umount', '-n', '-f', chroot_path] cmd = ["umount", "-n", "-f", chroot_path]
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
self._log_debug("Tmpfs force unmounted successfully") self._log_debug("Tmpfs force unmounted successfully")
return return
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
self._log_error(f"Force unmount failed: {e.stderr}") self._log_error(f"Force unmount failed: {e.stderr}")
raise raise
def validate_config(self, config: Any) -> bool: def validate_config(self, config: Any) -> bool:
""" """
Validate plugin configuration. Validate plugin configuration.
Args: Args:
config: Configuration to validate config: Configuration to validate
Returns: Returns:
True if configuration is valid, False otherwise True if configuration is valid, False otherwise
""" """
plugin_config = getattr(config, 'plugins', {}).get('tmpfs', {}) plugin_config = getattr(config, "plugins", {}).get("tmpfs", {})
# Validate size format # Validate size format
size = plugin_config.get('size', '2G') size = plugin_config.get("size", "2G")
if not self._is_valid_size_format(size): if not self._is_valid_size_format(size):
self._log_error(f"Invalid size format: {size}. Use format like '2G', '512M', etc.") self._log_error(f"Invalid size format: {size}. Use format like '2G', '512M', etc.")
return False return False
# Validate mode format # Validate mode format
mode = plugin_config.get('mode', '0755') mode = plugin_config.get("mode", "0755")
if not self._is_valid_mode_format(mode): if not self._is_valid_mode_format(mode):
self._log_error(f"Invalid mode format: {mode}. Use octal format like '0755'") self._log_error(f"Invalid mode format: {mode}. Use octal format like '0755'")
return False return False
# Validate required_ram_mb # Validate required_ram_mb
required_ram = plugin_config.get('required_ram_mb', 2048) required_ram = plugin_config.get("required_ram_mb", 2048)
if not isinstance(required_ram, int) or required_ram <= 0: if not isinstance(required_ram, int) or required_ram <= 0:
self._log_error(f"Invalid required_ram_mb: {required_ram}. Must be positive integer") self._log_error(f"Invalid required_ram_mb: {required_ram}. Must be positive integer")
return False return False
# Validate keep_mounted # Validate keep_mounted
keep_mounted = plugin_config.get('keep_mounted', False) keep_mounted = plugin_config.get("keep_mounted", False)
if not isinstance(keep_mounted, bool): if not isinstance(keep_mounted, bool):
self._log_error(f"Invalid keep_mounted: {keep_mounted}. Must be boolean") self._log_error(f"Invalid keep_mounted: {keep_mounted}. Must be boolean")
return False return False
return True return True
def _is_valid_size_format(self, size: str) -> bool: def _is_valid_size_format(self, size: str) -> bool:
""" """
Check if size format is valid. Check if size format is valid.
Args: Args:
size: Size string to validate size: Size string to validate
Returns: Returns:
True if format is valid, False otherwise True if format is valid, False otherwise
""" """
if not size: if not size:
return False return False
# Check if it's a number (bytes) # Check if it's a number (bytes)
if size.isdigit(): if size.isdigit():
return True return True
# Check if it ends with a valid unit # Check if it ends with a valid unit
valid_units = ['K', 'M', 'G', 'T'] valid_units = ["K", "M", "G", "T"]
if size[-1] in valid_units and size[:-1].isdigit(): if size[-1] in valid_units and size[:-1].isdigit():
return True return True
return False return False
def _is_valid_mode_format(self, mode: str) -> bool: def _is_valid_mode_format(self, mode: str) -> bool:
""" """
Check if mode format is valid. Check if mode format is valid.
Args: Args:
mode: Mode string to validate mode: Mode string to validate
Returns: Returns:
True if format is valid, False otherwise True if format is valid, False otherwise
""" """
if not mode: if not mode:
return False return False
# Check if it's a valid octal number # Check if it's a valid octal number
try: try:
int(mode, 8) int(mode, 8)
return True return True
except ValueError: except ValueError:
return False return False
def get_plugin_info(self) -> Dict[str, Any]: def get_plugin_info(self) -> Dict[str, Any]:
""" """
Get plugin information. Get plugin information.
Returns: Returns:
Dictionary with plugin information Dictionary with plugin information
""" """
info = super().get_plugin_info() info = super().get_plugin_info()
info.update({ info.update(
'tmpfs_size': self.tmpfs_settings['size'], {
'tmpfs_mode': self.tmpfs_settings['mode'], "tmpfs_size": self.tmpfs_settings["size"],
'mount_point': self.tmpfs_settings['mount_point'], "tmpfs_mode": self.tmpfs_settings["mode"],
'keep_mounted': self.tmpfs_settings['keep_mounted'], "mount_point": self.tmpfs_settings["mount_point"],
'required_ram_mb': self.tmpfs_settings['required_ram_mb'], "keep_mounted": self.tmpfs_settings["keep_mounted"],
'mounted': self.mounted, "required_ram_mb": self.tmpfs_settings["required_ram_mb"],
'hooks': ['mount_root', 'postumount'] "mounted": self.mounted,
}) "hooks": ["mount_root", "postumount"],
return info }
)
return info

281
deb_mock/sbuild.py
View file

@ -5,276 +5,281 @@ sbuild wrapper for deb-mock
import os import os
import subprocess import subprocess
import tempfile import tempfile
import shutil
from pathlib import Path from pathlib import Path
from typing import List, Dict, Any, Optional from typing import Any, Dict, List
from .exceptions import SbuildError from .exceptions import SbuildError
class SbuildWrapper: class SbuildWrapper:
"""Wrapper around sbuild for standardized package building""" """Wrapper around sbuild for standardized package building"""
def __init__(self, config): def __init__(self, config):
self.config = config self.config = config
def build_package(self, source_package: str, chroot_name: str = None, def build_package(
output_dir: str = None, **kwargs) -> Dict[str, Any]: self,
source_package: str,
chroot_name: str = None,
output_dir: str = None,
**kwargs,
) -> Dict[str, Any]:
"""Build a Debian source package using sbuild""" """Build a Debian source package using sbuild"""
if chroot_name is None: if chroot_name is None:
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
if output_dir is None: if output_dir is None:
output_dir = self.config.get_output_path() output_dir = self.config.get_output_path()
# Ensure output directory exists # Ensure output directory exists
os.makedirs(output_dir, exist_ok=True) os.makedirs(output_dir, exist_ok=True)
# Prepare sbuild command # Prepare sbuild command
cmd = self._prepare_sbuild_command(source_package, chroot_name, output_dir, **kwargs) cmd = self._prepare_sbuild_command(source_package, chroot_name, output_dir, **kwargs)
# Prepare environment variables
env = os.environ.copy()
if kwargs.get("build_env"):
env.update(kwargs["build_env"])
env.update(self.config.build_env)
# Create temporary log file # Create temporary log file
with tempfile.NamedTemporaryFile(mode='w', suffix='.log', delete=False) as log_file: with tempfile.NamedTemporaryFile(mode="w", suffix=".log", delete=False) as log_file:
log_path = log_file.name log_path = log_file.name
try: try:
# Execute sbuild # Execute sbuild
result = self._execute_sbuild(cmd, log_path) result = self._execute_sbuild(cmd, log_path, env)
# Parse build results # Parse build results
build_info = self._parse_build_results(output_dir, log_path, result) build_info = self._parse_build_results(output_dir, log_path, result)
return build_info return build_info
finally: finally:
# Clean up temporary log file # Clean up temporary log file
if os.path.exists(log_path): if os.path.exists(log_path):
os.unlink(log_path) os.unlink(log_path)
def _prepare_sbuild_command(self, source_package: str, chroot_name: str, def _prepare_sbuild_command(self, source_package: str, chroot_name: str, output_dir: str, **kwargs) -> List[str]:
output_dir: str, **kwargs) -> List[str]:
"""Prepare the sbuild command with all necessary options""" """Prepare the sbuild command with all necessary options"""
cmd = ['sbuild'] cmd = ["sbuild"]
# Basic options # Basic options
cmd.extend(['--chroot', chroot_name]) cmd.extend(["--chroot", chroot_name])
cmd.extend(['--dist', self.config.suite]) cmd.extend(["--dist", self.config.suite])
cmd.extend(['--arch', self.config.architecture]) cmd.extend(["--arch", self.config.architecture])
# Output options # Output options
cmd.extend(['--build-dir', output_dir]) cmd.extend(["--build-dir", output_dir])
# Logging options
cmd.extend(['--log-dir', self.config.sbuild_log_dir])
# Build options # Build options
if kwargs.get('verbose', self.config.verbose): if kwargs.get("verbose", self.config.verbose):
cmd.append('--verbose') cmd.append("--verbose")
if kwargs.get('debug', self.config.debug): if kwargs.get("debug", self.config.debug):
cmd.append('--debug') cmd.append("--debug")
# Additional build options from config # Additional build options from config
for option in self.config.build_options: for option in self.config.build_options:
cmd.extend(option.split()) cmd.extend(option.split())
# Custom build options # Custom build options
if kwargs.get('build_options'): if kwargs.get("build_options"):
for option in kwargs['build_options']: for option in kwargs["build_options"]:
cmd.extend(option.split()) cmd.extend(option.split())
# Environment variables # Environment variables will be passed to subprocess.run
for key, value in self.config.build_env.items(): pass
cmd.extend(['--env', f'{key}={value}'])
# Custom environment variables
if kwargs.get('build_env'):
for key, value in kwargs['build_env'].items():
cmd.extend(['--env', f'{key}={value}'])
# Source package # Source package
cmd.append(source_package) cmd.append(source_package)
return cmd return cmd
def _execute_sbuild(self, cmd: List[str], log_path: str) -> subprocess.CompletedProcess: def _execute_sbuild(self, cmd: List[str], log_path: str, env: Dict[str, str] = None) -> subprocess.CompletedProcess:
"""Execute sbuild command""" """Execute sbuild command"""
try: try:
# Redirect output to log file # Redirect output to log file
with open(log_path, 'w') as log_file: with open(log_path, "w") as log_file:
result = subprocess.run( result = subprocess.run(
cmd, cmd,
stdout=log_file, stdout=log_file,
stderr=subprocess.STDOUT, stderr=subprocess.STDOUT,
text=True, text=True,
check=True check=True,
env=env,
) )
return result return result
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
# Read log file for error details # Read log file for error details
with open(log_path, 'r') as log_file: with open(log_path, "r") as log_file:
log_content = log_file.read() log_content = log_file.read()
raise SbuildError(f"sbuild failed: {e}\nLog output:\n{log_content}") raise SbuildError(f"sbuild failed: {e}\nLog output:\n{log_content}")
except FileNotFoundError: except FileNotFoundError:
raise SbuildError("sbuild not found. Please install sbuild package.") raise SbuildError("sbuild not found. Please install sbuild package.")
def _parse_build_results(self, output_dir: str, log_path: str, def _parse_build_results(
result: subprocess.CompletedProcess) -> Dict[str, Any]: self, output_dir: str, log_path: str, result: subprocess.CompletedProcess
) -> Dict[str, Any]:
"""Parse build results and collect artifacts""" """Parse build results and collect artifacts"""
build_info = { build_info = {
'success': True, "success": True,
'output_dir': output_dir, "output_dir": output_dir,
'log_file': log_path, "log_file": log_path,
'artifacts': [], "artifacts": [],
'metadata': {} "metadata": {},
} }
# Collect build artifacts # Collect build artifacts
artifacts = self._collect_artifacts(output_dir) artifacts = self._collect_artifacts(output_dir)
build_info['artifacts'] = artifacts build_info["artifacts"] = artifacts
# Parse build metadata # Parse build metadata
metadata = self._parse_build_metadata(log_path, output_dir) metadata = self._parse_build_metadata(log_path, output_dir)
build_info['metadata'] = metadata build_info["metadata"] = metadata
return build_info return build_info
def _collect_artifacts(self, output_dir: str) -> List[str]: def _collect_artifacts(self, output_dir: str) -> List[str]:
"""Collect build artifacts from output directory""" """Collect build artifacts from output directory"""
artifacts = [] artifacts = []
if not os.path.exists(output_dir): if not os.path.exists(output_dir):
return artifacts return artifacts
# Look for .deb files # Look for .deb files
for deb_file in Path(output_dir).glob("*.deb"): for deb_file in Path(output_dir).glob("*.deb"):
artifacts.append(str(deb_file)) artifacts.append(str(deb_file))
# Look for .changes files # Look for .changes files
for changes_file in Path(output_dir).glob("*.changes"): for changes_file in Path(output_dir).glob("*.changes"):
artifacts.append(str(changes_file)) artifacts.append(str(changes_file))
# Look for .buildinfo files # Look for .buildinfo files
for buildinfo_file in Path(output_dir).glob("*.buildinfo"): for buildinfo_file in Path(output_dir).glob("*.buildinfo"):
artifacts.append(str(buildinfo_file)) artifacts.append(str(buildinfo_file))
return artifacts return artifacts
def _parse_build_metadata(self, log_path: str, output_dir: str) -> Dict[str, Any]: def _parse_build_metadata(self, log_path: str, output_dir: str) -> Dict[str, Any]:
"""Parse build metadata from log and artifacts""" """Parse build metadata from log and artifacts"""
metadata = { metadata = {
'build_time': None, "build_time": None,
'package_name': None, "package_name": None,
'package_version': None, "package_version": None,
'architecture': self.config.architecture, "architecture": self.config.architecture,
'suite': self.config.suite, "suite": self.config.suite,
'chroot': self.config.chroot_name, "chroot": self.config.chroot_name,
'dependencies': [], "dependencies": [],
'build_dependencies': [] "build_dependencies": [],
} }
# Parse log file for metadata # Parse log file for metadata
if os.path.exists(log_path): if os.path.exists(log_path):
with open(log_path, 'r') as log_file: with open(log_path, "r") as log_file:
log_content = log_file.read() log_content = log_file.read()
metadata.update(self._extract_metadata_from_log(log_content)) metadata.update(self._extract_metadata_from_log(log_content))
# Parse .changes file for additional metadata # Parse .changes file for additional metadata
changes_files = list(Path(output_dir).glob("*.changes")) changes_files = list(Path(output_dir).glob("*.changes"))
if changes_files: if changes_files:
metadata.update(self._parse_changes_file(changes_files[0])) metadata.update(self._parse_changes_file(changes_files[0]))
return metadata return metadata
def _extract_metadata_from_log(self, log_content: str) -> Dict[str, Any]: def _extract_metadata_from_log(self, log_content: str) -> Dict[str, Any]:
"""Extract metadata from sbuild log content""" """Extract metadata from sbuild log content"""
metadata = {} metadata = {}
# Extract build time # Extract build time
import re import re
time_match = re.search(r'Build started at (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})', log_content)
time_match = re.search(r"Build started at (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})", log_content)
if time_match: if time_match:
metadata['build_time'] = time_match.group(1) metadata["build_time"] = time_match.group(1)
# Extract package name and version # Extract package name and version
package_match = re.search(r'Building (\S+) \((\S+)\)', log_content) package_match = re.search(r"Building (\S+) \((\S+)\)", log_content)
if package_match: if package_match:
metadata['package_name'] = package_match.group(1) metadata["package_name"] = package_match.group(1)
metadata['package_version'] = package_match.group(2) metadata["package_version"] = package_match.group(2)
return metadata return metadata
def _parse_changes_file(self, changes_file: Path) -> Dict[str, Any]: def _parse_changes_file(self, changes_file: Path) -> Dict[str, Any]:
"""Parse .changes file for metadata""" """Parse .changes file for metadata"""
metadata = {} metadata = {}
try: try:
with open(changes_file, 'r') as f: with open(changes_file, "r") as f:
content = f.read() content = f.read()
lines = content.split('\n') lines = content.split("\n")
for line in lines: for line in lines:
if line.startswith('Source:'): if line.startswith("Source:"):
metadata['source_package'] = line.split(':', 1)[1].strip() metadata["source_package"] = line.split(":", 1)[1].strip()
elif line.startswith('Version:'): elif line.startswith("Version:"):
metadata['source_version'] = line.split(':', 1)[1].strip() metadata["source_version"] = line.split(":", 1)[1].strip()
elif line.startswith('Architecture:'): elif line.startswith("Architecture:"):
metadata['architectures'] = line.split(':', 1)[1].strip().split() metadata["architectures"] = line.split(":", 1)[1].strip().split()
except Exception: except Exception:
pass pass
return metadata return metadata
def check_dependencies(self, source_package: str, chroot_name: str = None) -> Dict[str, Any]: def check_dependencies(self, source_package: str, chroot_name: str = None) -> Dict[str, Any]:
"""Check build dependencies for a source package""" """Check build dependencies for a source package"""
if chroot_name is None: if chroot_name is None:
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
# Use dpkg-checkbuilddeps to check dependencies # Use dpkg-checkbuilddeps to check dependencies
cmd = ['schroot', '-c', chroot_name, '--', 'dpkg-checkbuilddeps'] cmd = ["schroot", "-c", chroot_name, "--", "dpkg-checkbuilddeps"]
try: try:
result = subprocess.run(cmd, capture_output=True, text=True, check=True) subprocess.run(cmd, capture_output=True, text=True, check=True)
return { return {"satisfied": True, "missing": [], "conflicts": []}
'satisfied': True,
'missing': [],
'conflicts': []
}
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
# Parse missing dependencies from error output # Parse missing dependencies from error output
missing = self._parse_missing_dependencies(e.stderr) missing = self._parse_missing_dependencies(e.stderr)
return { return {"satisfied": False, "missing": missing, "conflicts": []}
'satisfied': False,
'missing': missing,
'conflicts': []
}
def _parse_missing_dependencies(self, stderr: str) -> List[str]: def _parse_missing_dependencies(self, stderr: str) -> List[str]:
"""Parse missing dependencies from dpkg-checkbuilddeps output""" """Parse missing dependencies from dpkg-checkbuilddeps output"""
missing = [] missing = []
for line in stderr.split('\n'): for line in stderr.split("\n"):
if 'Unmet build dependencies:' in line: if "Unmet build dependencies:" in line:
# Extract package names from the line # Extract package names from the line
import re import re
packages = re.findall(r'\b[a-zA-Z0-9][a-zA-Z0-9+\-\.]*\b', line)
packages = re.findall(r"\b[a-zA-Z0-9][a-zA-Z0-9+\-\.]*\b", line)
missing.extend(packages) missing.extend(packages)
return missing return missing
def install_build_dependencies(self, dependencies: List[str], chroot_name: str = None) -> None: def install_build_dependencies(self, dependencies: List[str], chroot_name: str = None) -> None:
"""Install build dependencies in the chroot""" """Install build dependencies in the chroot"""
if chroot_name is None: if chroot_name is None:
chroot_name = self.config.chroot_name chroot_name = self.config.chroot_name
if not dependencies: if not dependencies:
return return
cmd = ['schroot', '-c', chroot_name, '--', 'apt-get', 'install', '-y'] + dependencies cmd = [
"schroot",
"-c",
chroot_name,
"--",
"apt-get",
"install",
"-y",
] + dependencies
try: try:
subprocess.run(cmd, check=True) subprocess.run(cmd, check=True)
except subprocess.CalledProcessError as e: except subprocess.CalledProcessError as e:
raise SbuildError(f"Failed to install build dependencies: {e}") raise SbuildError(f"Failed to install build dependencies: {e}")

0
debian/rules vendored Normal file → Executable file
View file

5
examples/hello_1.0-1.debian.tar.gz
View file

@ -1,5 +0,0 @@
# This is a placeholder for the hello_1.0-1.debian.tar.gz file
# In a real scenario, this would contain the debian/ directory
# with packaging files like debian/control, debian/rules, etc.
# For testing purposes, you would need to create an actual tarball
# containing the Debian packaging files.

19
examples/hello_1.0.dsc
View file

@ -1,19 +0,0 @@
Format: 3.0 (quilt)
Source: hello
Binary: hello
Architecture: any
Version: 1.0-1
Maintainer: Deb-Mock Team <team@deb-mock.org>
Homepage: https://github.com/deb-mock/deb-mock
Standards-Version: 4.6.2
Vcs-Browser: https://github.com/deb-mock/deb-mock
Vcs-Git: https://github.com/deb-mock/deb-mock.git
Build-Depends: debhelper-compat (= 13)
Package: hello
Architecture: any
Depends: ${misc:Depends}
Description: Example package for Deb-Mock testing
This is a simple example package used to test the Deb-Mock
build environment. It demonstrates basic package building
functionality.

4
examples/hello_1.0.orig.tar.gz
View file

@ -1,4 +0,0 @@
# This is a placeholder for the hello_1.0.orig.tar.gz file
# In a real scenario, this would be the upstream source tarball
# For testing purposes, you would need to create an actual tarball
# containing the source code for the hello package.

3
test-config.yaml
View file

@ -19,4 +19,5 @@ parallel_jobs: 2
# Build settings # Build settings
keep_chroot: false keep_chroot: false
verbose: true verbose: true
debug: false debug: false

2
tests/__init__.py
View file

@ -1,3 +1,3 @@
""" """
Tests for deb-mock Tests for deb-mock
""" """

130
tests/test_config.py
View file

@ -2,47 +2,47 @@
Tests for configuration management Tests for configuration management
""" """
import unittest
import tempfile
import os import os
from pathlib import Path import tempfile
import unittest
from deb_mock.config import Config from deb_mock.config import Config
from deb_mock.exceptions import ConfigurationError from deb_mock.exceptions import ConfigurationError
class TestConfig(unittest.TestCase): class TestConfig(unittest.TestCase):
"""Test configuration management""" """Test configuration management"""
def test_default_config(self): def test_default_config(self):
"""Test default configuration creation""" """Test default configuration creation"""
config = Config.default() config = Config.default()
self.assertEqual(config.chroot_name, 'bookworm-amd64') self.assertEqual(config.chroot_name, "bookworm-amd64")
self.assertEqual(config.architecture, 'amd64') self.assertEqual(config.architecture, "amd64")
self.assertEqual(config.suite, 'bookworm') self.assertEqual(config.suite, "bookworm")
self.assertEqual(config.output_dir, './output') self.assertEqual(config.output_dir, "./output")
self.assertFalse(config.keep_chroot) self.assertFalse(config.keep_chroot)
self.assertFalse(config.verbose) self.assertFalse(config.verbose)
self.assertFalse(config.debug) self.assertFalse(config.debug)
def test_custom_config(self): def test_custom_config(self):
"""Test custom configuration creation""" """Test custom configuration creation"""
config = Config( config = Config(
chroot_name='sid-amd64', chroot_name="sid-amd64",
architecture='arm64', architecture="arm64",
suite='sid', suite="sid",
output_dir='/tmp/build', output_dir="/tmp/build",
keep_chroot=True, keep_chroot=True,
verbose=True verbose=True,
) )
self.assertEqual(config.chroot_name, 'sid-amd64') self.assertEqual(config.chroot_name, "sid-amd64")
self.assertEqual(config.architecture, 'arm64') self.assertEqual(config.architecture, "arm64")
self.assertEqual(config.suite, 'sid') self.assertEqual(config.suite, "sid")
self.assertEqual(config.output_dir, '/tmp/build') self.assertEqual(config.output_dir, "/tmp/build")
self.assertTrue(config.keep_chroot) self.assertTrue(config.keep_chroot)
self.assertTrue(config.verbose) self.assertTrue(config.verbose)
def test_config_from_file(self): def test_config_from_file(self):
"""Test loading configuration from file""" """Test loading configuration from file"""
config_data = """ config_data = """
@ -53,89 +53,81 @@ output_dir: /tmp/build
keep_chroot: true keep_chroot: true
verbose: true verbose: true
""" """
with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f: with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
f.write(config_data) f.write(config_data)
config_file = f.name config_file = f.name
try: try:
config = Config.from_file(config_file) config = Config.from_file(config_file)
self.assertEqual(config.chroot_name, 'sid-amd64') self.assertEqual(config.chroot_name, "sid-amd64")
self.assertEqual(config.architecture, 'arm64') self.assertEqual(config.architecture, "arm64")
self.assertEqual(config.suite, 'sid') self.assertEqual(config.suite, "sid")
self.assertEqual(config.output_dir, '/tmp/build') self.assertEqual(config.output_dir, "/tmp/build")
self.assertTrue(config.keep_chroot) self.assertTrue(config.keep_chroot)
self.assertTrue(config.verbose) self.assertTrue(config.verbose)
finally: finally:
os.unlink(config_file) os.unlink(config_file)
def test_config_to_dict(self): def test_config_to_dict(self):
"""Test converting configuration to dictionary""" """Test converting configuration to dictionary"""
config = Config( config = Config(chroot_name="test-chroot", architecture="amd64", suite="bookworm")
chroot_name='test-chroot',
architecture='amd64',
suite='bookworm'
)
config_dict = config.to_dict() config_dict = config.to_dict()
self.assertEqual(config_dict['chroot_name'], 'test-chroot') self.assertEqual(config_dict["chroot_name"], "test-chroot")
self.assertEqual(config_dict['architecture'], 'amd64') self.assertEqual(config_dict["architecture"], "amd64")
self.assertEqual(config_dict['suite'], 'bookworm') self.assertEqual(config_dict["suite"], "bookworm")
self.assertIn('output_dir', config_dict) self.assertIn("output_dir", config_dict)
self.assertIn('keep_chroot', config_dict) self.assertIn("keep_chroot", config_dict)
def test_config_save(self): def test_config_save(self):
"""Test saving configuration to file""" """Test saving configuration to file"""
config = Config( config = Config(chroot_name="test-chroot", architecture="amd64", suite="bookworm")
chroot_name='test-chroot',
architecture='amd64', with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
suite='bookworm'
)
with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
config_file = f.name config_file = f.name
try: try:
config.save(config_file) config.save(config_file)
# Load the saved configuration # Load the saved configuration
loaded_config = Config.from_file(config_file) loaded_config = Config.from_file(config_file)
self.assertEqual(loaded_config.chroot_name, config.chroot_name) self.assertEqual(loaded_config.chroot_name, config.chroot_name)
self.assertEqual(loaded_config.architecture, config.architecture) self.assertEqual(loaded_config.architecture, config.architecture)
self.assertEqual(loaded_config.suite, config.suite) self.assertEqual(loaded_config.suite, config.suite)
finally: finally:
if os.path.exists(config_file): if os.path.exists(config_file):
os.unlink(config_file) os.unlink(config_file)
def test_invalid_architecture(self): def test_invalid_architecture(self):
"""Test validation of invalid architecture""" """Test validation of invalid architecture"""
config = Config(architecture='invalid-arch') config = Config(architecture="invalid-arch")
with self.assertRaises(ConfigurationError): with self.assertRaises(ConfigurationError):
config.validate() config.validate()
def test_invalid_suite(self): def test_invalid_suite(self):
"""Test validation of invalid suite""" """Test validation of invalid suite"""
config = Config(suite='invalid-suite') config = Config(suite="invalid-suite")
with self.assertRaises(ConfigurationError): with self.assertRaises(ConfigurationError):
config.validate() config.validate()
def test_get_paths(self): def test_get_paths(self):
"""Test path generation methods""" """Test path generation methods"""
config = Config( config = Config(
chroot_dir='/var/lib/chroots', chroot_dir="/var/lib/chroots",
output_dir='./output', output_dir="./output",
metadata_dir='./metadata' metadata_dir="./metadata",
) )
self.assertEqual(config.get_chroot_path(), '/var/lib/chroots/bookworm-amd64') self.assertEqual(config.get_chroot_path(), "/var/lib/chroots/bookworm-amd64")
self.assertEqual(config.get_output_path(), os.path.abspath('./output')) self.assertEqual(config.get_output_path(), os.path.abspath("./output"))
self.assertEqual(config.get_metadata_path(), os.path.abspath('./metadata')) self.assertEqual(config.get_metadata_path(), os.path.abspath("./metadata"))
if __name__ == '__main__': if __name__ == "__main__":
unittest.main() unittest.main()

166
tests/test_exceptions.py
View file

@ -3,19 +3,26 @@ Tests for the enhanced exception handling system
""" """
import pytest import pytest
import sys
from io import StringIO
from deb_mock.exceptions import ( from deb_mock.exceptions import (
DebMockError, ConfigurationError, ChrootError, SbuildError, BuildError,
BuildError, DependencyError, MetadataError, CacheError, CacheError,
PluginError, NetworkError, PermissionError, ValidationError, ChrootError,
handle_exception, format_error_context ConfigurationError,
DebMockError,
DependencyError,
NetworkError,
PermissionError,
SbuildError,
ValidationError,
format_error_context,
handle_exception,
) )
class TestDebMockError: class TestDebMockError:
"""Test the base DebMockError class""" """Test the base DebMockError class"""
def test_basic_error(self): def test_basic_error(self):
"""Test basic error creation""" """Test basic error creation"""
error = DebMockError("Test error message") error = DebMockError("Test error message")
@ -23,24 +30,24 @@ class TestDebMockError:
assert error.exit_code == 1 assert error.exit_code == 1
assert error.context == {} assert error.context == {}
assert error.suggestions == [] assert error.suggestions == []
def test_error_with_context(self): def test_error_with_context(self):
"""Test error with context information""" """Test error with context information"""
context = {'file': '/path/to/file', 'operation': 'read'} context = {"file": "/path/to/file", "operation": "read"}
error = DebMockError("File operation failed", context=context) error = DebMockError("File operation failed", context=context)
expected = """Error: File operation failed expected = """Error: File operation failed
Context: Context:
file: /path/to/file file: /path/to/file
operation: read""" operation: read"""
assert str(error) == expected assert str(error) == expected
def test_error_with_suggestions(self): def test_error_with_suggestions(self):
"""Test error with suggestions""" """Test error with suggestions"""
suggestions = ["Try again", "Check permissions", "Contact admin"] suggestions = ["Try again", "Check permissions", "Contact admin"]
error = DebMockError("Operation failed", suggestions=suggestions) error = DebMockError("Operation failed", suggestions=suggestions)
expected = """Error: Operation failed expected = """Error: Operation failed
Suggestions: Suggestions:
@ -48,14 +55,13 @@ Suggestions:
2. Check permissions 2. Check permissions
3. Contact admin""" 3. Contact admin"""
assert str(error) == expected assert str(error) == expected
def test_error_with_context_and_suggestions(self): def test_error_with_context_and_suggestions(self):
"""Test error with both context and suggestions""" """Test error with both context and suggestions"""
context = {'config_file': '/etc/deb-mock.conf'} context = {"config_file": "/etc/deb-mock.conf"}
suggestions = ["Check config syntax", "Verify file exists"] suggestions = ["Check config syntax", "Verify file exists"]
error = DebMockError("Invalid configuration", error = DebMockError("Invalid configuration", context=context, suggestions=suggestions)
context=context, suggestions=suggestions)
expected = """Error: Invalid configuration expected = """Error: Invalid configuration
Context: Context:
@ -65,7 +71,7 @@ Suggestions:
1. Check config syntax 1. Check config syntax
2. Verify file exists""" 2. Verify file exists"""
assert str(error) == expected assert str(error) == expected
def test_print_error(self, capsys): def test_print_error(self, capsys):
"""Test error printing to stderr""" """Test error printing to stderr"""
error = DebMockError("Test error") error = DebMockError("Test error")
@ -73,7 +79,7 @@ Suggestions:
error.print_error() error.print_error()
# If we get here, the method executed successfully # If we get here, the method executed successfully
assert True assert True
def test_get_exit_code(self): def test_get_exit_code(self):
"""Test exit code retrieval""" """Test exit code retrieval"""
error = DebMockError("Test error", exit_code=42) error = DebMockError("Test error", exit_code=42)
@ -82,125 +88,125 @@ Suggestions:
class TestSpecificExceptions: class TestSpecificExceptions:
"""Test specific exception types""" """Test specific exception types"""
def test_configuration_error(self): def test_configuration_error(self):
"""Test ConfigurationError with file and section context""" """Test ConfigurationError with file and section context"""
error = ConfigurationError( error = ConfigurationError(
"Invalid configuration", "Invalid configuration",
config_file="/etc/deb-mock.conf", config_file="/etc/deb-mock.conf",
config_section="chroot" config_section="chroot",
) )
assert "config_file: /etc/deb-mock.conf" in str(error) assert "config_file: /etc/deb-mock.conf" in str(error)
assert "config_section: chroot" in str(error) assert "config_section: chroot" in str(error)
assert error.exit_code == 2 assert error.exit_code == 2
assert len(error.suggestions) > 0 assert len(error.suggestions) > 0
def test_chroot_error(self): def test_chroot_error(self):
"""Test ChrootError with operation context""" """Test ChrootError with operation context"""
error = ChrootError( error = ChrootError(
"Failed to create chroot", "Failed to create chroot",
chroot_name="bookworm-amd64", chroot_name="bookworm-amd64",
operation="create", operation="create",
chroot_path="/var/lib/deb-mock/chroots/bookworm-amd64" chroot_path="/var/lib/deb-mock/chroots/bookworm-amd64",
) )
assert "chroot_name: bookworm-amd64" in str(error) assert "chroot_name: bookworm-amd64" in str(error)
assert "operation: create" in str(error) assert "operation: create" in str(error)
assert error.exit_code == 3 assert error.exit_code == 3
assert "clean-chroot" in str(error.suggestions[3]) assert "clean-chroot" in str(error.suggestions[3])
def test_sbuild_error(self): def test_sbuild_error(self):
"""Test SbuildError with build context""" """Test SbuildError with build context"""
error = SbuildError( error = SbuildError(
"Build failed", "Build failed",
sbuild_config="/etc/sbuild/sbuild.conf", sbuild_config="/etc/sbuild/sbuild.conf",
build_log="/var/log/sbuild.log", build_log="/var/log/sbuild.log",
return_code=1 return_code=1,
) )
assert "sbuild_config: /etc/sbuild/sbuild.conf" in str(error) assert "sbuild_config: /etc/sbuild/sbuild.conf" in str(error)
assert "build_log: /var/log/sbuild.log" in str(error) assert "build_log: /var/log/sbuild.log" in str(error)
assert "return_code: 1" in str(error) assert "return_code: 1" in str(error)
assert error.exit_code == 4 assert error.exit_code == 4
def test_build_error(self): def test_build_error(self):
"""Test BuildError with source package context""" """Test BuildError with source package context"""
error = BuildError( error = BuildError(
"Package build failed", "Package build failed",
source_package="hello_1.0.dsc", source_package="hello_1.0.dsc",
build_log="/tmp/build.log", build_log="/tmp/build.log",
artifacts=["hello_1.0-1_amd64.deb"] artifacts=["hello_1.0-1_amd64.deb"],
) )
assert "source_package: hello_1.0.dsc" in str(error) assert "source_package: hello_1.0.dsc" in str(error)
assert "build_log: /tmp/build.log" in str(error) assert "build_log: /tmp/build.log" in str(error)
assert "artifacts: ['hello_1.0-1_amd64.deb']" in str(error) assert "artifacts: ['hello_1.0-1_amd64.deb']" in str(error)
assert error.exit_code == 5 assert error.exit_code == 5
def test_dependency_error(self): def test_dependency_error(self):
"""Test DependencyError with missing packages""" """Test DependencyError with missing packages"""
error = DependencyError( error = DependencyError(
"Missing build dependencies", "Missing build dependencies",
missing_packages=["build-essential", "devscripts"], missing_packages=["build-essential", "devscripts"],
conflicting_packages=["old-package"] conflicting_packages=["old-package"],
) )
assert "missing_packages: ['build-essential', 'devscripts']" in str(error) assert "missing_packages: ['build-essential', 'devscripts']" in str(error)
assert "conflicting_packages: ['old-package']" in str(error) assert "conflicting_packages: ['old-package']" in str(error)
assert error.exit_code == 6 assert error.exit_code == 6
def test_cache_error(self): def test_cache_error(self):
"""Test CacheError with cache context""" """Test CacheError with cache context"""
error = CacheError( error = CacheError(
"Cache operation failed", "Cache operation failed",
cache_type="root_cache", cache_type="root_cache",
cache_path="/var/cache/deb-mock/root-cache", cache_path="/var/cache/deb-mock/root-cache",
operation="restore" operation="restore",
) )
assert "cache_type: root_cache" in str(error) assert "cache_type: root_cache" in str(error)
assert "cache_path: /var/cache/deb-mock/root-cache" in str(error) assert "cache_path: /var/cache/deb-mock/root-cache" in str(error)
assert "operation: restore" in str(error) assert "operation: restore" in str(error)
assert error.exit_code == 8 assert error.exit_code == 8
def test_network_error(self): def test_network_error(self):
"""Test NetworkError with network context""" """Test NetworkError with network context"""
error = NetworkError( error = NetworkError(
"Repository access failed", "Repository access failed",
url="http://deb.debian.org/debian/", url="http://deb.debian.org/debian/",
proxy="http://proxy.example.com:3128", proxy="http://proxy.example.com:3128",
timeout=30 timeout=30,
) )
assert "url: http://deb.debian.org/debian/" in str(error) assert "url: http://deb.debian.org/debian/" in str(error)
assert "proxy: http://proxy.example.com:3128" in str(error) assert "proxy: http://proxy.example.com:3128" in str(error)
assert "timeout: 30" in str(error) assert "timeout: 30" in str(error)
assert error.exit_code == 10 assert error.exit_code == 10
def test_permission_error(self): def test_permission_error(self):
"""Test PermissionError with permission context""" """Test PermissionError with permission context"""
error = PermissionError( error = PermissionError(
"Insufficient privileges", "Insufficient privileges",
operation="create_chroot", operation="create_chroot",
path="/var/lib/deb-mock", path="/var/lib/deb-mock",
required_privileges="root" required_privileges="root",
) )
assert "operation: create_chroot" in str(error) assert "operation: create_chroot" in str(error)
assert "path: /var/lib/deb-mock" in str(error) assert "path: /var/lib/deb-mock" in str(error)
assert "required_privileges: root" in str(error) assert "required_privileges: root" in str(error)
assert error.exit_code == 11 assert error.exit_code == 11
def test_validation_error(self): def test_validation_error(self):
"""Test ValidationError with validation context""" """Test ValidationError with validation context"""
error = ValidationError( error = ValidationError(
"Invalid architecture", "Invalid architecture",
field="architecture", field="architecture",
value="invalid-arch", value="invalid-arch",
expected_format="amd64, i386, arm64, etc." expected_format="amd64, i386, arm64, etc.",
) )
assert "field: architecture" in str(error) assert "field: architecture" in str(error)
assert "value: invalid-arch" in str(error) assert "value: invalid-arch" in str(error)
assert "expected_format: amd64, i386, arm64, etc." in str(error) assert "expected_format: amd64, i386, arm64, etc." in str(error)
@ -209,35 +215,28 @@ class TestSpecificExceptions:
class TestHelperFunctions: class TestHelperFunctions:
"""Test helper functions""" """Test helper functions"""
def test_format_error_context(self): def test_format_error_context(self):
"""Test format_error_context helper""" """Test format_error_context helper"""
context = format_error_context( context = format_error_context(file="/path/to/file", operation="read", user="testuser", none_value=None)
file="/path/to/file",
operation="read", expected = {"file": "/path/to/file", "operation": "read", "user": "testuser"}
user="testuser",
none_value=None
)
expected = {
'file': '/path/to/file',
'operation': 'read',
'user': 'testuser'
}
assert context == expected assert context == expected
assert 'none_value' not in context assert "none_value" not in context
def test_handle_exception_decorator_success(self): def test_handle_exception_decorator_success(self):
"""Test handle_exception decorator with successful function""" """Test handle_exception decorator with successful function"""
@handle_exception @handle_exception
def successful_function(): def successful_function():
return "success" return "success"
result = successful_function() result = successful_function()
assert result == "success" assert result == "success"
def test_handle_exception_decorator_debmock_error(self, capsys): def test_handle_exception_decorator_debmock_error(self, capsys):
"""Test handle_exception decorator with DebMockError""" """Test handle_exception decorator with DebMockError"""
@handle_exception @handle_exception
def failing_function(): def failing_function():
raise ConfigurationError("Config error", config_file="/etc/config") raise ConfigurationError("Config error", config_file="/etc/config")
@ -250,9 +249,10 @@ class TestHelperFunctions:
# The error message was printed (we can see it in the test output) # The error message was printed (we can see it in the test output)
# Just verify the decorator handled the exception correctly # Just verify the decorator handled the exception correctly
assert True assert True
def test_handle_exception_decorator_unexpected_error(self, capsys): def test_handle_exception_decorator_unexpected_error(self, capsys):
"""Test handle_exception decorator with unexpected error""" """Test handle_exception decorator with unexpected error"""
@handle_exception @handle_exception
def unexpected_error_function(): def unexpected_error_function():
raise ValueError("Unexpected value error") raise ValueError("Unexpected value error")
@ -269,73 +269,73 @@ class TestHelperFunctions:
class TestExceptionIntegration: class TestExceptionIntegration:
"""Test exception integration scenarios""" """Test exception integration scenarios"""
def test_chroot_creation_error_scenario(self): def test_chroot_creation_error_scenario(self):
"""Test realistic chroot creation error scenario""" """Test realistic chroot creation error scenario"""
error = ChrootError( error = ChrootError(
"Failed to create chroot environment", "Failed to create chroot environment",
chroot_name="bookworm-amd64", chroot_name="bookworm-amd64",
operation="debootstrap", operation="debootstrap",
chroot_path="/var/lib/deb-mock/chroots/bookworm-amd64" chroot_path="/var/lib/deb-mock/chroots/bookworm-amd64",
) )
error_str = str(error) error_str = str(error)
# Check that all context information is present # Check that all context information is present
assert "chroot_name: bookworm-amd64" in error_str assert "chroot_name: bookworm-amd64" in error_str
assert "operation: debootstrap" in error_str assert "operation: debootstrap" in error_str
assert "chroot_path: /var/lib/deb-mock/chroots/bookworm-amd64" in error_str assert "chroot_path: /var/lib/deb-mock/chroots/bookworm-amd64" in error_str
# Check that helpful suggestions are provided # Check that helpful suggestions are provided
assert "sufficient disk space" in error_str assert "sufficient disk space" in error_str
assert "root privileges" in error_str assert "root privileges" in error_str
assert "clean-chroot" in error_str assert "clean-chroot" in error_str
# Check exit code # Check exit code
assert error.exit_code == 3 assert error.exit_code == 3
def test_build_failure_scenario(self): def test_build_failure_scenario(self):
"""Test realistic build failure scenario""" """Test realistic build failure scenario"""
error = BuildError( error = BuildError(
"Package build failed due to compilation errors", "Package build failed due to compilation errors",
source_package="myapp_1.0.dsc", source_package="myapp_1.0.dsc",
build_log="/tmp/build_myapp.log", build_log="/tmp/build_myapp.log",
artifacts=[] artifacts=[],
) )
error_str = str(error) error_str = str(error)
# Check context information # Check context information
assert "source_package: myapp_1.0.dsc" in error_str assert "source_package: myapp_1.0.dsc" in error_str
assert "build_log: /tmp/build_myapp.log" in error_str assert "build_log: /tmp/build_myapp.log" in error_str
# Check helpful suggestions # Check helpful suggestions
assert "build log" in error_str assert "build log" in error_str
assert "build dependencies" in error_str assert "build dependencies" in error_str
assert "verbose output" in error_str assert "verbose output" in error_str
# Check exit code # Check exit code
assert error.exit_code == 5 assert error.exit_code == 5
def test_dependency_resolution_scenario(self): def test_dependency_resolution_scenario(self):
"""Test realistic dependency resolution scenario""" """Test realistic dependency resolution scenario"""
error = DependencyError( error = DependencyError(
"Unable to resolve build dependencies", "Unable to resolve build dependencies",
missing_packages=["libssl-dev", "libcurl4-openssl-dev"], missing_packages=["libssl-dev", "libcurl4-openssl-dev"],
conflicting_packages=["libssl1.0-dev"] conflicting_packages=["libssl1.0-dev"],
) )
error_str = str(error) error_str = str(error)
# Check context information # Check context information
assert "libssl-dev" in error_str assert "libssl-dev" in error_str
assert "libcurl4-openssl-dev" in error_str assert "libcurl4-openssl-dev" in error_str
assert "libssl1.0-dev" in error_str assert "libssl1.0-dev" in error_str
# Check helpful suggestions # Check helpful suggestions
assert "Install missing build dependencies" in error_str assert "Install missing build dependencies" in error_str
assert "Resolve package conflicts" in error_str assert "Resolve package conflicts" in error_str
assert "update-chroot" in error_str assert "update-chroot" in error_str
# Check exit code # Check exit code
assert error.exit_code == 6 assert error.exit_code == 6