mcp-proxy-adapter 6.9.43__py3-none-any.whl

mcp_proxy_adapter/core/config/config.py

@@ -0,0 +1,237 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Main configuration class for MCP Proxy Adapter.
+"""
+
+from typing import Any, Dict, Optional, List
+from pathlib import Path
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+from .config_loader import ConfigLoader
+from .feature_manager import FeatureManager
+from .config_factory import ConfigFactory
+
+# Import validation if available
+try:
+    VALIDATION_AVAILABLE = True
+except ImportError:
+    VALIDATION_AVAILABLE = False
+
+# Import configuration errors
+from ..errors import ConfigError, ValidationResult
+
+
+class Config:
+    """
+    Configuration management class for the microservice.
+    Allows loading settings from configuration file and environment variables.
+    Supports optional features that can be enabled/disabled.
+    """
+
+    def __init__(
+        self, config_path: Optional[str] = None, validate_on_load: bool = False
+    ):
+        """
+        Initialize configuration.
+
+        Args:
+            config_path: Path to configuration file. If not specified,
+                        "./config.json" is used.
+            validate_on_load: Whether to validate configuration on load (default: False)
+        
+        Raises:
+            ConfigError: If configuration validation fails
+        """
+        self.config_path = config_path or "./config.json"
+        self.config_data: Dict[str, Any] = {}
+        self.validate_on_load = validate_on_load
+        self.validation_results: List[ValidationResult] = []
+        self.validator = None
+        
+        # Initialize components
+        self.logger = get_global_logger()
+        self.loader = ConfigLoader()
+        self.feature_manager = FeatureManager(self.config_data)
+        self.factory = ConfigFactory()
+        
+        # Load configuration
+        self.load_config()
+
+    def load_config(self) -> None:
+        """Load configuration from file and environment variables."""
+        try:
+            # Load from file if it exists
+            if Path(self.config_path).exists():
+                file_config = self.loader.load_from_file(self.config_path)
+                self.config_data.update(file_config)
+            
+            # Load from environment variables
+            try:
+                env_config = self.loader.load_from_env()
+                self._merge_config(env_config)
+            except AttributeError:
+                # load_from_env doesn't exist yet, skip
+                pass
+            
+            # Validate if required
+            if self.validate_on_load and VALIDATION_AVAILABLE:
+                self.validate()
+                
+        except Exception as e:
+            self.logger.error(f"Failed to load configuration: {e}")
+            raise ConfigError(f"Configuration loading failed: {e}")
+
+    def _merge_config(self, new_config: Dict[str, Any]) -> None:
+        """
+        Merge new configuration into existing configuration.
+
+        Args:
+            new_config: New configuration to merge
+        """
+        for section, values in new_config.items():
+            if section in self.config_data:
+                if isinstance(self.config_data[section], dict) and isinstance(
+                    values, dict
+                ):
+                    self.config_data[section].update(values)
+                else:
+                    self.config_data[section] = values
+            else:
+                self.config_data[section] = values
+
+    def enable_feature(self, feature: str) -> None:
+        """
+        Enable a feature.
+
+        Args:
+            feature: Feature name
+        """
+        self.feature_manager.enable_feature(feature)
+
+    def disable_feature(self, feature: str) -> None:
+        """
+        Disable a feature.
+
+        Args:
+            feature: Feature name
+        """
+        self.feature_manager.disable_feature(feature)
+
+    def is_feature_enabled(self, feature: str) -> bool:
+        """
+        Check if feature is enabled.
+
+        Args:
+            feature: Feature name
+
+        Returns:
+            True if enabled, False otherwise
+        """
+        return self.feature_manager.is_feature_enabled(feature)
+
+    def get_enabled_features(self) -> List[str]:
+        """
+        Get list of enabled features.
+
+        Returns:
+            List of enabled feature names
+        """
+        return self.feature_manager.get_enabled_features()
+
+    def validate(self) -> List[ValidationResult]:
+        """
+        Validate configuration.
+
+        Returns:
+            List of validation results
+        """
+        if not VALIDATION_AVAILABLE:
+            self.logger.warning("Configuration validation not available")
+            return []
+
+        try:
+            from ..config_validator import ConfigValidator
+
+            self.validator = ConfigValidator()
+            self.validator.config_data = self.config_data
+            self.validation_results = self.validator.validate_config()
+            return self.validation_results
+        except Exception as e:
+            self.logger.error(f"Configuration validation failed: {e}")
+            return []
+
+    def get_validation_errors(self) -> List[ValidationResult]:
+        """Get validation errors."""
+        return [result for result in self.validation_results if result.level == "error"]
+
+    def get_validation_warnings(self) -> List[ValidationResult]:
+        """Get validation warnings."""
+        return [
+            result for result in self.validation_results if result.level == "warning"
+        ]
+
+    def get_validation_summary(self) -> Dict[str, Any]:
+        """Get validation summary."""
+        errors = self.get_validation_errors()
+        warnings = self.get_validation_warnings()
+        
+        return {
+            "total": len(self.validation_results),
+            "errors": len(errors),
+            "warnings": len(warnings),
+            "is_valid": len(errors) == 0,
+        }
+
+    def check_feature_requirements(self, feature: str) -> List[ValidationResult]:
+        """
+        Check feature requirements.
+
+        Args:
+            feature: Feature name
+
+        Returns:
+            List of validation results
+        """
+        return self.feature_manager.check_feature_requirements(feature)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value using dot notation.
+
+        Supports nested dictionary access using dot notation.
+        For example: "transport.cert_file" will access config_data["transport"]["cert_file"]
+
+        Args:
+            key: Configuration key, can use dot notation (e.g., "transport.cert_file")
+            default: Default value if key not found
+
+        Returns:
+            Configuration value or default
+
+        Examples:
+            >>> config.get("server.host", "0.0.0.0")
+            >>> config.get("transport.ssl.cert_file")
+        """
+        keys = key.split(".")
+        value = self.config_data
+
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+                if value is None:
+                    return default
+            else:
+                return default
+
+        return value if value is not None else default
+
+    def get_all(self) -> Dict[str, Any]:
+        """
+        Get all configuration data.
+
+        Returns:
+            Complete configuration dictionary
+        """
+        return self.config_data

