gitwebhooks 2.1.0__py3-none-any.whl

gitwebhooks/config/loader.py

@@ -0,0 +1,170 @@
+"""Configuration loader
+
+Load and parse configuration from INI files.
+"""
+
+import configparser
+from pathlib import Path
+from typing import Dict, Optional
+
+from gitwebhooks.config.models import ProviderConfig, RepositoryConfig
+from gitwebhooks.models.provider import Provider
+from gitwebhooks.utils.exceptions import ConfigurationError
+
+
+class ConfigLoader:
+    """Configuration loader
+
+    Responsible for loading and validating configuration from INI files
+    """
+
+    def __init__(self, config_path: str):
+        """Initialize configuration loader
+
+        Args:
+            config_path: INI configuration file path
+
+        Raises:
+            ConfigurationError: File does not exist or cannot be parsed
+        """
+        self.config_path = Path(config_path)
+        self.parser = configparser.ConfigParser()
+        self._load_file()
+
+    def _load_file(self) -> None:
+        """Load configuration file
+
+        Raises:
+            ConfigurationError: File does not exist or parsing failed
+        """
+        if not self.config_path.exists():
+            raise ConfigurationError(f'Config file not found: {self.config_path}')
+
+        try:
+            self.parser.read(str(self.config_path))
+        except (configparser.Error, UnicodeDecodeError) as e:
+            raise ConfigurationError(f'Failed to parse config: {e}')
+
+    def load_provider_config(self, provider: Provider) -> ProviderConfig:
+        """Load configuration for specified provider
+
+        Args:
+            provider: Provider type
+
+        Returns:
+            ProviderConfig instance
+
+        Raises:
+            ConfigurationError: Configuration section does not exist
+        """
+        try:
+            return ProviderConfig.from_config_parser(self.parser, provider)
+        except configparser.NoSectionError:
+            # Return default configuration
+            return ProviderConfig(
+                provider=provider,
+                verify=False,
+                secret='',
+                handle_events=[]
+            )
+
+    def load_all_provider_configs(self) -> Dict[Provider, ProviderConfig]:
+        """Load all provider configurations
+
+        Returns:
+            Mapping of provider to configuration
+        """
+        configs = {}
+        for provider in Provider:
+            configs[provider] = self.load_provider_config(provider)
+        return configs
+
+    def load_repository_config(self, name: str) -> Optional[RepositoryConfig]:
+        """Load configuration for specified repository
+
+        Args:
+            name: Repository name (configuration section name)
+
+        Returns:
+            RepositoryConfig instance, or None if section does not exist
+        """
+        return RepositoryConfig.from_config_parser(self.parser, name)
+
+    def load_all_repository_configs(self) -> Dict[str, RepositoryConfig]:
+        """Load all repository configurations
+
+        Returns:
+            Mapping of repository name to configuration
+
+        Note:
+            Skips reserved section names: server, ssl, github, gitee, gitlab, custom
+        """
+        configs = {}
+        reserved_sections = self._get_reserved_sections()
+
+        for section in self.parser.sections():
+            if section not in reserved_sections:
+                repo_config = self.load_repository_config(section)
+                if repo_config is not None:
+                    configs[section] = repo_config
+
+        return configs
+
+    def _get_reserved_sections(self) -> set:
+        """Get reserved configuration section names
+
+        Returns:
+            Set of reserved section names
+        """
+        return {'server', 'ssl', 'github', 'gitee', 'gitlab', 'custom'}
+
+    def get_server_config(self) -> Dict[str, any]:
+        """Get server configuration
+
+        Returns:
+            Dictionary containing server configuration, keys include:
+            - address: Listen address
+            - port: Listen port
+            - log_file: Log file path
+        """
+        return {
+            'address': self.parser.get('server', 'address', fallback='0.0.0.0'),
+            'port': self.parser.getint('server', 'port', fallback=6789),
+            'log_file': self.parser.get('server', 'log_file', fallback='').strip(),
+        }
+
+    def get_ssl_config(self) -> Optional[Dict[str, str]]:
+        """Get SSL configuration
+
+        Returns:
+            Dictionary containing SSL configuration, or None if not enabled
+            Keys include:
+            - enable: Whether SSL is enabled
+            - key_file: SSL key file path
+            - cert_file: SSL certificate file path
+        """
+        try:
+            if not self.parser.getboolean('ssl', 'enable'):
+                return None
+        except (configparser.NoSectionError, ValueError):
+            return None
+
+        return {
+            'enable': True,
+            'key_file': self.parser.get('ssl', 'key_file'),
+            'cert_file': self.parser.get('ssl', 'cert_file'),
+        }
+
+    def validate_repository_configs(self) -> None:
+        """Validate all repository configurations
+
+        Raises:
+            ConfigurationError: Configuration is invalid
+        """
+        configs = self.load_all_repository_configs()
+
+        for name, config in configs.items():
+            try:
+                config.validate()
+            except ConfigurationError as e:
+                raise ConfigurationError(f'Repository {name}: {e}')

