mcp-proxy-adapter 6.9.27__py3-none-any.whl → 6.9.29__py3-none-any.whl

mcp_proxy_adapter/examples/validate_generator_compatibility_simple.py

@@ -10,7 +10,6 @@ email: vasilyvz@gmail.com
 import json
 import sys
 from pathlib import Path
-from typing import Dict, Any, List
 
 # Add the project root to the path
 project_root = Path(__file__).parent.parent.parent
@@ -20,196 +19,10 @@ from mcp_proxy_adapter.core.config_validator import ConfigValidator
 from mcp_proxy_adapter.examples.config_builder import generate_complete_config
 
 
-def test_generator_validator_structure():
-    """Test that generated configs have the correct structure."""
-    print("🔍 Testing Generator-Validator Structure Compatibility")
-    print("=" * 60)
-    
-    # Test basic HTTP configuration
-    print("\n📋 Testing: HTTP Basic Configuration")
-    print("-" * 40)
-    
-    try:
-        # Generate configuration
-        print("  🔧 Generating configuration...")
-        config = generate_complete_config(host="localhost", port=8080)
-        
-        # Check required sections exist
-        required_sections = ["server", "logging", "commands", "debug", "ssl", "security", "roles", "proxy_registration"]
-        missing_sections = []
-        
-        for section in required_sections:
-            if section not in config:
-                missing_sections.append(section)
-        
-        if missing_sections:
-            print(f"  ❌ FAIL - Missing sections: {missing_sections}")
-            return False
-        
-        # Check server section
-        server_required = ["host", "port", "protocol", "debug", "log_level"]
-        server_missing = [key for key in server_required if key not in config["server"]]
-        
-        if server_missing:
-            print(f"  ❌ FAIL - Server section missing keys: {server_missing}")
-            return False
-        
-        # Check protocol is HTTP
-        if config["server"]["protocol"] != "http":
-            print(f"  ❌ FAIL - Expected protocol 'http', got '{config['server']['protocol']}'")
-            return False
-        
-        # Check SSL is disabled
-        if config["ssl"]["enabled"] != False:
-            print(f"  ❌ FAIL - Expected SSL disabled, got {config['ssl']['enabled']}")
-            return False
-        
-        # Check security is disabled
-        if config["security"]["enabled"] != False:
-            print(f"  ❌ FAIL - Expected security disabled, got {config['security']['enabled']}")
-            return False
-        
-        # Check roles is disabled
-        if config["roles"]["enabled"] != False:
-            print(f"  ❌ FAIL - Expected roles disabled, got {config['roles']['enabled']}")
-            return False
-        
-        # Check proxy registration is disabled
-        if config["proxy_registration"]["enabled"] != False:
-            print(f"  ❌ FAIL - Expected proxy registration disabled, got {config['proxy_registration']['enabled']}")
-            return False
-        
-        print("  ✅ PASS - All required sections and fields present")
-        print("  ✅ PASS - All features correctly disabled")
-        print("  ✅ PASS - Protocol correctly set to HTTP")
-        
-        return True
-        
-    except Exception as e:
-        print(f"  💥 EXCEPTION: {str(e)}")
-        return False
-
-
-def test_config_modification():
-    """Test that we can modify generated configs for different scenarios."""
-    print("\n📋 Testing: Configuration Modification")
-    print("-" * 40)
-    
-    try:
-        # Generate base config
-        config = generate_complete_config(host="localhost", port=8080)
-        
-        # Test 1: Enable HTTPS
-        print("  🔧 Testing HTTPS modification...")
-        config["server"]["protocol"] = "https"
-        config["ssl"]["enabled"] = True
-        
-        if config["server"]["protocol"] != "https":
-            print("  ❌ FAIL - Could not change protocol to HTTPS")
-            return False
-        
-        if config["ssl"]["enabled"] != True:
-            print("  ❌ FAIL - Could not enable SSL")
-            return False
-        
-        print("  ✅ PASS - HTTPS modification successful")
-        
-        # Test 2: Enable security
-        print("  🔧 Testing security modification...")
-        config["security"]["enabled"] = True
-        config["security"]["tokens"] = {"test_token": {"permissions": ["*"]}}
-        
-        if config["security"]["enabled"] != True:
-            print("  ❌ FAIL - Could not enable security")
-            return False
-        
-        if "tokens" not in config["security"]:
-            print("  ❌ FAIL - Could not add tokens")
-            return False
-        
-        print("  ✅ PASS - Security modification successful")
-        
-        # Test 3: Enable roles
-        print("  🔧 Testing roles modification...")
-        config["roles"]["enabled"] = True
-        config["roles"]["config_file"] = "./test_roles.json"
-        
-        if config["roles"]["enabled"] != True:
-            print("  ❌ FAIL - Could not enable roles")
-            return False
-        
-        if config["roles"]["config_file"] != "./test_roles.json":
-            print("  ❌ FAIL - Could not set roles config file")
-            return False
-        
-        print("  ✅ PASS - Roles modification successful")
-        
-        return True
-        
-    except Exception as e:
-        print(f"  💥 EXCEPTION: {str(e)}")
-        return False
 
 
-def test_validator_accepts_generated_config():
-    """Test that validator accepts the basic generated config without file checks."""
-    print("\n📋 Testing: Validator Accepts Generated Config")
-    print("-" * 40)
-    
-    try:
-        # Generate config
-        config = generate_complete_config(host="localhost", port=8080)
-        
-        # Create a mock validator that doesn't check files
-        class MockValidator(ConfigValidator):
-            def _validate_file_existence(self):
-                """Skip file existence checks for testing."""
-                pass
-            
-            def _validate_certificate_file(self, cert_file, section, key):
-                """Skip certificate validation for testing."""
-                pass
-            
-            def _validate_key_file(self, key_file, section, key):
-                """Skip key validation for testing."""
-                pass
-            
-            def _validate_ca_certificate_file(self, ca_cert_file, section, key):
-                """Skip CA certificate validation for testing."""
-                pass
-        
-        # Validate with mock validator
-        validator = MockValidator()
-        validator.config_data = config
-        results = validator.validate_config()
-        
-        errors = [r for r in results if r.level == "error"]
-        warnings = [r for r in results if r.level == "warning"]
-        
-        if len(errors) > 0:
-            print(f"  ❌ FAIL - {len(errors)} validation errors:")
-            for error in errors[:3]:
-                print(f"    • {error.message}")
-            return False
-        
-        print(f"  ✅ PASS - No validation errors ({len(warnings)} warnings)")
-        return True
-        
-    except Exception as e:
-        print(f"  💥 EXCEPTION: {str(e)}")
-        return False
 
 
-def main():
-    """Main test function."""
-    print("🚀 Generator-Validator Structure Compatibility Test")
-    print("=" * 70)
-    
-    tests = [
-        ("Structure Test", test_generator_validator_structure),
-        ("Modification Test", test_config_modification),
-        ("Validator Acceptance Test", test_validator_accepts_generated_config)
-    ]
     
     results = []
     