mcp_proxy_adapter/core/config/config_factory.py

@@ -0,0 +1,22 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Configuration factory for creating predefined configurations.
+"""
+
+from typing import Dict, Any
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class ConfigFactory:
+    """Factory for creating predefined configurations."""
+
+    def __init__(self):
+        """Initialize config factory."""
+        self.logger = get_global_logger()
+
+
+
+

mcp_proxy_adapter/core/config/config_loader.py

@@ -0,0 +1,66 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Configuration loading utilities for MCP Proxy Adapter.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class ConfigLoader:
+    """Loader for configuration files and environment variables."""
+
+    def __init__(self):
+        """Initialize config loader."""
+        self.logger = get_global_logger()
+
+    def load_from_file(self, config_path: str | Path) -> dict:
+        """
+        Load configuration from JSON file.
+
+        Args:
+            config_path: Path to configuration file
+
+        Returns:
+            Configuration dictionary
+
+        Raises:
+            FileNotFoundError: If config file doesn't exist
+            json.JSONDecodeError: If config file is invalid JSON
+        """
+        path = Path(config_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    def _convert_env_value(self, value: str) -> Any:
+        """
+        Convert environment variable value to appropriate type.
+
+        Args:
+            value: Value as string
+
+        Returns:
+            Converted value
+        """
+        # Try to convert to appropriate type
+        if value.lower() == "true":
+            return True
+        elif value.lower() == "false":
+            return False
+        elif value.isdigit():
+            return int(value)
+        else:
+            try:
+                return float(value)
+            except ValueError:
+                return value
+

mcp_proxy_adapter/core/config/feature_manager.py

@@ -0,0 +1,31 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Feature management utilities for MCP Proxy Adapter configuration.
+"""
+
+from typing import Any, Dict, List
+
+from mcp_proxy_adapter.core.logging import get_global_logger
+
+
+class FeatureManager:
+    """Manager for configuration features."""
+
+    def __init__(self, config_data: Dict[str, Any]):
+        """
+        Initialize feature manager.
+
+        Args:
+            config_data: Configuration data dictionary
+        """
+        self.config_data = config_data
+        self.logger = get_global_logger()
+
+
+
+
+
+
+