gitwebhooks/config/models.py

@@ -0,0 +1,145 @@
+"""Configuration data models
+
+Defines configuration-related dataclasses.
+"""
+
+import configparser
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+from gitwebhooks.models.provider import Provider
+from gitwebhooks.utils.exceptions import ConfigurationError
+
+
+@dataclass
+class ProviderConfig:
+    """Git platform provider configuration
+
+    Attributes:
+        provider: Provider type
+        verify: Whether to verify signature/token
+        secret: Secret key for verification
+        handle_events: List of events to handle (empty list = handle all events)
+        header_name: Custom identification header (CUSTOM only)
+        header_value: Custom identification value (CUSTOM only)
+        header_event: Custom event header (CUSTOM only)
+        header_token: Custom token header (CUSTOM only)
+        identifier_path: Repository identifier JSON path (CUSTOM only)
+    """
+    provider: Provider
+    verify: bool
+    secret: str
+    handle_events: List[str]
+
+    # Custom provider only
+    header_name: str = ''
+    header_value: str = ''
+    header_event: str = ''
+    header_token: str = ''
+    identifier_path: str = ''
+
+    @classmethod
+    def from_config_parser(cls, parser: configparser.ConfigParser,
+                          provider: Provider) -> 'ProviderConfig':
+        """Load provider configuration from ConfigParser
+
+        Args:
+            parser: ConfigParser instance
+            provider: Provider type
+
+        Returns:
+            ProviderConfig instance
+
+        Raises:
+            configparser.NoSectionError: Configuration section does not exist
+        """
+        section = provider.value
+        handle_events_str = parser.get(section, 'handle_events',
+                                       fallback='').strip()
+        handle_events = [e.strip() for e in handle_events_str.split(',')
+                        if e.strip()] if handle_events_str else []
+
+        config = cls(
+            provider=provider,
+            verify=parser.getboolean(section, 'verify', fallback=False),
+            secret=parser.get(section, 'secret', fallback=''),
+            handle_events=handle_events
+        )
+
+        # Custom provider additional fields
+        if provider == Provider.CUSTOM:
+            config.header_name = parser.get(section, 'header_name',
+                                           fallback='X-Custom-Webhook')
+            config.header_value = parser.get(section, 'header_value',
+                                            fallback='custom')
+            config.header_event = parser.get(section, 'header_event',
+                                            fallback='X-Custom-Event')
+            config.header_token = parser.get(section, 'header_token',
+                                            fallback='X-Custom-Token')
+            config.identifier_path = parser.get(section, 'identifier_path',
+                                               fallback='')
+
+        return config
+
+    def allows_event(self, event: str) -> bool:
+        """Check if an event is allowed to be handled
+
+        Args:
+            event: Event type (None means all events)
+
+        Returns:
+            True if event is allowed, False otherwise
+        """
+        if not self.handle_events:
+            return True  # Empty list = handle all events
+        return event in self.handle_events
+
+
+@dataclass
+class RepositoryConfig:
+    """Repository deployment configuration
+
+    Attributes:
+        name: Repository name (format: 'owner/repo' or 'group/project/repo')
+        cwd: Working directory for deployment command execution
+        cmd: Deployment command (shell string)
+    """
+    name: str
+    cwd: str
+    cmd: str
+
+    @classmethod
+    def from_config_parser(cls, parser: configparser.ConfigParser,
+                          name: str):
+        """Load repository configuration from ConfigParser
+
+        Args:
+            parser: ConfigParser instance
+            name: Configuration section name (repository name)
+
+        Returns:
+            RepositoryConfig instance, or None if section does not exist
+
+        Raises:
+            configparser.NoOptionError: Section exists but missing required options
+        """
+        if not parser.has_section(name):
+            return None
+
+        return cls(
+            name=name,
+            cwd=parser.get(name, 'cwd'),
+            cmd=parser.get(name, 'cmd')
+        )
+
+    def validate(self) -> None:
+        """Validate configuration
+
+        Raises:
+            ConfigurationError: Configuration is invalid
+        """
+        if not self.cwd:
+            raise ConfigurationError(f'Repository {self.name}: cwd is required')
+        if not self.cmd:
+            raise ConfigurationError(f'Repository {self.name}: cmd is required')

gitwebhooks/config/registry.py

