Phase 1 complete: Core/DBus decoupling, main entry refactor, interface_simple.py syntax fix
This commit is contained in:
Joe Particle
parent
2c3844029f
commit
d3b7a31a66
4 changed files with 352 additions and 155 deletions
12
TODO.md
12
TODO.md
|
|
@ -6,6 +6,7 @@
|
|||
- ✅ **D-Bus Signal Emission**: Fixed all dbus-next signal emission calls to use direct function calls instead of `.emit()`, resolving 'function object has no attribute emit' errors
|
||||
- ✅ **apt-layer.sh Integration**: Updated apt-layer.sh and related scriptlets to use the correct service name and ensure proper daemon status detection and management
|
||||
- ✅ **End-to-End D-Bus Testing**: Successfully tested D-Bus method/property calls and signal emission via busctl and apt-layer.sh, confirming full integration and correct daemon operation after VM reboot and service migration
|
||||
- ✅ **Phase 1: Foundation & Core Decoupling**: Core daemon logic is now fully decoupled from D-Bus. The core daemon is pure Python with no D-Bus dependencies, D-Bus setup is consolidated in the main entry point, D-Bus interfaces are thin wrappers with no business logic, and all circular imports are eliminated. Also fixed a syntax error in interface_simple.py.
|
||||
|
||||
### Daemon Integration (COMPLETED)
|
||||
- ✅ **D-Bus Interface**: Complete D-Bus interface implementation with sysroot and transaction interfaces
|
||||
|
|
@ -163,11 +164,12 @@
|
|||
## Next Phase 🎯
|
||||
|
||||
### Full dbus-next Migration & Architecture Decoupling (PLANNED)
|
||||
- 🎯 **Phase 1: Foundation & Core Decoupling**
|
||||
- Create centralized `AptOstreeDaemon` class with pure Python logic (no D-Bus dependencies)
|
||||
- Consolidate D-Bus setup in main entry point (`apt_ostree_new.py` or similar)
|
||||
- Refine `interface_simple.py` to pure D-Bus interface definitions using `dbus-next`
|
||||
- Eliminate circular imports and architectural impedance mismatch
|
||||
- ✅ **Phase 1: Foundation & Core Decoupling**
|
||||
- Core daemon is pure Python, no D-Bus dependencies
|
||||
- D-Bus setup consolidated in main entry point (`apt_ostree_new.py`)
|
||||
- D-Bus interfaces are thin wrappers, no business logic
|
||||
- Circular imports eliminated
|
||||
- Syntax error in interface_simple.py fixed
|
||||
- 🎯 **Phase 2: Implementing dbus-next Correctly & Decoupling Logic**
|
||||
- Implement all D-Bus properties using `@dbus_property` decorators
|
||||
- Correctly define and emit D-Bus signals using `@signal()` and `.emit()`
|
||||
|
|
|
|||
|
|
@ -2,6 +2,16 @@
|
|||
|
||||
## [Unreleased]
|
||||
|
||||
### Added
|
||||
- **Phase 1: Foundation & Core Decoupling**: Major architectural refactor.
|
||||
- Core daemon logic is now pure Python with no D-Bus dependencies.
|
||||
- D-Bus setup is consolidated in the main entry point (`apt_ostree_new.py`).
|
||||
- D-Bus interfaces are thin wrappers with no business logic, delegating to the core daemon.
|
||||
- All circular imports between D-Bus and core logic eliminated.
|
||||
|
||||
### Fixed
|
||||
- **Syntax Error**: Fixed unterminated string literal and missing newline in `interface_simple.py` that prevented daemon startup.
|
||||
|
||||
### Added
|
||||
- **Enhanced Logging System**: Comprehensive logging enhancement with advanced features
|
||||
- **Advanced Log Rotation**: Implemented size-based, time-based, and hybrid rotation strategies
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
Simplified D-Bus interface for apt-ostree using dbus-next
|
||||
Following rpm-ostree architectural patterns
|
||||
Thin wrapper around core daemon logic - no business logic here
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
|
|
@ -13,23 +13,17 @@ from dbus_next import BusType, DBusError
|
|||
from dbus_next.aio import MessageBus
|
||||
from dbus_next.service import ServiceInterface, method, signal, dbus_property, PropertyAccess
|
||||
|
||||
# Removed to avoid circular import - sysroot is passed via daemon_instance
|
||||
from utils.shell_integration import ShellIntegration
|
||||
|
||||
|
||||
class AptOstreeSysrootInterface(ServiceInterface):
|
||||
"""Sysroot interface following rpm-ostree patterns"""
|
||||
|
||||
def __init__(self, daemon_instance):
|
||||
"""Sysroot interface - thin D-Bus wrapper around core daemon"""
|
||||
def __init__(self, core_daemon):
|
||||
super().__init__("org.debian.aptostree1.Sysroot")
|
||||
self.daemon = daemon_instance
|
||||
# Pass progress callback to ShellIntegration
|
||||
self.shell_integration = ShellIntegration(progress_callback=self._progress_callback)
|
||||
self.core_daemon = core_daemon
|
||||
self.logger = logging.getLogger('dbus.sysroot')
|
||||
|
||||
# Properties
|
||||
self._booted = ""
|
||||
self._path = self.daemon.sysroot.path if hasattr(self.daemon, 'sysroot') else "/"
|
||||
self._path = self.core_daemon.get_sysroot_path()
|
||||
self._active_transaction = ""
|
||||
self._active_transaction_path = ""
|
||||
self._deployments = {}
|
||||
|
|
@ -50,209 +44,220 @@ class AptOstreeSysrootInterface(ServiceInterface):
|
|||
"""Signal emitted when system status changes"""
|
||||
pass
|
||||
|
||||
@method()
|
||||
async def GetStatus(self) -> 's':
|
||||
"""Get system status as JSON string"""
|
||||
try:
|
||||
status = {
|
||||
'daemon_running': True,
|
||||
'sysroot_path': self.daemon.sysroot.path,
|
||||
'active_transactions': len(self.daemon.get_active_transactions()) if hasattr(self.daemon, 'get_active_transactions') else 0,
|
||||
'test_mode': True # We're running in test mode
|
||||
}
|
||||
# Emit status changed signal as JSON string
|
||||
self.StatusChanged(json.dumps(status))
|
||||
return json.dumps(status)
|
||||
except Exception as e:
|
||||
self.logger.error(f"GetStatus failed: {e}")
|
||||
return json.dumps({'error': str(e)})
|
||||
|
||||
def _progress_callback(self, transaction_id, operation, progress, message):
|
||||
def _progress_callback(self, transaction_id: str, operation: str, progress: float, message: str):
|
||||
"""Progress callback that emits D-Bus signals"""
|
||||
try:
|
||||
self.TransactionProgress(transaction_id, operation, progress, message)
|
||||
self.logger.debug(f"Emitted TransactionProgress: {transaction_id} {operation} {progress}% {message}")
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to emit TransactionProgress signal: {e}")
|
||||
|
||||
@method()
|
||||
async def GetStatus(self) -> 's':
|
||||
"""Get system status as JSON string - delegates to core daemon"""
|
||||
try:
|
||||
# Delegate to core daemon
|
||||
status = await self.core_daemon.get_status()
|
||||
|
||||
# Emit status changed signal
|
||||
self.StatusChanged(json.dumps(status))
|
||||
return json.dumps(status)
|
||||
except Exception as e:
|
||||
self.logger.error(f"GetStatus failed: {e}")
|
||||
return json.dumps({'error': str(e)})
|
||||
|
||||
@method()
|
||||
async def InstallPackages(self, packages: 'as', live_install: 'b' = False) -> 's':
|
||||
"""Install packages using apt-layer.sh integration"""
|
||||
transaction_id = f"install_{int(time.time())}"
|
||||
"""Install packages - delegates to core daemon"""
|
||||
try:
|
||||
self.logger.info(f"Installing packages: {packages}")
|
||||
# Emit start signal
|
||||
self.TransactionProgress(transaction_id, "install", 0.0, f"Starting installation of {len(packages)} packages")
|
||||
result = await self.shell_integration.install_packages(packages, live_install)
|
||||
# Emit completion signal
|
||||
success = result.get('success', False)
|
||||
progress = 100.0 if success else 0.0
|
||||
message = f"Installation {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
|
||||
self.TransactionProgress(transaction_id, "install", progress, message)
|
||||
|
||||
# Delegate to core daemon with progress callback
|
||||
result = await self.core_daemon.install_packages(
|
||||
packages,
|
||||
live_install,
|
||||
progress_callback=self._progress_callback
|
||||
)
|
||||
|
||||
# Emit property changed for active transactions
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
|
||||
if result.get('success', False):
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
|
||||
return json.dumps(result)
|
||||
except Exception as e:
|
||||
self.logger.error(f"InstallPackages failed: {e}")
|
||||
self.TransactionProgress(transaction_id, "install", 0.0, f"Installation failed: {str(e)}")
|
||||
self._progress_callback("install", "install", 0.0, f"Installation failed: {str(e)}")
|
||||
return json.dumps({'success': False, 'error': str(e)})
|
||||
|
||||
@method()
|
||||
async def RemovePackages(self, packages: 'as', live_remove: 'b' = False) -> 's':
|
||||
"""Remove packages using apt-layer.sh integration"""
|
||||
transaction_id = f"remove_{int(time.time())}"
|
||||
"""Remove packages - delegates to core daemon"""
|
||||
try:
|
||||
self.logger.info(f"Removing packages: {packages}")
|
||||
self.TransactionProgress(transaction_id, "remove", 0.0, f"Starting removal of {len(packages)} packages")
|
||||
result = await self.shell_integration.remove_packages(packages, live_remove)
|
||||
success = result.get('success', False)
|
||||
progress = 100.0 if success else 0.0
|
||||
message = f"Removal {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
|
||||
self.TransactionProgress(transaction_id, "remove", progress, message)
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
|
||||
|
||||
# Delegate to core daemon with progress callback
|
||||
result = await self.core_daemon.remove_packages(
|
||||
packages,
|
||||
live_remove,
|
||||
progress_callback=self._progress_callback
|
||||
)
|
||||
|
||||
# Emit property changed for active transactions
|
||||
if result.get('success', False):
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
|
||||
return json.dumps(result)
|
||||
except Exception as e:
|
||||
self.logger.error(f"RemovePackages failed: {e}")
|
||||
self.TransactionProgress(transaction_id, "remove", 0.0, f"Removal failed: {str(e)}")
|
||||
return json.dumps({'success': False, 'error': str(e)})
|
||||
|
||||
@method()
|
||||
def ComposeFSCreate(self, source_dir: 's', layer_path: 's', digest_store: 's') -> 's':
|
||||
"""Create ComposeFS layer using apt-layer.sh integration"""
|
||||
try:
|
||||
self.logger.info(f"Creating ComposeFS layer: {source_dir} -> {layer_path}")
|
||||
|
||||
# This is synchronous, so no await needed
|
||||
result = self.shell_integration.composefs_create(source_dir, layer_path, digest_store)
|
||||
|
||||
return json.dumps(result)
|
||||
except Exception as e:
|
||||
self.logger.error(f"ComposeFSCreate failed: {e}")
|
||||
self._progress_callback("remove", "remove", 0.0, f"Removal failed: {str(e)}")
|
||||
return json.dumps({'success': False, 'error': str(e)})
|
||||
|
||||
@method()
|
||||
async def Deploy(self, deployment_id: 's') -> 's':
|
||||
"""Deploy a specific deployment"""
|
||||
transaction_id = f"deploy_{int(time.time())}"
|
||||
"""Deploy a specific deployment - delegates to core daemon"""
|
||||
try:
|
||||
self.logger.info(f"Deploying: {deployment_id}")
|
||||
self.TransactionProgress(transaction_id, "deploy", 0.0, f"Starting deployment of {deployment_id}")
|
||||
result = self.shell_integration.deploy_layer_sync(deployment_id)
|
||||
self.logger.info(f"Deploy result: {result}")
|
||||
success = result.get('success', False)
|
||||
progress = 100.0 if success else 0.0
|
||||
message = f"Deployment {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
|
||||
self.TransactionProgress(transaction_id, "deploy", progress, message)
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
|
||||
|
||||
# Delegate to core daemon with progress callback
|
||||
result = await self.core_daemon.deploy_layer(
|
||||
deployment_id,
|
||||
progress_callback=self._progress_callback
|
||||
)
|
||||
|
||||
# Emit property changed for active transactions
|
||||
if result.get('success', False):
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
|
||||
return json.dumps(result)
|
||||
except Exception as e:
|
||||
self.logger.error(f"Deploy failed: {e}")
|
||||
self.TransactionProgress(transaction_id, "deploy", 0.0, f"Deployment failed: {str(e)}")
|
||||
self._progress_callback("deploy", "deploy", 0.0, f"Deployment failed: {str(e)}")
|
||||
return json.dumps({'success': False, 'error': str(e)})
|
||||
|
||||
@method()
|
||||
async def Upgrade(self) -> 's':
|
||||
"""Upgrade the system"""
|
||||
transaction_id = f"upgrade_{int(time.time())}"
|
||||
"""Upgrade the system - delegates to core daemon"""
|
||||
try:
|
||||
self.logger.info("Upgrading system")
|
||||
self.TransactionProgress(transaction_id, "upgrade", 0.0, "Starting system upgrade")
|
||||
result = self.shell_integration.get_system_status_sync()
|
||||
self.logger.info(f"Upgrade result: {result}")
|
||||
success = result.get('success', False)
|
||||
progress = 100.0 if success else 0.0
|
||||
message = f"Upgrade {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
|
||||
self.TransactionProgress(transaction_id, "upgrade", progress, message)
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
|
||||
|
||||
# Delegate to core daemon with progress callback
|
||||
result = await self.core_daemon.upgrade_system(
|
||||
progress_callback=self._progress_callback
|
||||
)
|
||||
|
||||
# Emit property changed for active transactions
|
||||
if result.get('success', False):
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
|
||||
return json.dumps(result)
|
||||
except Exception as e:
|
||||
self.logger.error(f"Upgrade failed: {e}")
|
||||
self.TransactionProgress(transaction_id, "upgrade", 0.0, f"Upgrade failed: {str(e)}")
|
||||
self._progress_callback("upgrade", "upgrade", 0.0, f"Upgrade failed: {str(e)}")
|
||||
return json.dumps({'success': False, 'error': str(e)})
|
||||
|
||||
@method()
|
||||
async def Rollback(self) -> 's':
|
||||
"""Rollback to previous deployment"""
|
||||
transaction_id = f"rollback_{int(time.time())}"
|
||||
"""Rollback to previous deployment - delegates to core daemon"""
|
||||
try:
|
||||
self.logger.info("Rolling back system")
|
||||
self.TransactionProgress(transaction_id, "rollback", 0.0, "Starting system rollback")
|
||||
result = self.shell_integration.rollback_layer_sync()
|
||||
self.logger.info(f"Rollback result: {result}")
|
||||
success = result.get('success', False)
|
||||
progress = 100.0 if success else 0.0
|
||||
message = f"Rollback {'completed' if success else 'failed'}: {result.get('message', 'Unknown error')}"
|
||||
self.TransactionProgress(transaction_id, "rollback", progress, message)
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", transaction_id if success else "")
|
||||
|
||||
# Delegate to core daemon with progress callback
|
||||
result = await self.core_daemon.rollback_system(
|
||||
progress_callback=self._progress_callback
|
||||
)
|
||||
|
||||
# Emit property changed for active transactions
|
||||
if result.get('success', False):
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "ActiveTransaction", result.get('transaction_id', ""))
|
||||
return json.dumps(result)
|
||||
except Exception as e:
|
||||
self.logger.error(f"Rollback failed: {e}")
|
||||
self.TransactionProgress(transaction_id, "rollback", 0.0, f"Rollback failed: {str(e)}")
|
||||
self._progress_callback("rollback", "rollback", 0.0, f"Rollback failed: {str(e)}")
|
||||
return json.dumps({'success': False, 'error': str(e)})
|
||||
|
||||
@method()
|
||||
def CreateComposeFSLayer(self, source_dir: 's', layer_path: 's', digest_store: 's') -> 's':
|
||||
"""Create ComposeFS layer with proper parameters"""
|
||||
try:
|
||||
self.logger.info(f"Creating ComposeFS layer: {source_dir} -> {layer_path}")
|
||||
|
||||
# Use synchronous method to avoid event loop issues
|
||||
result = self.shell_integration.create_composefs_layer_sync(source_dir, layer_path, digest_store)
|
||||
|
||||
return json.dumps(result)
|
||||
except Exception as e:
|
||||
self.logger.error(f"CreateComposeFSLayer failed: {e}")
|
||||
return json.dumps({'success': False, 'error': str(e)})
|
||||
|
||||
# D-Bus Properties
|
||||
# D-Bus Properties - thin wrappers around core daemon properties
|
||||
@dbus_property(access=PropertyAccess.READ)
|
||||
def Booted(self) -> 's':
|
||||
return self._booted
|
||||
"""booted deployment - delegates to core daemon"""
|
||||
try:
|
||||
return self.core_daemon.get_booted_deployment()
|
||||
except Exception as e:
|
||||
self.logger.error(f"Booted property failed: {e}")
|
||||
return ""
|
||||
|
||||
@dbus_property(access=PropertyAccess.READ)
|
||||
def Path(self) -> 's':
|
||||
return self._path
|
||||
"""Get sysroot path - delegates to core daemon"""
|
||||
try:
|
||||
return self.core_daemon.get_sysroot_path()
|
||||
except Exception as e:
|
||||
self.logger.error(f"Path property failed: {e}")
|
||||
return "/"
|
||||
|
||||
@dbus_property(access=PropertyAccess.READWRITE)
|
||||
def ActiveTransaction(self) -> 's':
|
||||
return self._active_transaction
|
||||
"""active transaction - delegates to core daemon"""
|
||||
try:
|
||||
transaction = self.core_daemon.get_active_transaction()
|
||||
return transaction.transaction_id if transaction else ""
|
||||
except Exception as e:
|
||||
self.logger.error(f"ActiveTransaction property failed: {e}")
|
||||
return ""
|
||||
@ActiveTransaction.setter
|
||||
def ActiveTransaction(self, value: 's'):
|
||||
self._active_transaction = value
|
||||
self.logger.warning("ActiveTransaction is read-only from core daemon")
|
||||
|
||||
@dbus_property(access=PropertyAccess.READWRITE)
|
||||
def ActiveTransactionPath(self) -> 's':
|
||||
return self._active_transaction_path
|
||||
"""active transaction path - delegates to core daemon"""
|
||||
try:
|
||||
transaction = self.core_daemon.get_active_transaction()
|
||||
return transaction.path if transaction else ""
|
||||
except Exception as e:
|
||||
self.logger.error(f"ActiveTransactionPath property failed: {e}")
|
||||
return ""
|
||||
@ActiveTransactionPath.setter
|
||||
def ActiveTransactionPath(self, value: 's'):
|
||||
self._active_transaction_path = value
|
||||
self.logger.warning("ActiveTransactionPath is read-only from core daemon")
|
||||
|
||||
@dbus_property(access=PropertyAccess.READ)
|
||||
def Deployments(self) -> 's':
|
||||
return json.dumps(self._deployments)
|
||||
"""Get deployments - delegates to core daemon"""
|
||||
try:
|
||||
deployments = self.core_daemon.get_deployments()
|
||||
return json.dumps(deployments)
|
||||
except Exception as e:
|
||||
self.logger.error(f"Deployments property failed: {e}")
|
||||
return json.dumps({})
|
||||
|
||||
@dbus_property(access=PropertyAccess.READWRITE)
|
||||
def AutomaticUpdatePolicy(self) -> 's':
|
||||
return self._automatic_update_policy
|
||||
"""automatic update policy - delegates to core daemon"""
|
||||
try:
|
||||
return self.core_daemon.get_auto_update_policy()
|
||||
except Exception as e:
|
||||
self.logger.error(f"AutomaticUpdatePolicy property failed: {e}")
|
||||
return "manual"
|
||||
|
||||
@AutomaticUpdatePolicy.setter
|
||||
def AutomaticUpdatePolicy(self, value: 's'):
|
||||
self._automatic_update_policy = value
|
||||
"""automatic update policy - delegates to core daemon"""
|
||||
try:
|
||||
self.core_daemon.set_auto_update_policy(value)
|
||||
self.PropertyChanged("org.debian.aptostree1.Sysroot", "AutomaticUpdatePolicy", value)
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to set AutomaticUpdatePolicy: {e}")
|
||||
|
||||
|
||||
class AptOstreeOSInterface(ServiceInterface):
|
||||
"""OS interface for deployment management"""
|
||||
"""OS interface - thin D-Bus wrapper around core daemon"""
|
||||
|
||||
def __init__(self, daemon_instance):
|
||||
def __init__(self, core_daemon):
|
||||
super().__init__("org.debian.aptostree1.OS")
|
||||
self.daemon = daemon_instance
|
||||
self.shell_integration = ShellIntegration()
|
||||
self.core_daemon = core_daemon
|
||||
self.logger = logging.getLogger('dbus.os')
|
||||
|
||||
@method()
|
||||
def GetBootedDeployment(self) -> 's':
|
||||
"""Get currently booted deployment"""
|
||||
"""Get currently booted deployment - delegates to core daemon"""
|
||||
try:
|
||||
# This would get the booted deployment from sysroot
|
||||
booted = self.daemon.sysroot.get_booted_deployment()
|
||||
booted = self.core_daemon.get_booted_deployment()
|
||||
return json.dumps({'booted_deployment': booted})
|
||||
except Exception as e:
|
||||
self.logger.error(f"GetBootedDeployment failed: {e}")
|
||||
|
|
@ -260,10 +265,9 @@ class AptOstreeOSInterface(ServiceInterface):
|
|||
|
||||
@method()
|
||||
def GetDefaultDeployment(self) -> 's':
|
||||
"""Get default deployment"""
|
||||
"""Get default deployment - delegates to core daemon"""
|
||||
try:
|
||||
# This would get the default deployment from sysroot
|
||||
default = self.daemon.sysroot.get_default_deployment()
|
||||
default = self.core_daemon.get_default_deployment()
|
||||
return json.dumps({'default_deployment': default})
|
||||
except Exception as e:
|
||||
self.logger.error(f"GetDefaultDeployment failed: {e}")
|
||||
|
|
@ -271,41 +275,37 @@ class AptOstreeOSInterface(ServiceInterface):
|
|||
|
||||
@method()
|
||||
def ListDeployments(self) -> 's':
|
||||
"""List all deployments"""
|
||||
"""List all deployments - delegates to core daemon"""
|
||||
try:
|
||||
# This would list all deployments from sysroot
|
||||
deployments = self.daemon.sysroot.get_deployments()
|
||||
deployments = self.core_daemon.get_deployments()
|
||||
return json.dumps({'deployments': deployments})
|
||||
except Exception as e:
|
||||
self.logger.error(f"ListDeployments failed: {e}")
|
||||
return json.dumps({'error': str(e)})
|
||||
|
||||
|
||||
# Legacy main function for backward compatibility - will be removed in Phase 2
|
||||
async def main():
|
||||
"""Main daemon function"""
|
||||
"""gacy main function - kept for backward compatibility during transition"""
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger('daemon')
|
||||
|
||||
logger.info("Starting apt-ostree daemon with dbus-next")
|
||||
logger = logging.getLogger('daemon')
|
||||
logger.info("Starting apt-ostree daemon with dbus-next (legacy mode)")
|
||||
|
||||
# Create D-Bus connection
|
||||
bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
|
||||
|
||||
# Create daemon instance (simplified for testing)
|
||||
# Create mock daemon for legacy compatibility
|
||||
class MockDaemon:
|
||||
def __init__(self):
|
||||
self.sysroot = MockSysroot()
|
||||
|
||||
class MockSysroot:
|
||||
def __init__(self):
|
||||
self.path = "/"
|
||||
|
||||
self.path = "/"
|
||||
def get_booted_deployment(self):
|
||||
return "debian/24.04/x86_64/desktop"
|
||||
|
||||
def get_default_deployment(self):
|
||||
return "debian/24.04/x86_64/desktop"
|
||||
|
||||
def get_deployments(self):
|
||||
return {
|
||||
"debian/24.04/x86_64/desktop": {
|
||||
|
|
@ -322,13 +322,11 @@ async def main():
|
|||
os_interface = AptOstreeOSInterface(daemon)
|
||||
|
||||
bus.export("/org/debian/aptostree1/Sysroot", sysroot_interface)
|
||||
bus.export("/org/debian/aptostree1/OS/default", os_interface) # Use /default path for compatibility
|
||||
bus.export("/org/debian/aptostree1/OS/default", os_interface)
|
||||
|
||||
# Request D-Bus name
|
||||
await bus.request_name("org.debian.aptostree1")
|
||||
|
||||
logger.info("Daemon started successfully")
|
||||
|
||||
await bus.request_name("org.debian.aptostree1")
|
||||
logger.info("Daemon started successfully (legacy mode)")
|
||||
# Keep the daemon running
|
||||
try:
|
||||
await asyncio.Event().wait() # Wait forever
|
||||
|
|
@ -337,5 +335,5 @@ async def main():
|
|||
bus.disconnect()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if __name__ == '__main__':
|
||||
asyncio.run(main())
|
||||
187
src/apt-ostree.py/python/apt_ostree_new.py
Normal file
187
src/apt-ostree.py/python/apt_ostree_new.py
Normal file
|
|
@ -0,0 +1,187 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
apt-ostree Daemon - New dbus-next implementation with proper decoupling
|
||||
Atomic package management system for Debian/Ubuntu inspired by rpm-ostree
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import argparse
|
||||
import logging
|
||||
import signal
|
||||
import sys
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
# Add the current directory to Python path for imports
|
||||
sys.path.insert(0, str(Path(__file__).parent))
|
||||
|
||||
from core.daemon import AptOstreeDaemon
|
||||
from apt_ostree_dbus.interface_simple import AptOstreeSysrootInterface, AptOstreeOSInterface
|
||||
from dbus_next.aio import MessageBus
|
||||
from dbus_next import BusType
|
||||
|
||||
class AptOstreeNewDaemon:
|
||||
"""New daemon using dbus-next implementation with proper decoupling"""
|
||||
|
||||
def __init__(self, pid_file: str = None, config: dict = None):
|
||||
self.pid_file = pid_file
|
||||
self.config = config or {}
|
||||
self.running = False
|
||||
self.logger = logging.getLogger('daemon')
|
||||
|
||||
# Core daemon instance (pure Python, no D-Bus dependencies)
|
||||
self.core_daemon: Optional[AptOstreeDaemon] = None
|
||||
|
||||
# D-Bus components
|
||||
self.bus: Optional[MessageBus] = None
|
||||
self.sysroot_interface: Optional[AptOstreeSysrootInterface] = None
|
||||
self.os_interface: Optional[AptOstreeOSInterface] = None
|
||||
|
||||
def _write_pid_file(self):
|
||||
"""Write PID to file"""
|
||||
if self.pid_file:
|
||||
try:
|
||||
with open(self.pid_file, 'w') as f:
|
||||
f.write(str(os.getpid()))
|
||||
os.chmod(self.pid_file, 0o644)
|
||||
except Exception as e:
|
||||
print(f"Failed to write PID file: {e}", file=sys.stderr)
|
||||
|
||||
def _remove_pid_file(self):
|
||||
"""Remove PID file"""
|
||||
if self.pid_file and os.path.exists(self.pid_file):
|
||||
try:
|
||||
os.unlink(self.pid_file)
|
||||
except Exception as e:
|
||||
print(f"Failed to remove PID file: {e}", file=sys.stderr)
|
||||
|
||||
def _setup_signal_handlers(self):
|
||||
"""Setup signal handlers for graceful shutdown"""
|
||||
def signal_handler(signum, frame):
|
||||
self.logger.info(f"Received signal {signum}, shutting down...")
|
||||
self.running = False
|
||||
|
||||
signal.signal(signal.SIGINT, signal_handler)
|
||||
signal.signal(signal.SIGTERM, signal_handler)
|
||||
|
||||
async def _setup_dbus(self):
|
||||
"""Setup D-Bus connection and interfaces"""
|
||||
try:
|
||||
# Connect to system bus
|
||||
self.bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
|
||||
|
||||
# Create D-Bus interfaces with core daemon instance
|
||||
self.sysroot_interface = AptOstreeSysrootInterface(self.core_daemon)
|
||||
self.os_interface = AptOstreeOSInterface(self.core_daemon)
|
||||
|
||||
# Export interfaces
|
||||
self.bus.export("/org/debian/aptostree1/Sysroot", self.sysroot_interface)
|
||||
self.bus.export("/org/debian/aptostree1/OS/default", self.os_interface)
|
||||
|
||||
# Request D-Bus name
|
||||
await self.bus.request_name("org.debian.aptostree1")
|
||||
|
||||
self.logger.info("D-Bus interfaces exported successfully")
|
||||
return True
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to setup D-Bus: {e}")
|
||||
return False
|
||||
|
||||
async def _cleanup_dbus(self):
|
||||
"""Cleanup D-Bus connection"""
|
||||
if self.bus:
|
||||
try:
|
||||
self.bus.disconnect()
|
||||
self.logger.info("D-Bus connection closed")
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error closing D-Bus connection: {e}")
|
||||
|
||||
async def run(self):
|
||||
"""Run the daemon with proper decoupling"""
|
||||
try:
|
||||
# Write PID file if specified
|
||||
if self.pid_file:
|
||||
self._write_pid_file()
|
||||
|
||||
# Setup signal handlers
|
||||
self._setup_signal_handlers()
|
||||
|
||||
self.logger.info("Starting apt-ostree daemon (dbus-next implementation)")
|
||||
|
||||
# Initialize core daemon (pure Python logic)
|
||||
self.core_daemon = AptOstreeDaemon(self.config, self.logger)
|
||||
if not await self.core_daemon.initialize():
|
||||
self.logger.error("Failed to initialize core daemon")
|
||||
return 1
|
||||
|
||||
# Setup D-Bus interfaces (thin wrapper around core daemon)
|
||||
if not await self._setup_dbus():
|
||||
self.logger.error("Failed to setup D-Bus interfaces")
|
||||
return 1
|
||||
|
||||
self.running = True
|
||||
self.logger.info("Daemon started successfully")
|
||||
|
||||
# Keep the daemon running
|
||||
try:
|
||||
await asyncio.Event().wait() # Wait forever
|
||||
except KeyboardInterrupt:
|
||||
self.logger.info("Received interrupt signal")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Daemon error: {e}")
|
||||
return 1
|
||||
finally:
|
||||
# Cleanup in reverse order
|
||||
await self._cleanup_dbus()
|
||||
if self.core_daemon:
|
||||
await self.core_daemon.shutdown()
|
||||
self._remove_pid_file()
|
||||
self.running = False
|
||||
|
||||
return 0
|
||||
|
||||
def parse_arguments():
|
||||
"""Parse command line arguments"""
|
||||
parser = argparse.ArgumentParser(description='apt-ostree System Management Daemon (dbus-next)')
|
||||
parser.add_argument('--daemon', action='store_true',
|
||||
help='Run as daemon (default behavior)')
|
||||
parser.add_argument('--pid-file', type=str,
|
||||
help='Write PID to specified file')
|
||||
parser.add_argument('--foreground', action='store_true',
|
||||
help='Run in foreground (for debugging)')
|
||||
parser.add_argument('--config', type=str,
|
||||
help='Path to configuration file')
|
||||
return parser.parse_args()
|
||||
|
||||
def main():
|
||||
"""Main entry point"""
|
||||
args = parse_arguments()
|
||||
|
||||
# Check if running as root (required for system operations)
|
||||
if os.geteuid() != 0:
|
||||
print("apt-ostree daemon must be run as root", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
# Setup basic logging
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
||||
)
|
||||
|
||||
# Load configuration (placeholder for now)
|
||||
config = {
|
||||
'daemon.auto_update_policy': 'none',
|
||||
'daemon.idle_exit_timeout': 0,
|
||||
'sysroot.path': '/',
|
||||
'sysroot.test_mode': True
|
||||
}
|
||||
|
||||
daemon = AptOstreeNewDaemon(pid_file=args.pid_file, config=config)
|
||||
|
||||
# Run the daemon
|
||||
return asyncio.run(daemon.run())
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Loading…
Add table
Add a link
Reference in a new issue