mcp_proxy_adapter/core/config/simple_config.py

@@ -0,0 +1,116 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple configuration data container and IO helpers for MCP Proxy Adapter.
+
+This module provides a minimal, explicit configuration model with three
+sections: server, proxy_client and auth.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ServerConfig:
+    host: str
+    port: int
+    protocol: str  # http | https | mtls
+    cert_file: Optional[str] = None
+    key_file: Optional[str] = None
+    ca_cert_file: Optional[str] = None
+    crl_file: Optional[str] = None
+    use_system_ca: bool = False  # If True, allow system CA store when ca_cert_file is not provided
+    log_dir: str = "./logs"
+
+
+@dataclass
+class HeartbeatConfig:
+    endpoint: str = "/heartbeat"
+    interval: int = 30
+
+
+@dataclass
+class RegistrationConfig:
+    register_endpoint: str = "/register"
+    unregister_endpoint: str = "/unregister"
+    auto_on_startup: bool = True
+    auto_on_shutdown: bool = True
+
+
+@dataclass
+class ProxyClientConfig:
+    enabled: bool = False
+    host: str = "localhost"
+    port: int = 3005
+    protocol: str = "http"
+    server_id: Optional[str] = None  # Server identifier for registration (preferred)
+    server_name: Optional[str] = None  # Legacy field, use server_id instead
+    cert_file: Optional[str] = None
+    key_file: Optional[str] = None
+    ca_cert_file: Optional[str] = None
+    crl_file: Optional[str] = None
+    use_system_ca: bool = False  # If True, allow system CA store when ca_cert_file is not provided
+    heartbeat: HeartbeatConfig = field(default_factory=HeartbeatConfig)
+    registration: RegistrationConfig = field(default_factory=RegistrationConfig)
+
+
+@dataclass
+class AuthConfig:
+    use_token: bool = False
+    use_roles: bool = False
+    tokens: Dict[str, List[str]] = field(default_factory=dict)
+    roles: Dict[str, List[str]] = field(default_factory=dict)
+
+
+@dataclass
+class SimpleConfigModel:
+    server: ServerConfig
+    proxy_client: ProxyClientConfig = field(default_factory=ProxyClientConfig)
+    auth: AuthConfig = field(default_factory=AuthConfig)
+
+
+class SimpleConfig:
+    """High-level loader/saver for SimpleConfigModel."""
+
+    def __init__(self, config_path: str = "config.json") -> None:
+        self.config_path: Path = Path(config_path)
+        self.model: Optional[SimpleConfigModel] = None
+
+    def load(self) -> SimpleConfigModel:
+        content = json.loads(self.config_path.read_text(encoding="utf-8"))
+        server = ServerConfig(**content["server"])  # type: ignore[arg-type]
+        proxy_client = ProxyClientConfig(**content.get("proxy_client", {}))  # type: ignore[arg-type]
+        # Nested structures for proxy client (heartbeat/registration)
+        if isinstance(content.get("proxy_client"), dict):
+            pc = content["proxy_client"]
+            if isinstance(pc.get("heartbeat"), dict):
+                proxy_client.heartbeat = HeartbeatConfig(**pc["heartbeat"])  # type: ignore[arg-type]
+            if isinstance(pc.get("registration"), dict):
+                proxy_client.registration = RegistrationConfig(**pc["registration"])  # type: ignore[arg-type]
+        auth = AuthConfig(**content.get("auth", {}))  # type: ignore[arg-type]
+        self.model = SimpleConfigModel(server=server, proxy_client=proxy_client, auth=auth)
+        return self.model
+
+    def save(self, out_path: Optional[str] = None) -> None:
+        if self.model is None:
+            raise ValueError("Configuration model is not loaded")
+        path = Path(out_path) if out_path else self.config_path
+        data: Dict[str, Any] = {
+            "server": vars(self.model.server),
+            "proxy_client": {
+                **{k: v for k, v in vars(self.model.proxy_client).items() if k not in {"heartbeat", "registration"}},
+                "heartbeat": vars(self.model.proxy_client.heartbeat),
+                "registration": vars(self.model.proxy_client.registration),
+            },
+            "auth": vars(self.model.auth),
+        }
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+
+