@@ -0,0 +1,104 @@
+"""Configuration registry
+
+Holds all configuration and provides access interface.
+"""
+
+from typing import Dict
+
+from gitwebhooks.config.loader import ConfigLoader
+from gitwebhooks.config.models import ProviderConfig, RepositoryConfig
+from gitwebhooks.config.server import ServerConfig
+from gitwebhooks.models.provider import Provider
+from gitwebhooks.utils.exceptions import ConfigurationError
+
+
+class ConfigurationRegistry:
+    """Configuration registry
+
+    Holds all configuration and provides access interface
+    """
+
+    def __init__(self, loader: ConfigLoader):
+        """Initialize configuration registry
+
+        Args:
+            loader: Configuration loader instance
+        """
+        self.loader = loader
+        self._server_config = None
+        self._provider_configs = None
+        self._repository_configs = None
+        self._load_all_configs()
+
+    def _load_all_configs(self) -> None:
+        """Load all configurations
+
+        Raises:
+            ConfigurationError: Configuration loading or validation failed
+        """
+        self._server_config = ServerConfig.from_loader(self.loader)
+        self._server_config.validate()
+
+        self._provider_configs = self.loader.load_all_provider_configs()
+        self._repository_configs = self.loader.load_all_repository_configs()
+
+        self.loader.validate_repository_configs()
+
+    @property
+    def server_config(self) -> ServerConfig:
+        """Get server configuration"""
+        if self._server_config is None:
+            raise ConfigurationError('Server config not loaded')
+        return self._server_config
+
+    @property
+    def provider_configs(self) -> Dict[Provider, ProviderConfig]:
+        """Get provider configuration dictionary"""
+        if self._provider_configs is None:
+            raise ConfigurationError('Provider configs not loaded')
+        return self._provider_configs
+
+    @property
+    def repository_configs(self) -> Dict[str, RepositoryConfig]:
+        """Get repository configuration dictionary"""
+        if self._repository_configs is None:
+            raise ConfigurationError('Repository configs not loaded')
+        return self._repository_configs
+
+    def get_provider_config(self, provider: Provider) -> ProviderConfig:
+        """Get configuration for specified provider
+
+        Args:
+            provider: Provider type
+
+        Returns:
+            ProviderConfig instance
+        """
+        return self.provider_configs.get(provider, ProviderConfig(
+            provider=provider,
+            verify=False,
+            secret='',
+            handle_events=[]
+        ))
+
+    def get_repository_config(self, name: str) -> RepositoryConfig:
+        """Get configuration for specified repository
+
+        Args:
+            name: Repository name
+
+        Returns:
+            RepositoryConfig instance, or None if not found
+        """
+        return self.repository_configs.get(name)
+
+    def has_repository(self, name: str) -> bool:
+        """Check if repository exists
+
+        Args:
+            name: Repository name
+
+        Returns:
+            True if exists, False otherwise
+        """
+        return name in self.repository_configs

gitwebhooks/config/server.py

@@ -0,0 +1,85 @@
+"""Server configuration
+
+Defines server-related configuration dataclasses.
+"""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional
+
+from gitwebhooks.utils.exceptions import ConfigurationError
+
+
+@dataclass
+class ServerConfig:
+    """Server configuration
+
+    Attributes:
+        address: Listen address
+        port: Listen port
+        log_file: Log file path (empty string means no file logging)
+        ssl_enabled: Whether SSL is enabled
+        ssl_key_file: SSL key file path
+        ssl_cert_file: SSL certificate file path
+    """
+    address: str
+    port: int
+    log_file: str
+    ssl_enabled: bool = False
+    ssl_key_file: Optional[str] = None
+    ssl_cert_file: Optional[str] = None
+
+    @classmethod
+    def from_loader(cls, loader: 'ConfigLoader') -> 'ServerConfig':
+        """Create server configuration from ConfigLoader
+
+        Args:
+            loader: Configuration loader instance
+
+        Returns:
+            ServerConfig instance
+        """
+        server_cfg = loader.get_server_config()
+        ssl_cfg = loader.get_ssl_config()
+
+        return cls(
+            address=server_cfg['address'],
+            port=server_cfg['port'],
+            log_file=server_cfg['log_file'],
+            ssl_enabled=ssl_cfg is not None,
+            ssl_key_file=ssl_cfg['key_file'] if ssl_cfg else None,
+            ssl_cert_file=ssl_cfg['cert_file'] if ssl_cfg else None,
+        )
+
+    def validate(self) -> None:
+        """Validate server configuration
+
+        Raises:
+            ConfigurationError: Configuration is invalid
+        """
+        if self.ssl_enabled:
+            if not self.ssl_key_file:
+                raise ConfigurationError('SSL enabled but key_file not specified')
+            if not self.ssl_cert_file:
+                raise ConfigurationError('SSL enabled but cert_file not specified')
+
+            # Verify files exist
+            key_path = Path(self.ssl_key_file)
+            cert_path = Path(self.ssl_cert_file)
+
+            if not key_path.exists():
+                raise ConfigurationError(f'SSL key file not found: {self.ssl_key_file}')
+            if not cert_path.exists():
+                raise ConfigurationError(f'SSL cert file not found: {self.ssl_cert_file}')
+
+        # Validate port range
+        if not (1 <= self.port <= 65535):
+            raise ConfigurationError(f'Invalid port number: {self.port}')
+
+        # Validate log file writable (if specified)
+        if self.log_file:
+            log_path = Path(self.log_file)
+            parent_dir = log_path.parent
+            if parent_dir.exists() and not os.access(parent_dir, os.W_OK):
+                raise ConfigurationError(f'Log directory not writable: {parent_dir}')