mcp_proxy_adapter/integrations/__init__.py

@@ -0,0 +1,25 @@
+"""
+Integration modules for mcp_proxy_adapter.
+
+This package contains integrations with external systems and libraries
+to extend the functionality of the MCP Proxy Adapter framework.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from .queuemgr_integration import (
+    QueueManagerIntegration,
+    QueueJobBase,
+    QueueJobResult,
+    QueueJobStatus,
+    QueueJobError,
+)
+
+__all__ = [
+    "QueueManagerIntegration",
+    "QueueJobBase", 
+    "QueueJobResult",
+    "QueueJobStatus",
+    "QueueJobError",
+]

mcp_proxy_adapter/integrations/queuemgr_integration.py

@@ -0,0 +1,462 @@
+"""
+Queue Manager Integration for MCP Proxy Adapter.
+
+This module provides integration between mcp_proxy_adapter and queuemgr
+for managing background jobs and task queues.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import logging
+from pathlib import Path
+from contextlib import asynccontextmanager
+from typing import Optional, Dict, Any, Type
+
+try:
+    from queuemgr.jobs.base import QueueJobBase as QueuemgrJobBase
+    from queuemgr.core.types import JobStatus as QueuemgrJobStatus
+    from queuemgr.exceptions import (
+        QueueManagerError,
+        JobNotFoundError,
+        JobAlreadyExistsError,
+        InvalidJobStateError,
+        JobExecutionError,
+        ProcessControlError,
+        ValidationError as QueuemgrValidationError,
+        TimeoutError as QueuemgrTimeoutError,
+    )
+    QUEUEMGR_AVAILABLE = True
+except ImportError as e:
+    # Fallback for when queuemgr is not available
+    QUEUEMGR_AVAILABLE = False
+    QueuemgrJobBase = object
+    QueuemgrJobStatus = str
+    QueueManagerError = Exception
+    JobNotFoundError = Exception
+    JobAlreadyExistsError = Exception
+    InvalidJobStateError = Exception
+    JobExecutionError = Exception
+    ProcessControlError = Exception
+    QueuemgrValidationError = Exception
+    QueuemgrTimeoutError = Exception
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from mcp_proxy_adapter.core.errors import MicroserviceError, ValidationError
+
+
+class QueueJobStatus:
+    """Job status constants for queue integration."""
+    
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    STOPPED = "stopped"
+    DELETED = "deleted"
+
+
+class QueueJobResult:
+    """Result of a queue job execution."""
+    
+    def __init__(
+        self,
+        job_id: str,
+        status: str,
+        result: Optional[Dict[str, Any]] = None,
+        error: Optional[str] = None,
+        progress: int = 0,
+        description: str = "",
+    ):
+        """
+        Initialize queue job result.
+        
+        Args:
+            job_id: Unique job identifier
+            status: Job status
+            result: Job result data
+            error: Error message if failed
+            progress: Progress percentage (0-100)
+            description: Job description
+        """
+        self.job_id = job_id
+        self.status = status
+        self.result = result or {}
+        self.error = error
+        self.progress = max(0, min(100, progress))
+        self.description = description
+
+
+class QueueJobError(Exception):
+    """Exception raised for queue job errors."""
+    
+    def __init__(self, job_id: str, message: str, original_error: Optional[Exception] = None):
+        """
+        Initialize queue job error.
+        
+        Args:
+            job_id: Job identifier that failed
+            message: Error message
+            original_error: Original exception that caused the error
+        """
+        super().__init__(f"Job {job_id}: {message}")
+        self.job_id = job_id
+        self.original_error = original_error
+
+
+class QueueJobBase(QueuemgrJobBase):
+    """
+    Base class for MCP Proxy Adapter queue jobs.
+    
+    This class extends the queuemgr QueueJobBase to provide
+    MCP-specific functionality and error handling.
+    """
+    
+    def __init__(self, job_id: str, params: Dict[str, Any]):
+        """
+        Initialize MCP queue job.
+        
+        Args:
+            job_id: Unique job identifier
+            params: Job parameters
+        """
+        if not QUEUEMGR_AVAILABLE:
+            raise MicroserviceError(
+                "queuemgr is not available. Install it with: pip install queuemgr>=1.0.5"
+            )
+        
+        super().__init__(job_id, params)
+        self.logger = get_global_logger()
+        self.mcp_params = params
+        
+        
+
+
+class QueueManagerIntegration:
+    """
+    Queue Manager Integration for MCP Proxy Adapter.
+    
+    This class provides a high-level interface for managing
+    background jobs using the queuemgr system.
+    """
+    
+    def __init__(
+        self,
+        registry_path: str = "mcp_queue_registry.jsonl",
+        shutdown_timeout: float = 30.0,
+        max_concurrent_jobs: int = 10,
+    ):
+        """
+        Initialize queue manager integration.
+        
+        Args:
+            registry_path: Path to the queue registry file
+            shutdown_timeout: Timeout for graceful shutdown
+            max_concurrent_jobs: Maximum number of concurrent jobs
+        """
+        if not QUEUEMGR_AVAILABLE:
+            raise MicroserviceError(
+                "queuemgr is not available. Install it with: pip install queuemgr>=1.0.5"
+            )
+        
+        self.registry_path = registry_path
+        self.shutdown_timeout = shutdown_timeout
+        self.max_concurrent_jobs = max_concurrent_jobs
+        self.logger = get_global_logger()
+        self._queue_system: Optional[AsyncQueueSystem] = None
+        self._is_running = False
+        
+    async def start(self) -> None:
+        """Start the queue manager integration."""
+        if self._is_running:
+            self.logger.warning("Queue manager integration is already running")
+            return
+            
+        try:
+            self._queue_system = AsyncQueueSystem(
+                registry_path=self.registry_path,
+                shutdown_timeout=self.shutdown_timeout,
+            )
+            await self._queue_system.start()
+            self._is_running = True
+            self.logger.info("✅ Queue manager integration started")
+            
+        except Exception as e:
+            self.logger.error(f"❌ Failed to start queue manager integration: {e}")
+            raise MicroserviceError(f"Failed to start queue manager: {str(e)}")
+    
+    async def stop(self) -> None:
+        """Stop the queue manager integration."""
+        if not self._is_running:
+            self.logger.warning("Queue manager integration is not running")
+            return
+            
+        try:
+            if self._queue_system:
+                await self._queue_system.stop()
+            self._is_running = False
+            self.logger.info("✅ Queue manager integration stopped")
+            
+        except Exception as e:
+            self.logger.error(f"❌ Failed to stop queue manager integration: {e}")
+            raise MicroserviceError(f"Failed to stop queue manager: {str(e)}")
+    
+    def is_running(self) -> bool:
+        """Check if the queue manager integration is running."""
+        return self._is_running and self._queue_system is not None
+    
+    async def add_job(
+        self,
+        job_class: Type[QueueJobBase],
+        job_id: str,
+        params: Dict[str, Any],
+    ) -> QueueJobResult:
+        """
+        Add a job to the queue.
+        
+        Args:
+            job_class: Job class to instantiate
+            job_id: Unique job identifier
+            params: Job parameters
+            
+        Returns:
+            QueueJobResult with job information
+            
+        Raises:
+            QueueJobError: If job cannot be added
+        """
+        if not self.is_running():
+            raise QueueJobError(job_id, "Queue manager is not running")
+        
+        try:
+            await self._queue_system.add_job(job_class, job_id, params)
+            return QueueJobResult(
+                job_id=job_id,
+                status=QueueJobStatus.PENDING,
+                description="Job added to queue"
+            )
+            
+        except JobAlreadyExistsError as e:
+            raise QueueJobError(job_id, f"Job already exists: {str(e)}", e)
+        except QueuemgrValidationError as e:
+            raise QueueJobError(job_id, f"Invalid job parameters: {str(e)}", e)
+        except Exception as e:
+            raise QueueJobError(job_id, f"Failed to add job: {str(e)}", e)
+    
+    async def start_job(self, job_id: str) -> QueueJobResult:
+        """
+        Start a job in the queue.
+        
+        Args:
+            job_id: Job identifier to start
+            
+        Returns:
+            QueueJobResult with job status
+            
+        Raises:
+            QueueJobError: If job cannot be started
+        """
+        if not self.is_running():
+            raise QueueJobError(job_id, "Queue manager is not running")
+        
+        try:
+            await self._queue_system.start_job(job_id)
+            return QueueJobResult(
+                job_id=job_id,
+                status=QueueJobStatus.RUNNING,
+                description="Job started"
+            )
+            
+        except JobNotFoundError as e:
+            raise QueueJobError(job_id, f"Job not found: {str(e)}", e)
+        except InvalidJobStateError as e:
+            raise QueueJobError(job_id, f"Invalid job state: {str(e)}", e)
+        except Exception as e:
+            raise QueueJobError(job_id, f"Failed to start job: {str(e)}", e)
+    
+    async def stop_job(self, job_id: str) -> QueueJobResult:
+        """
+        Stop a job in the queue.
+        
+        Args:
+            job_id: Job identifier to stop
+            
+        Returns:
+            QueueJobResult with job status
+            
+        Raises:
+            QueueJobError: If job cannot be stopped
+        """
+        if not self.is_running():
+            raise QueueJobError(job_id, "Queue manager is not running")
+        
+        try:
+            await self._queue_system.stop_job(job_id)
+            return QueueJobResult(
+                job_id=job_id,
+                status=QueueJobStatus.STOPPED,
+                description="Job stopped"
+            )
+            
+        except JobNotFoundError as e:
+            raise QueueJobError(job_id, f"Job not found: {str(e)}", e)
+        except ProcessControlError as e:
+            raise QueueJobError(job_id, f"Process control error: {str(e)}", e)
+        except Exception as e:
+            raise QueueJobError(job_id, f"Failed to stop job: {str(e)}", e)
+    
+    async def delete_job(self, job_id: str) -> QueueJobResult:
+        """
+        Delete a job from the queue.
+        
+        Args:
+            job_id: Job identifier to delete
+            
+        Returns:
+            QueueJobResult with job status
+            
+        Raises:
+            QueueJobError: If job cannot be deleted
+        """
+        if not self.is_running():
+            raise QueueJobError(job_id, "Queue manager is not running")
+        
+        try:
+            await self._queue_system.delete_job(job_id)
+            return QueueJobResult(
+                job_id=job_id,
+                status=QueueJobStatus.DELETED,
+                description="Job deleted"
+            )
+            
+        except JobNotFoundError as e:
+            raise QueueJobError(job_id, f"Job not found: {str(e)}", e)
+        except Exception as e:
+            raise QueueJobError(job_id, f"Failed to delete job: {str(e)}", e)
+    
+    async def get_job_status(self, job_id: str) -> QueueJobResult:
+        """
+        Get the status of a job.
+        
+        Args:
+            job_id: Job identifier to get status for
+            
+        Returns:
+            QueueJobResult with job status and information
+            
+        Raises:
+            QueueJobError: If job status cannot be retrieved
+        """
+        if not self.is_running():
+            raise QueueJobError(job_id, "Queue manager is not running")
+        
+        try:
+            status_data = await self._queue_system.get_job_status(job_id)
+            
+            # Convert queuemgr status to MCP status
+            mcp_status = self._convert_status(status_data.get("status", "unknown"))
+            
+            return QueueJobResult(
+                job_id=job_id,
+                status=mcp_status,
+                result=status_data.get("result", {}),
+                error=status_data.get("error"),
+                progress=status_data.get("progress", 0),
+                description=status_data.get("description", ""),
+            )
+            
+        except JobNotFoundError as e:
+            raise QueueJobError(job_id, f"Job not found: {str(e)}", e)
+        except Exception as e:
+            raise QueueJobError(job_id, f"Failed to get job status: {str(e)}", e)
+    
+    async def list_jobs(self) -> List[QueueJobResult]:
+        """
+        List all jobs in the queue.
+        
+        Returns:
+            List of QueueJobResult objects
+            
+        Raises:
+            QueueJobError: If jobs cannot be listed
+        """
+        if not self.is_running():
+            raise QueueJobError("", "Queue manager is not running")
+        
+        try:
+            jobs_data = await self._queue_system.list_jobs()
+            
+            results = []
+            for job_data in jobs_data:
+                mcp_status = self._convert_status(job_data.get("status", "unknown"))
+                results.append(QueueJobResult(
+                    job_id=job_data.get("job_id", "unknown"),
+                    status=mcp_status,
+                    result=job_data.get("result", {}),
+                    error=job_data.get("error"),
+                    progress=job_data.get("progress", 0),
+                    description=job_data.get("description", ""),
+                ))
+            
+            return results
+            
+        except Exception as e:
+            raise QueueJobError("", f"Failed to list jobs: {str(e)}", e)
+    
+    
+    def _convert_status(self, queuemgr_status: str) -> str:
+        """
+        Convert queuemgr status to MCP status.
+        
+        Args:
+            queuemgr_status: Status from queuemgr
+            
+        Returns:
+            MCP-compatible status
+        """
+        status_mapping = {
+            "pending": QueueJobStatus.PENDING,
+            "running": QueueJobStatus.RUNNING,
+            "completed": QueueJobStatus.COMPLETED,
+            "failed": QueueJobStatus.FAILED,
+            "stopped": QueueJobStatus.STOPPED,
+            "deleted": QueueJobStatus.DELETED,
+        }
+        
+        return status_mapping.get(queuemgr_status.lower(), QueueJobStatus.PENDING)
+
+
+# Global queue manager instance
+_global_queue_manager: Optional[QueueManagerIntegration] = None
+
+
+async def get_global_queue_manager() -> QueueManagerIntegration:
+    """
+    Get global queue manager instance, initializing it if necessary.
+
+    Returns:
+        QueueManagerIntegration instance
+
+    Raises:
+        QueueJobError: If queue manager cannot be initialized
+    """
+    global _global_queue_manager
+    
+    if _global_queue_manager is None:
+        # Initialize with default configuration
+        config = {
+            "queue_manager": {
+                "backend": "memory",  # Default to in-memory for simplicity
+                "max_workers": 4,
+            }
+        }
+        _global_queue_manager = QueueManagerIntegration(config)
+        await _global_queue_manager.initialize()
+    
+    return _global_queue_manager
+
+
+
+
+
+