mcp_proxy_adapter/core/config/simple_config_generator.py

@@ -0,0 +1,100 @@
+"""
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+
+Simple configuration generator for MCP Proxy Adapter.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .simple_config import (
+    SimpleConfig,
+    SimpleConfigModel,
+    ServerConfig,
+    ProxyClientConfig,
+    AuthConfig,
+)
+
+
+class SimpleConfigGenerator:
+    """Generate minimal configuration according to the plan."""
+
+    def generate(
+        self,
+        protocol: str,
+        with_proxy: bool = False,
+        out_path: str = "config.json",
+        server_host: Optional[str] = None,
+        server_port: Optional[int] = None,
+        server_cert_file: Optional[str] = None,
+        server_key_file: Optional[str] = None,
+        server_ca_cert_file: Optional[str] = None,
+        proxy_host: Optional[str] = None,
+        proxy_port: Optional[int] = None,
+        proxy_cert_file: Optional[str] = None,
+        proxy_key_file: Optional[str] = None,
+        proxy_ca_cert_file: Optional[str] = None,
+    ) -> str:
+        """
+        Generate configuration with optional custom parameters.
+        
+        Args:
+            protocol: Server protocol (http, https, mtls)
+            with_proxy: Enable proxy registration
+            out_path: Output file path
+            server_host: Server host (default: 0.0.0.0)
+            server_port: Server port (default: 8080)
+            server_cert_file: Server certificate file path
+            server_key_file: Server key file path
+            server_ca_cert_file: Server CA certificate file path
+            proxy_host: Proxy host (default: localhost)
+            proxy_port: Proxy port (default: 3005)
+            proxy_cert_file: Proxy client certificate file path
+            proxy_key_file: Proxy client key file path
+            proxy_ca_cert_file: Proxy CA certificate file path
+        """
+        # Server configuration
+        server = ServerConfig(
+            host=server_host or "0.0.0.0", port=server_port or 8080, protocol=protocol
+        )
+        if protocol in ("https", "mtls"):
+            server.cert_file = server_cert_file or "./certs/server.crt"
+            server.key_file = server_key_file or "./certs/server.key"
+        # For mtls: CA is required if use_system_ca=False (default), optional if use_system_ca=True
+        # Only set if explicitly provided
+        if protocol == "mtls" and server_ca_cert_file:
+            server.ca_cert_file = server_ca_cert_file
+        # use_system_ca defaults to False (only CA from config is used by default)
+
+        # Proxy configuration
+        proxy = ProxyClientConfig(enabled=with_proxy)
+        if with_proxy:
+            # NOTE: proxy.protocol indicates the SERVER's protocol, not the proxy's protocol
+            # The proxy itself typically runs on HTTP (for test proxy) or may have its own protocol
+            # This field is used to determine if client certificates are needed for proxy connection
+            # (if proxy itself uses HTTPS/mTLS, which is not the case for test proxy)
+            proxy.protocol = protocol
+            proxy.host = proxy_host or "localhost"
+            proxy.port = proxy_port or 3005
+            # Client certificates for proxy connection (only if proxy itself uses HTTPS/mTLS)
+            # For test proxy (HTTP), these are not used but may be set for consistency
+            if protocol in ("https", "mtls"):
+                proxy.cert_file = proxy_cert_file or "./certs/client.crt"
+                proxy.key_file = proxy_key_file or "./certs/client.key"
+            # For mtls: CA is required if use_system_ca=False (default), optional if use_system_ca=True
+            # Only set if explicitly provided
+            if protocol == "mtls" and proxy_ca_cert_file:
+                proxy.ca_cert_file = proxy_ca_cert_file
+            # use_system_ca defaults to False (only CA from config is used by default)
+            # Explicitly set registration.auto_on_startup when proxy is enabled
+            # Note: enabled controls client availability, registration.auto_on_startup controls auto-registration
+            proxy.registration.auto_on_startup = True
+
+        auth = AuthConfig(use_token=False, use_roles=False, tokens={}, roles={})
+
+        cfg = SimpleConfig()
+        cfg.model = SimpleConfigModel(server=server, proxy_client=proxy, auth=auth)
+        cfg.save(out_path)
+        return out_path