mcp-ticketer 0.1.1__py3-none-any.whl

mcp_ticketer/queue/manager.py

@@ -0,0 +1,261 @@
+"""Worker manager with file-based locking for single instance."""
+
+import os
+import psutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional, Dict, Any
+import fcntl
+import logging
+
+from .queue import Queue
+from .worker import Worker
+
+logger = logging.getLogger(__name__)
+
+
+class WorkerManager:
+    """Manages worker process with file-based locking."""
+
+    def __init__(self):
+        """Initialize worker manager."""
+        self.lock_file = Path.home() / ".mcp-ticketer" / "worker.lock"
+        self.pid_file = Path.home() / ".mcp-ticketer" / "worker.pid"
+        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
+        self.queue = Queue()
+
+    def _acquire_lock(self) -> bool:
+        """Acquire exclusive lock for worker.
+
+        Returns:
+            True if lock acquired, False otherwise
+        """
+        try:
+            # Create lock file if it doesn't exist
+            if not self.lock_file.exists():
+                self.lock_file.touch()
+
+            # Try to acquire exclusive lock
+            self.lock_fd = open(self.lock_file, "w")
+            fcntl.lockf(self.lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+            # Write PID to lock file
+            self.lock_fd.write(str(os.getpid()))
+            self.lock_fd.flush()
+
+            return True
+        except IOError:
+            # Lock already held
+            return False
+
+    def _release_lock(self):
+        """Release worker lock."""
+        if hasattr(self, 'lock_fd'):
+            fcntl.lockf(self.lock_fd, fcntl.LOCK_UN)
+            self.lock_fd.close()
+
+        # Clean up PID file
+        if self.pid_file.exists():
+            self.pid_file.unlink()
+
+    def start_if_needed(self) -> bool:
+        """Start worker if not already running and there are pending items.
+
+        Returns:
+            True if worker started or already running, False otherwise
+        """
+        # Check if worker is already running
+        if self.is_running():
+            logger.debug("Worker already running")
+            return True
+
+        # Check if there are pending items
+        if self.queue.get_pending_count() == 0:
+            logger.debug("No pending items, worker not needed")
+            return False
+
+        # Try to start worker
+        return self.start()
+
+    def start(self) -> bool:
+        """Start the worker process.
+
+        Returns:
+            True if started successfully, False otherwise
+        """
+        # Check if already running
+        if self.is_running():
+            logger.info("Worker is already running")
+            return True
+
+        # Try to acquire lock
+        if not self._acquire_lock():
+            logger.warning("Could not acquire lock - another worker may be running")
+            return False
+
+        try:
+            # Start worker in subprocess
+            cmd = [
+                sys.executable,
+                "-m",
+                "mcp_ticketer.queue.run_worker"
+            ]
+
+            # Start as background process
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True
+            )
+
+            # Save PID
+            self.pid_file.write_text(str(process.pid))
+
+            # Give the process a moment to start
+            import time
+            time.sleep(0.5)
+
+            # Verify process is running
+            if not psutil.pid_exists(process.pid):
+                logger.error("Worker process died immediately after starting")
+                self._cleanup()
+                return False
+
+            logger.info(f"Started worker process with PID {process.pid}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to start worker: {e}")
+            self._release_lock()
+            return False
+
+    def stop(self) -> bool:
+        """Stop the worker process.
+
+        Returns:
+            True if stopped successfully, False otherwise
+        """
+        pid = self._get_pid()
+        if not pid:
+            logger.info("No worker process to stop")
+            return True
+
+        try:
+            # Check if process exists
+            if not psutil.pid_exists(pid):
+                logger.info("Worker process not found, cleaning up")
+                self._cleanup()
+                return True
+
+            # Send SIGTERM
+            process = psutil.Process(pid)
+            process.terminate()
+
+            # Wait for graceful shutdown
+            gone, alive = psutil.wait_procs([process], timeout=10)
+
+            if gone:
+                logger.info(f"Worker process {pid} terminated gracefully")
+            else:
+                # Force kill if still alive
+                for p in alive:
+                    logger.warning(f"Force killing worker process {p.pid}")
+                    p.kill()
+
+            self._cleanup()
+            return True
+
+        except Exception as e:
+            logger.error(f"Error stopping worker: {e}")
+            return False
+
+    def restart(self) -> bool:
+        """Restart the worker process.
+
+        Returns:
+            True if restarted successfully, False otherwise
+        """
+        logger.info("Restarting worker...")
+        self.stop()
+        time.sleep(1)  # Brief pause between stop and start
+        return self.start()
+
+    def is_running(self) -> bool:
+        """Check if worker is currently running.
+
+        Returns:
+            True if running, False otherwise
+        """
+        pid = self._get_pid()
+        if not pid:
+            return False
+
+        try:
+            # Check if process exists and is actually our worker
+            if psutil.pid_exists(pid):
+                process = psutil.Process(pid)
+                cmdline = " ".join(process.cmdline())
+                return "run_worker" in cmdline or "mcp_ticketer.queue" in cmdline
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+
+        return False
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get detailed worker status.
+
+        Returns:
+            Status information
+        """
+        is_running = self.is_running()
+        pid = self._get_pid() if is_running else None
+
+        status = {
+            "running": is_running,
+            "pid": pid
+        }
+
+        # Add process info if running
+        if is_running and pid:
+            try:
+                process = psutil.Process(pid)
+                status.update({
+                    "cpu_percent": process.cpu_percent(),
+                    "memory_mb": process.memory_info().rss / 1024 / 1024,
+                    "create_time": process.create_time(),
+                    "status": process.status()
+                })
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+
+        # Add queue stats
+        queue_stats = self.queue.get_stats()
+        status["queue"] = queue_stats
+
+        return status
+
+    def _get_pid(self) -> Optional[int]:
+        """Get worker PID from file.
+
+        Returns:
+            Process ID or None if not found
+        """
+        if not self.pid_file.exists():
+            return None
+
+        try:
+            pid_text = self.pid_file.read_text().strip()
+            return int(pid_text)
+        except (ValueError, IOError):
+            return None
+
+    def _cleanup(self):
+        """Clean up lock and PID files."""
+        self._release_lock()
+        if self.pid_file.exists():
+            self.pid_file.unlink()
+        if self.lock_file.exists():
+            self.lock_file.unlink()

mcp_ticketer/queue/queue.py

@@ -0,0 +1,357 @@
+"""SQLite-based queue system for async ticket operations."""
+
+import sqlite3
+import json
+import threading
+from datetime import datetime, timedelta
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, asdict
+import uuid
+
+
+class QueueStatus(str, Enum):
+    """Queue item status values."""
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass
+class QueueItem:
+    """Represents a queued operation."""
+    id: str
+    ticket_data: Dict[str, Any]
+    adapter: str
+    operation: str
+    status: QueueStatus
+    created_at: datetime
+    processed_at: Optional[datetime] = None
+    error_message: Optional[str] = None
+    retry_count: int = 0
+    result: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for storage."""
+        data = asdict(self)
+        data['created_at'] = self.created_at.isoformat()
+        if self.processed_at:
+            data['processed_at'] = self.processed_at.isoformat()
+        return data
+
+    @classmethod
+    def from_row(cls, row: tuple) -> "QueueItem":
+        """Create from database row."""
+        return cls(
+            id=row[0],
+            ticket_data=json.loads(row[1]),
+            adapter=row[2],
+            operation=row[3],
+            status=QueueStatus(row[4]),
+            created_at=datetime.fromisoformat(row[5]),
+            processed_at=datetime.fromisoformat(row[6]) if row[6] else None,
+            error_message=row[7],
+            retry_count=row[8],
+            result=json.loads(row[9]) if row[9] else None
+        )
+
+
+class Queue:
+    """Thread-safe SQLite queue for ticket operations."""
+
+    def __init__(self, db_path: Optional[Path] = None):
+        """Initialize queue with database connection.
+
+        Args:
+            db_path: Path to SQLite database. Defaults to ~/.mcp-ticketer/queue.db
+        """
+        if db_path is None:
+            db_dir = Path.home() / ".mcp-ticketer"
+            db_dir.mkdir(parents=True, exist_ok=True)
+            db_path = db_dir / "queue.db"
+
+        self.db_path = str(db_path)
+        self._lock = threading.Lock()
+        self._init_database()
+
+    def _init_database(self):
+        """Initialize database schema."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute('''
+                CREATE TABLE IF NOT EXISTS queue (
+                    id TEXT PRIMARY KEY,
+                    ticket_data TEXT NOT NULL,
+                    adapter TEXT NOT NULL,
+                    operation TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    processed_at TEXT,
+                    error_message TEXT,
+                    retry_count INTEGER DEFAULT 0,
+                    result TEXT,
+                    CHECK (status IN ('pending', 'processing', 'completed', 'failed'))
+                )
+            ''')
+
+            # Create indices for efficient queries
+            conn.execute('''
+                CREATE INDEX IF NOT EXISTS idx_queue_status
+                ON queue(status)
+            ''')
+            conn.execute('''
+                CREATE INDEX IF NOT EXISTS idx_queue_created
+                ON queue(created_at)
+            ''')
+            conn.execute('''
+                CREATE INDEX IF NOT EXISTS idx_queue_adapter
+                ON queue(adapter)
+            ''')
+
+            conn.commit()
+
+    def add(self,
+            ticket_data: Dict[str, Any],
+            adapter: str,
+            operation: str) -> str:
+        """Add item to queue.
+
+        Args:
+            ticket_data: The ticket data for the operation
+            adapter: Name of the adapter to use
+            operation: Operation to perform (create, update, delete, etc.)
+
+        Returns:
+            Queue ID for tracking
+        """
+        queue_id = f"Q-{uuid.uuid4().hex[:8].upper()}"
+
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute('''
+                    INSERT INTO queue (
+                        id, ticket_data, adapter, operation,
+                        status, created_at, retry_count
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                ''', (
+                    queue_id,
+                    json.dumps(ticket_data),
+                    adapter,
+                    operation,
+                    QueueStatus.PENDING.value,
+                    datetime.now().isoformat(),
+                    0
+                ))
+                conn.commit()
+
+        return queue_id
+
+    def get_next_pending(self) -> Optional[QueueItem]:
+        """Get next pending item from queue.
+
+        Returns:
+            Next pending QueueItem or None if queue is empty
+        """
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                # Get next pending item ordered by creation time
+                cursor = conn.execute('''
+                    SELECT * FROM queue
+                    WHERE status = ?
+                    ORDER BY created_at
+                    LIMIT 1
+                ''', (QueueStatus.PENDING.value,))
+
+                row = cursor.fetchone()
+                if row:
+                    # Mark as processing
+                    conn.execute('''
+                        UPDATE queue
+                        SET status = ?
+                        WHERE id = ?
+                    ''', (QueueStatus.PROCESSING.value, row[0]))
+                    conn.commit()
+
+                    return QueueItem.from_row(row)
+
+        return None
+
+    def update_status(self,
+                     queue_id: str,
+                     status: QueueStatus,
+                     error_message: Optional[str] = None,
+                     result: Optional[Dict[str, Any]] = None):
+        """Update queue item status.
+
+        Args:
+            queue_id: Queue item ID
+            status: New status
+            error_message: Error message if failed
+            result: Result data if completed
+        """
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                processed_at = datetime.now().isoformat() if status in [
+                    QueueStatus.COMPLETED, QueueStatus.FAILED
+                ] else None
+
+                conn.execute('''
+                    UPDATE queue
+                    SET status = ?, processed_at = ?,
+                        error_message = ?, result = ?
+                    WHERE id = ?
+                ''', (
+                    status.value,
+                    processed_at,
+                    error_message,
+                    json.dumps(result) if result else None,
+                    queue_id
+                ))
+                conn.commit()
+
+    def increment_retry(self, queue_id: str) -> int:
+        """Increment retry count for item.
+
+        Args:
+            queue_id: Queue item ID
+
+        Returns:
+            New retry count
+        """
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.execute('''
+                    UPDATE queue
+                    SET retry_count = retry_count + 1,
+                        status = ?
+                    WHERE id = ?
+                    RETURNING retry_count
+                ''', (QueueStatus.PENDING.value, queue_id))
+
+                result = cursor.fetchone()
+                conn.commit()
+                return result[0] if result else 0
+
+    def get_item(self, queue_id: str) -> Optional[QueueItem]:
+        """Get specific queue item by ID.
+
+        Args:
+            queue_id: Queue item ID
+
+        Returns:
+            QueueItem or None if not found
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute('''
+                SELECT * FROM queue WHERE id = ?
+            ''', (queue_id,))
+
+            row = cursor.fetchone()
+            return QueueItem.from_row(row) if row else None
+
+    def list_items(self,
+                   status: Optional[QueueStatus] = None,
+                   limit: int = 50) -> List[QueueItem]:
+        """List queue items.
+
+        Args:
+            status: Filter by status (optional)
+            limit: Maximum items to return
+
+        Returns:
+            List of QueueItems
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            if status:
+                cursor = conn.execute('''
+                    SELECT * FROM queue
+                    WHERE status = ?
+                    ORDER BY created_at DESC
+                    LIMIT ?
+                ''', (status.value, limit))
+            else:
+                cursor = conn.execute('''
+                    SELECT * FROM queue
+                    ORDER BY created_at DESC
+                    LIMIT ?
+                ''', (limit,))
+
+            return [QueueItem.from_row(row) for row in cursor.fetchall()]
+
+    def get_pending_count(self) -> int:
+        """Get count of pending items.
+
+        Returns:
+            Number of pending items
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute('''
+                SELECT COUNT(*) FROM queue
+                WHERE status = ?
+            ''', (QueueStatus.PENDING.value,))
+
+            return cursor.fetchone()[0]
+
+    def cleanup_old(self, days: int = 7):
+        """Clean up old completed/failed items.
+
+        Args:
+            days: Delete items older than this many days
+        """
+        cutoff_date = (datetime.now() - timedelta(days=days)).isoformat()
+
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute('''
+                    DELETE FROM queue
+                    WHERE status IN (?, ?)
+                    AND processed_at < ?
+                ''', (
+                    QueueStatus.COMPLETED.value,
+                    QueueStatus.FAILED.value,
+                    cutoff_date
+                ))
+                conn.commit()
+
+    def reset_stuck_items(self, timeout_minutes: int = 30):
+        """Reset items stuck in processing state.
+
+        Args:
+            timeout_minutes: Consider items stuck after this many minutes
+        """
+        cutoff_time = (datetime.now() - timedelta(minutes=timeout_minutes)).isoformat()
+
+        with self._lock:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute('''
+                    UPDATE queue
+                    SET status = ?, error_message = ?
+                    WHERE status = ?
+                    AND created_at < ?
+                ''', (
+                    QueueStatus.PENDING.value,
+                    "Reset from stuck processing state",
+                    QueueStatus.PROCESSING.value,
+                    cutoff_time
+                ))
+                conn.commit()
+
+    def get_stats(self) -> Dict[str, int]:
+        """Get queue statistics.
+
+        Returns:
+            Dictionary with counts by status
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute('''
+                SELECT status, COUNT(*)
+                FROM queue
+                GROUP BY status
+            ''')
+
+            stats = {status.value: 0 for status in QueueStatus}
+            for status, count in cursor.fetchall():
+                stats[status] = count
+
+            return stats

mcp_ticketer/queue/run_worker.py

@@ -0,0 +1,38 @@
+"""Standalone worker runner module."""
+
+import logging
+import sys
+
+from .queue import Queue
+from .worker import Worker
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """Run the worker process."""
+    logger.info("Starting standalone worker process")
+
+    try:
+        # Create queue and worker
+        queue = Queue()
+        worker = Worker(queue)
+
+        # Run worker (blocking)
+        worker.start(daemon=False)
+
+    except KeyboardInterrupt:
+        logger.info("Worker interrupted by user")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Worker failed: {e}", exc_info=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()