dtSpark 1.0.4__py3-none-any.whl

dtSpark/daemon/daemon_manager.py

@@ -0,0 +1,289 @@
+"""
+Daemon lifecycle manager.
+
+Provides CLI commands for starting, stopping, and checking daemon status.
+
+
+"""
+
+import os
+import sys
+import time
+import signal
+import logging
+import subprocess
+from typing import List, Optional
+
+from .pid_file import PIDFile
+
+logger = logging.getLogger(__name__)
+
+
+class DaemonManager:
+    """
+    Manages daemon lifecycle via CLI commands.
+
+    Supports: start, stop, status, restart
+    Works across Windows and Unix platforms.
+    """
+
+    def __init__(self, pid_file_path: str):
+        """
+        Initialise the daemon manager.
+
+        Args:
+            pid_file_path: Path to the PID file
+        """
+        self.pid_file = PIDFile(pid_file_path)
+
+    def start(self, args: Optional[List[str]] = None) -> int:
+        """
+        Start the daemon process.
+
+        Args:
+            args: Additional arguments to pass to daemon
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        # Check if already running
+        if self.pid_file.is_running():
+            pid = self.pid_file.read_pid()
+            print(f"Daemon already running (PID: {pid})")
+            return 1
+
+        # Check for --foreground flag
+        foreground = False
+        if args and '--foreground' in args:
+            foreground = True
+            args = [a for a in args if a != '--foreground']
+
+        if foreground:
+            # Run in foreground (for debugging)
+            return self._run_foreground(args)
+        else:
+            # Start in background
+            return self._start_background(args)
+
+    def _run_foreground(self, args: Optional[List[str]] = None) -> int:
+        """Run daemon in foreground mode."""
+        print("Starting daemon in foreground mode...")
+        print("Press Ctrl+C to stop")
+        print("")
+
+        # Import and run directly
+        from .daemon_app import DaemonApplication
+        app = DaemonApplication()
+
+        # Clean up sys.argv - AbstractApp expects only arguments it recognises
+        # Remove 'daemon', 'start', '--foreground' and keep only daemon-specific args
+        clean_args = ['dtSpark-daemon']
+        if args:
+            clean_args.extend(args)
+        sys.argv = clean_args
+
+        try:
+            app.run()
+            return 0
+        except KeyboardInterrupt:
+            print("\nDaemon stopped by user")
+            return 0
+        except Exception as e:
+            print(f"Daemon error: {e}")
+            import traceback
+            traceback.print_exc()
+            return 1
+
+    def _start_background(self, args: Optional[List[str]] = None) -> int:
+        """Start daemon as a background process."""
+        # Build command to run daemon
+        daemon_cmd = [
+            sys.executable,
+            '-m', 'dtSpark.daemon',
+            '--run'
+        ]
+        if args:
+            daemon_cmd.extend(args)
+
+        # Log file for daemon output (helps with debugging startup issues)
+        daemon_log_path = str(self.pid_file.path) + '.log'
+
+        try:
+            # Open log file for daemon output
+            log_file = open(daemon_log_path, 'w')
+
+            if sys.platform == 'win32':
+                # Windows: use CREATE_NEW_PROCESS_GROUP and DETACHED_PROCESS
+                process = subprocess.Popen(
+                    daemon_cmd,
+                    creationflags=(
+                        subprocess.CREATE_NEW_PROCESS_GROUP |
+                        subprocess.DETACHED_PROCESS
+                    ),
+                    stdout=log_file,
+                    stderr=log_file,
+                    stdin=subprocess.DEVNULL,
+                )
+            else:
+                # Unix: start new session
+                process = subprocess.Popen(
+                    daemon_cmd,
+                    start_new_session=True,
+                    stdout=log_file,
+                    stderr=log_file,
+                    stdin=subprocess.DEVNULL,
+                )
+
+            # Wait for daemon to start and write PID file
+            # Poll with increasing intervals up to a maximum wait time
+            max_wait = 10  # seconds
+            waited = 0
+            check_interval = 0.5
+
+            while waited < max_wait:
+                time.sleep(check_interval)
+                waited += check_interval
+
+                if self.pid_file.is_running():
+                    pid = self.pid_file.read_pid()
+                    print(f"Daemon started (PID: {pid})")
+                    print(f"Daemon log: {daemon_log_path}")
+                    return 0
+
+            # Daemon didn't start within timeout
+            print("Daemon failed to start. Check daemon log for details:")
+            print(f"  {daemon_log_path}")
+            # Try to show recent log content
+            try:
+                log_file.close()
+                with open(daemon_log_path, 'r') as f:
+                    content = f.read()
+                    if content:
+                        print("\nDaemon output:")
+                        print(content[-2000:] if len(content) > 2000 else content)
+            except Exception:
+                pass
+            return 1
+
+        except Exception as e:
+            print(f"Failed to start daemon: {e}")
+            logger.error(f"Failed to start daemon: {e}", exc_info=True)
+            return 1
+
+    def stop(self, timeout: int = 30) -> int:
+        """
+        Stop the daemon gracefully.
+
+        Args:
+            timeout: Seconds to wait for graceful shutdown
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        pid = self.pid_file.read_pid()
+        if not pid or not self.pid_file.is_running():
+            print("Daemon is not running")
+            # Clean up stale PID file if exists
+            self.pid_file.remove()
+            return 0
+
+        print(f"Stopping daemon (PID: {pid})...")
+
+        # Send termination signal
+        try:
+            if sys.platform == 'win32':
+                # Windows: Create a stop signal file that the daemon checks
+                # This is more reliable than signals across console sessions
+                stop_file = str(self.pid_file.path) + '.stop'
+                try:
+                    with open(stop_file, 'w') as f:
+                        f.write(str(pid))
+                    print("Stop signal sent")
+                except Exception as e:
+                    print(f"Failed to create stop signal: {e}")
+                    # Fall back to taskkill /F if signal file fails
+                    subprocess.run(['taskkill', '/F', '/PID', str(pid)], capture_output=True)
+            else:
+                # Unix: SIGTERM for graceful shutdown
+                os.kill(pid, signal.SIGTERM)
+        except ProcessLookupError:
+            print("Daemon process not found")
+            self.pid_file.remove()
+            return 0
+        except PermissionError:
+            print("Permission denied to stop daemon")
+            return 1
+        except Exception as e:
+            print(f"Error stopping daemon: {e}")
+            return 1
+
+        # Wait for graceful shutdown
+        for i in range(timeout):
+            if not self.pid_file.is_running():
+                print("Daemon stopped")
+                self._cleanup_stop_file()
+                return 0
+            time.sleep(1)
+            if (i + 1) % 5 == 0:
+                print(f"Waiting for shutdown... ({i + 1}/{timeout}s)")
+
+        # Process didn't stop gracefully - clean up and report
+        self._cleanup_stop_file()
+        print(f"Daemon did not stop within {timeout} seconds")
+        if sys.platform == 'win32':
+            print("Forcing termination...")
+            subprocess.run(['taskkill', '/F', '/PID', str(pid)], capture_output=True)
+            time.sleep(1)
+            if not self.pid_file.is_running():
+                print("Daemon terminated")
+                return 0
+        print("Consider using 'kill -9' manually if needed")
+        return 1
+
+    def _cleanup_stop_file(self):
+        """Remove the stop signal file if it exists."""
+        stop_file = str(self.pid_file.path) + '.stop'
+        try:
+            if os.path.exists(stop_file):
+                os.remove(stop_file)
+        except Exception:
+            pass
+
+    def status(self) -> int:
+        """
+        Check daemon status.
+
+        Returns:
+            0 if running, 1 if not running
+        """
+        pid = self.pid_file.read_pid()
+
+        if pid and self.pid_file.is_running():
+            print(f"Daemon is running (PID: {pid})")
+            return 0
+        else:
+            print("Daemon is not running")
+            # Clean up stale PID file if exists
+            if pid:
+                self.pid_file.remove()
+            return 1
+
+    def restart(self, args: Optional[List[str]] = None) -> int:
+        """
+        Restart the daemon.
+
+        Args:
+            args: Additional arguments to pass to daemon
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        # Stop if running
+        if self.pid_file.is_running():
+            stop_result = self.stop()
+            if stop_result != 0:
+                return stop_result
+            time.sleep(2)
+
+        # Start daemon
+        return self.start(args)

dtSpark/daemon/execution_coordinator.py

@@ -0,0 +1,194 @@
+"""
+Execution coordinator for preventing duplicate action runs.
+
+Provides functionality for:
+- Acquiring execution locks on actions
+- Preventing concurrent execution by daemon and UI
+- Cleaning up stale locks from crashed processes
+
+
+"""
+
+import logging
+from datetime import datetime
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ActionLockedError(Exception):
+    """Raised when an action is locked by another process."""
+
+    def __init__(self, action_id: int, locked_by: str, message: str = None):
+        self.action_id = action_id
+        self.locked_by = locked_by
+        self.message = message or f"Action {action_id} is locked by {locked_by}"
+        super().__init__(self.message)
+
+
+class ExecutionCoordinator:
+    """
+    Coordinates action execution to prevent conflicts.
+
+    Uses database locking mechanism to prevent duplicate execution
+    when both daemon and UI try to run the same action.
+    """
+
+    def __init__(
+        self,
+        database,
+        process_id: str,
+        user_guid: str,
+        lock_timeout_seconds: int = 300
+    ):
+        """
+        Initialise the execution coordinator.
+
+        Args:
+            database: Database instance with autonomous_actions methods
+            process_id: Unique identifier for this process (daemon_id or session_id)
+            user_guid: User GUID for database operations
+            lock_timeout_seconds: Seconds after which a lock is considered stale
+        """
+        self.database = database
+        self.process_id = process_id
+        self.user_guid = user_guid
+        self.lock_timeout_seconds = lock_timeout_seconds
+
+    def try_acquire_lock(self, action_id: int) -> bool:
+        """
+        Attempt to acquire an execution lock for an action.
+
+        Args:
+            action_id: ID of the action to lock
+
+        Returns:
+            True if lock acquired, False if another process holds it
+        """
+        # First, clear any stale locks
+        self._clear_stale_locks()
+
+        # Try to acquire lock
+        from dtSpark.database.autonomous_actions import try_lock_action
+        success = try_lock_action(
+            conn=self.database.conn,
+            action_id=action_id,
+            locked_by=self.process_id,
+            user_guid=self.user_guid
+        )
+
+        if success:
+            logger.debug(f"Acquired lock on action {action_id}")
+        else:
+            logger.debug(f"Failed to acquire lock on action {action_id}")
+
+        return success
+
+    def release_lock(self, action_id: int) -> bool:
+        """
+        Release an execution lock for an action.
+
+        Args:
+            action_id: ID of the action to unlock
+
+        Returns:
+            True if unlocked successfully, False otherwise
+        """
+        from dtSpark.database.autonomous_actions import unlock_action
+        success = unlock_action(
+            conn=self.database.conn,
+            action_id=action_id,
+            locked_by=self.process_id,
+            user_guid=self.user_guid
+        )
+
+        if success:
+            logger.debug(f"Released lock on action {action_id}")
+        else:
+            logger.warning(f"Failed to release lock on action {action_id}")
+
+        return success
+
+    def is_action_locked(self, action_id: int) -> bool:
+        """
+        Check if an action is currently locked by another process.
+
+        Args:
+            action_id: ID of the action to check
+
+        Returns:
+            True if locked by another process, False otherwise
+        """
+        from dtSpark.database.autonomous_actions import get_action_lock_info
+        lock_info = get_action_lock_info(
+            conn=self.database.conn,
+            action_id=action_id,
+            user_guid=self.user_guid
+        )
+
+        if not lock_info or not lock_info.get('locked_by'):
+            return False
+
+        # Not locked by another process if we hold the lock
+        if lock_info['locked_by'] == self.process_id:
+            return False
+
+        return True
+
+    def get_lock_holder(self, action_id: int) -> Optional[str]:
+        """
+        Get the identifier of the process holding the lock.
+
+        Args:
+            action_id: ID of the action
+
+        Returns:
+            Process identifier if locked, None otherwise
+        """
+        from dtSpark.database.autonomous_actions import get_action_lock_info
+        lock_info = get_action_lock_info(
+            conn=self.database.conn,
+            action_id=action_id,
+            user_guid=self.user_guid
+        )
+
+        if lock_info:
+            return lock_info.get('locked_by')
+        return None
+
+    def _clear_stale_locks(self):
+        """Clear locks that are older than the timeout."""
+        from dtSpark.database.autonomous_actions import clear_stale_locks
+        clear_stale_locks(
+            conn=self.database.conn,
+            lock_timeout_seconds=self.lock_timeout_seconds,
+            user_guid=self.user_guid
+        )
+
+    def execute_with_lock(self, action_id: int, execute_func, *args, **kwargs):
+        """
+        Execute a function while holding an action lock.
+
+        Args:
+            action_id: ID of the action to lock
+            execute_func: Function to execute
+            *args, **kwargs: Arguments to pass to the function
+
+        Returns:
+            Result of execute_func
+
+        Raises:
+            ActionLockedError: If action is locked by another process
+        """
+        if not self.try_acquire_lock(action_id):
+            lock_holder = self.get_lock_holder(action_id)
+            raise ActionLockedError(
+                action_id=action_id,
+                locked_by=lock_holder or "unknown",
+                message=f"Action {action_id} is currently being executed by another process"
+            )
+
+        try:
+            return execute_func(*args, **kwargs)
+        finally:
+            self.release_lock(action_id)

dtSpark/daemon/pid_file.py

@@ -0,0 +1,169 @@
+"""
+PID file management for daemon process.
+
+Provides functionality for:
+- Writing and reading PID files
+- Checking if a process is running
+- Preventing multiple daemon instances
+
+
+"""
+
+import os
+import sys
+import logging
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class PIDFile:
+    """
+    Manages PID file for daemon process.
+
+    Prevents multiple daemon instances and enables status checking.
+    Works across Windows and Unix platforms.
+    """
+
+    def __init__(self, path: str):
+        """
+        Initialise the PID file manager.
+
+        Args:
+            path: Path to the PID file
+        """
+        self.path = Path(path)
+
+    def write_pid(self, pid: Optional[int] = None):
+        """
+        Write current process PID to file.
+
+        Args:
+            pid: Process ID to write (default: current process)
+        """
+        if pid is None:
+            pid = os.getpid()
+
+        # Ensure parent directory exists
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+        self.path.write_text(str(pid))
+        logger.info(f"PID file written: {self.path} (PID: {pid})")
+
+    def read_pid(self) -> Optional[int]:
+        """
+        Read PID from file.
+
+        Returns:
+            Process ID if file exists and is valid, None otherwise
+        """
+        try:
+            return int(self.path.read_text().strip())
+        except FileNotFoundError:
+            return None
+        except ValueError:
+            logger.warning(f"Invalid PID file contents: {self.path}")
+            return None
+
+    def remove(self):
+        """Remove PID file."""
+        try:
+            self.path.unlink()
+            logger.info(f"PID file removed: {self.path}")
+        except FileNotFoundError:
+            pass
+
+    def is_running(self) -> bool:
+        """
+        Check if process with stored PID is running.
+
+        Returns:
+            True if process is running, False otherwise
+        """
+        pid = self.read_pid()
+        if not pid:
+            return False
+
+        return self._is_process_running(pid)
+
+    def _is_process_running(self, pid: int) -> bool:
+        """
+        Check if a process with the given PID is running.
+
+        Args:
+            pid: Process ID to check
+
+        Returns:
+            True if process is running, False otherwise
+        """
+        if sys.platform == 'win32':
+            return self._is_process_running_windows(pid)
+        else:
+            return self._is_process_running_unix(pid)
+
+    def _is_process_running_windows(self, pid: int) -> bool:
+        """Check if process is running on Windows."""
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+
+            # PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+            handle = kernel32.OpenProcess(0x1000, False, pid)
+            if handle:
+                kernel32.CloseHandle(handle)
+                return True
+            return False
+        except Exception as e:
+            logger.debug(f"Error checking process on Windows: {e}")
+            return False
+
+    def _is_process_running_unix(self, pid: int) -> bool:
+        """Check if process is running on Unix."""
+        try:
+            # Signal 0 doesn't actually send a signal, just checks if process exists
+            os.kill(pid, 0)
+            return True
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            # Process exists but we don't have permission to signal it
+            return True
+        except OSError:
+            return False
+
+    def acquire(self) -> bool:
+        """
+        Attempt to acquire the PID file (atomic operation).
+
+        Returns:
+            True if acquired successfully, False if daemon already running
+        """
+        if self.is_running():
+            existing_pid = self.read_pid()
+            logger.warning(f"Daemon already running with PID {existing_pid}")
+            return False
+
+        # Clean up stale PID file if process is not running
+        if self.path.exists():
+            logger.info("Removing stale PID file")
+            self.remove()
+
+        self.write_pid()
+        return True
+
+    def release(self):
+        """
+        Release the PID file.
+
+        Only removes if the current process holds it.
+        """
+        current_pid = os.getpid()
+        stored_pid = self.read_pid()
+
+        if stored_pid == current_pid:
+            self.remove()
+        else:
+            logger.warning(
+                f"PID file contains different PID (stored: {stored_pid}, current: {current_pid})"
+            )