gitwebhooks/handlers/__init__.py

@@ -0,0 +1,22 @@
+"""Webhook handlers module
+
+Handles webhook requests from different Git platforms.
+"""
+
+from .base import WebhookHandler
+from .github import GithubHandler
+from .gitee import GiteeHandler
+from .gitlab import GitlabHandler
+from .custom import CustomHandler
+from .factory import HandlerFactory
+from .request import WebhookRequestHandler
+
+__all__ = [
+    'WebhookHandler',
+    'GithubHandler',
+    'GiteeHandler',
+    'GitlabHandler',
+    'CustomHandler',
+    'HandlerFactory',
+    'WebhookRequestHandler',
+]

gitwebhooks/handlers/base.py

@@ -0,0 +1,107 @@
+"""Handler base class
+
+Defines the abstract interface for webhook handlers.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from gitwebhooks.models.provider import Provider
+from gitwebhooks.models.request import WebhookRequest
+from gitwebhooks.models.result import SignatureVerificationResult
+from gitwebhooks.config.models import ProviderConfig
+from gitwebhooks.utils.exceptions import SignatureValidationError, UnsupportedEventError
+
+
+class WebhookHandler(ABC):
+    """Webhook handler base class
+
+    All platform-specific handlers must inherit from this class and implement all abstract methods.
+    """
+
+    @abstractmethod
+    def get_provider(self) -> Provider:
+        """Return the provider type supported by this handler
+
+        Returns:
+            Provider enum value
+        """
+        pass
+
+    @abstractmethod
+    def verify_signature(self, request: WebhookRequest,
+                        config: ProviderConfig) -> SignatureVerificationResult:
+        """Verify webhook signature
+
+        Args:
+            request: Webhook request data
+            config: Provider configuration (includes secret)
+
+        Returns:
+            Signature verification result
+
+        Raises:
+            SignatureValidationError: When verification fails
+        """
+        pass
+
+    @abstractmethod
+    def extract_repository(self, request: WebhookRequest,
+                          config: ProviderConfig) -> Optional[str]:
+        """Extract repository identifier from request
+
+        Args:
+            request: Webhook request data
+            config: Provider configuration (may include identifier_path)
+
+        Returns:
+            Repository identifier (e.g., 'owner/repo'), None if not found
+        """
+        pass
+
+    @abstractmethod
+    def is_event_allowed(self, event: Optional[str],
+                        config: ProviderConfig) -> bool:
+        """Check if event type is allowed to be handled
+
+        Args:
+            event: Event type (e.g., 'push', 'merge_request')
+            config: Provider configuration (includes handle_events list)
+
+        Returns:
+            True if event is allowed, False otherwise
+        """
+        pass
+
+    def handle_request(self, request: WebhookRequest,
+                      config: ProviderConfig) -> Optional[str]:
+        """Handle complete webhook request
+
+        This is a template method that defines the fixed flow of request processing:
+        1. Check if event is allowed
+        2. Verify signature
+        3. Extract repository identifier
+
+        Args:
+            request: Webhook request data
+            config: Provider configuration
+
+        Returns:
+            Repository identifier, None if processing failed
+
+        Raises:
+            SignatureValidationError: Signature verification failed
+            UnsupportedEventError: Event type not allowed
+        """
+        # Step 1: Check event
+        if not self.is_event_allowed(request.event, config):
+            raise UnsupportedEventError(f'Event not configured: {request.event}')
+
+        # Step 2: Verify signature (if required)
+        if config.verify:
+            result = self.verify_signature(request, config)
+            if not result.is_valid:
+                raise SignatureValidationError(result.error_message or 'Verification failed')
+
+        # Step 3: Extract repository identifier
+        return self.extract_repository(request, config)