gitwebhooks 2.1.0__py3-none-any.whl

gitwebhooks/main/__init__.py

@@ -0,0 +1,117 @@
+"""CLI main function
+
+Command-line interface module providing compatibility with the original git-webhooks-server.py.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+
+from gitwebhooks.server import WebhookServer
+from gitwebhooks.utils.exceptions import ConfigurationError
+
+# Try to import subcommands, may not be available in older versions
+try:
+    from gitwebhooks.cli import register_subparsers
+    HAS_SUBCOMMANDS = True
+except ImportError:
+    HAS_SUBCOMMANDS = False
+
+
+def main(argv: List[str] = None) -> int:
+    """Main entry point
+
+    Args:
+        argv: Command-line argument list (defaults to sys.argv[1:])
+
+    Returns:
+        Exit code (0 = success, 1 = error)
+
+    Raises:
+        SystemExit: Exit on error
+
+    Command Line Arguments:
+        -h, --help      Show help message and exit
+        -c, --config    Specify configuration file path
+        service         Service management subcommands
+        config          Configuration management subcommands
+
+    Default Config Path:
+        ~/.gitwebhook.ini
+
+    Examples:
+        python3 -m gitwebhooks.main -c /path/to/config.ini
+        gitwebhooks-cli --config /etc/webhooks.ini
+        gitwebhooks-cli service install
+        gitwebhooks-cli config init
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+
+    # Default configuration file path (changed to user home directory)
+    default_config = '~/.gitwebhook.ini'
+
+    # Create main argument parser
+    parser = argparse.ArgumentParser(
+        prog='gitwebhooks-cli',
+        description='Git Webhooks Server - Automated deployment webhook handler',
+        add_help=True
+    )
+    parser.add_argument(
+        '-c', '--config',
+        default=default_config,
+        help='Path to INI configuration file (default: ~/.gitwebhook.ini)'
+    )
+
+    # Add subcommands if available
+    if HAS_SUBCOMMANDS:
+        subparsers = parser.add_subparsers(dest='command', help='Subcommands')
+        register_subparsers(subparsers)
+
+    # Parse arguments
+    args = parser.parse_args(argv)
+
+    # If no subcommand, run server (backward compatible behavior)
+    if not hasattr(args, 'func'):
+        return run_server(args.config)
+
+    # Execute subcommand
+    return args.func(args)
+
+
+def run_server(config_file: str) -> int:
+    """Run the webhook server
+
+    Args:
+        config_file: Path to configuration file
+
+    Returns:
+        Exit code (0 = success, 1 = error)
+    """
+    # Expand user path
+    config_path = Path(config_file).expanduser()
+
+    # Check configuration file exists
+    if not config_path.exists():
+        print(f'Error: Configuration file not found: {config_path}', file=sys.stderr)
+        return 1
+
+    # Create and run server
+    try:
+        server = WebhookServer(config_path=str(config_path))
+        server.run()
+        return 0
+    except ConfigurationError as e:
+        print(f'Configuration error: {e}', file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print('\nServer stopped by user')
+        return 0
+    except Exception as e:
+        print(f'Error: {e}', file=sys.stderr)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

gitwebhooks/main/__main__.py

@@ -0,0 +1,12 @@
+"""Main module entry point
+
+Allows running the CLI with: python3 -m gitwebhooks.main
+"""
+
+import sys
+
+# Import main from the same directory
+from gitwebhooks.main import main
+
+if __name__ == '__main__':
+    sys.exit(main())

gitwebhooks/models/__init__.py

@@ -0,0 +1,14 @@
+"""Data models module
+
+Defines core data types and enumerations.
+"""
+
+from .provider import Provider
+from .request import WebhookRequest
+from .result import SignatureVerificationResult
+
+__all__ = [
+    'Provider',
+    'WebhookRequest',
+    'SignatureVerificationResult',
+]

gitwebhooks/models/provider.py

@@ -0,0 +1,22 @@
+"""Git platform provider enumeration
+
+Defines supported Git hosting platform types.
+"""
+
+from enum import Enum, unique
+
+
+@unique
+class Provider(Enum):
+    """Git platform provider type
+
+    Supported Git hosting platforms:
+    - GITHUB: GitHub platform
+    - GITEE: Gitee platform (China)
+    - GITLAB: GitLab platform
+    - CUSTOM: Custom webhook platform
+    """
+    GITHUB = 'github'
+    GITEE = 'gitee'
+    GITLAB = 'gitlab'
+    CUSTOM = 'custom'

gitwebhooks/models/request.py

@@ -0,0 +1,61 @@
+"""Webhook request data wrapper
+
+Represents a parsed HTTP webhook request.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from gitwebhooks.models.provider import Provider
+
+
+@dataclass
+class WebhookRequest:
+    """Webhook request data wrapper
+
+    Attributes:
+        provider: Git platform provider
+        event: Event type (e.g., 'push', 'merge_request')
+        payload: Raw request body bytes
+        headers: HTTP request headers
+        post_data: Parsed JSON/form data
+        content_type: Content-Type header value
+        content_length: Content-Length header value
+    """
+    provider: Provider
+    event: Optional[str]
+    payload: bytes
+    headers: Dict[str, str]
+    post_data: Optional[Dict[str, Any]]
+    content_type: str
+    content_length: int
+
+    @property
+    def repo_identifier(self) -> Optional[str]:
+        """Extract repository identifier from post_data
+
+        Returns:
+            Repository identifier (e.g., 'owner/repo'), None if not found
+
+        Extraction rules:
+        - GitHub: repository.full_name
+        - Gitee: repository.full_name
+        - GitLab: project.path_with_namespace
+        - Custom: Uses ProviderConfig.identifier_path
+        """
+        if self.post_data is None:
+            return None
+
+        extractors = {
+            Provider.GITHUB: lambda d: d.get('repository', {}).get('full_name'),
+            Provider.GITEE: lambda d: d.get('repository', {}).get('full_name'),
+            Provider.GITLAB: lambda d: d.get('project', {}).get('path_with_namespace'),
+        }
+
+        extractor = extractors.get(self.provider)
+        if extractor:
+            result = extractor(self.post_data)
+            return result if isinstance(result, str) else None
+
+        # Custom provider uses identifier_path (handled in handler)
+        return None

gitwebhooks/models/result.py

@@ -0,0 +1,40 @@
+"""Signature verification result dataclass
+
+Represents the result status of signature verification.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class SignatureVerificationResult:
+    """Signature verification result
+
+    Attributes:
+        is_valid: Whether verification passed
+        error_message: Error description when verification fails
+    """
+    is_valid: bool
+    error_message: Optional[str] = None
+
+    @classmethod
+    def success(cls) -> 'SignatureVerificationResult':
+        """Create a successful verification result
+
+        Returns:
+            Result object with is_valid=True
+        """
+        return cls(is_valid=True)
+
+    @classmethod
+    def failure(cls, message: str) -> 'SignatureVerificationResult':
+        """Create a failed verification result
+
+        Args:
+            message: Error description
+
+        Returns:
+            Result object with is_valid=False and error message
+        """
+        return cls(is_valid=False, error_message=message)

gitwebhooks/server.py

@@ -0,0 +1,128 @@
+"""HTTP server main logic
+
+Creates and runs the HTTP server, handles webhook requests.
+"""
+
+import logging
+import ssl
+import sys
+from http.server import HTTPServer
+from typing import Optional
+
+from gitwebhooks.config.loader import ConfigLoader
+from gitwebhooks.config.registry import ConfigurationRegistry
+from gitwebhooks.config.server import ServerConfig
+from gitwebhooks.handlers.request import WebhookRequestHandler
+from gitwebhooks.logging.setup import setup_logging
+from gitwebhooks.utils.exceptions import ConfigurationError
+
+
+class WebhookServer:
+    """Git Webhooks server main class
+
+    Responsible for creating and running the HTTP server, handling webhook requests.
+    """
+
+    def __init__(self, config_path: str,
+                 registry: Optional[ConfigurationRegistry] = None):
+        """Initialize Webhook server
+
+        Args:
+            config_path: INI configuration file path
+            registry: Configuration registry (optional, for dependency injection)
+
+        Raises:
+            ConfigurationError: Invalid or missing configuration
+        """
+        self.config_path = config_path
+        self.loader = ConfigLoader(config_path)
+        self.registry = registry or ConfigurationRegistry(self.loader)
+        self.server_config = self.registry.server_config
+
+        # Configure logging
+        self._setup_logging()
+
+    def _setup_logging(self) -> None:
+        """Configure logging system
+
+        Sets up logging based on server configuration:
+        - If log_file is empty, output to stdout only
+        - If log_file is non-empty, output to both file and stdout
+
+        Raises:
+            ConfigurationError: Log file cannot be created
+        """
+        setup_logging(self.server_config.log_file)
+
+    def create_http_server(self) -> HTTPServer:
+        """Create HTTP server instance
+
+        Returns:
+            Configured HTTPServer instance
+
+        Raises:
+            ConfigurationError: Invalid server configuration
+            OSError: Failed to bind address
+        """
+        # Configure handler class (inject dependencies)
+        WebhookRequestHandler.configure(
+            self.registry.provider_configs,
+            self.registry.repository_configs
+        )
+
+        # Create server
+        server = HTTPServer(
+            (self.server_config.address, self.server_config.port),
+            WebhookRequestHandler
+        )
+
+        # Configure SSL (if enabled)
+        if self.server_config.ssl_enabled:
+            server.socket = self._wrap_socket_ssl(server.socket)
+
+        return server
+
+    def _wrap_socket_ssl(self, socket):
+        """Wrap socket with SSL
+
+        Args:
+            socket: Raw socket
+
+        Returns:
+            SSL-wrapped socket
+
+        Raises:
+            ConfigurationError: Invalid SSL configuration
+            ssl.SSLError: SSL initialization failed
+        """
+        try:
+            context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            context.load_cert_chain(
+                certfile=self.server_config.ssl_cert_file,
+                keyfile=self.server_config.ssl_key_file
+            )
+            return context.wrap_socket(socket, server_side=True)
+        except (ssl.SSLError, OSError) as e:
+            raise ConfigurationError(f'SSL configuration error: {e}')
+
+    def run(self) -> None:
+        """Start server main loop
+
+        This method blocks until the server is stopped.
+        """
+        server = self.create_http_server()
+
+        ssl_message = ' with SSL' if self.server_config.ssl_enabled else ''
+        logging.info('Serving on %s port %d%s...',
+                    self.server_config.address,
+                    self.server_config.port,
+                    ssl_message)
+
+        try:
+            server.serve_forever()
+        except KeyboardInterrupt:
+            logging.info('Server stopped by user')
+            server.shutdown()
+        except Exception as e:
+            logging.error('Server error: %s', e)
+            raise

gitwebhooks/utils/__init__.py

@@ -0,0 +1,14 @@
+"""Utilities module
+
+Provides constants, exceptions, and utility functions.
+"""
+
+from . import constants
+from . import exceptions
+from . import executor
+
+__all__ = [
+    'constants',
+    'exceptions',
+    'executor',
+]

gitwebhooks/utils/constants.py

@@ -0,0 +1,55 @@
+"""HTTP and response constants definition
+
+Defines all constants used in the project.
+"""
+
+# HTTP Status Codes
+HTTP_OK = 200
+HTTP_BAD_REQUEST = 400
+HTTP_UNAUTHORIZED = 401
+HTTP_FORBIDDEN = 403
+HTTP_NOT_FOUND = 404
+HTTP_NOT_ACCEPTABLE = 406
+HTTP_PRECONDITION_FAILED = 412
+HTTP_INTERNAL_SERVER_ERROR = 500
+
+# HTTP Content Types
+CONTENT_TYPE_JSON = 'application/json'
+CONTENT_TYPE_FORM_URLENCODED = 'application/x-www-form-urlencoded'
+
+# HTTP Headers
+HEADER_CONTENT_TYPE = 'Content-Type'
+HEADER_CONTENT_LENGTH = 'Content-Length'
+HEADER_GITHUB_EVENT = 'X-GitHub-Event'
+HEADER_GITHUB_SIGNATURE = 'X-Hub-Signature'
+HEADER_GITEE_EVENT = 'X-Gitee-Event'
+HEADER_GITEE_TOKEN = 'X-Gitee-Token'
+HEADER_GITEE_TIMESTAMP = 'X-Gitee-Timestamp'
+HEADER_GITLAB_EVENT = 'X-Gitlab-Event'
+HEADER_GITLAB_TOKEN = 'X-Gitlab-Token'
+
+# Response Messages
+MESSAGE_OK = b'OK'
+MESSAGE_FORBIDDEN = 'Forbidden'
+MESSAGE_BAD_REQUEST = 'Bad Request'
+MESSAGE_UNAUTHORIZED = 'Unauthorized'
+MESSAGE_NOT_FOUND = 'Not Found'
+MESSAGE_NOT_ACCEPTABLE = 'Not Acceptable'
+MESSAGE_PRECONDITION_FAILED = 'Precondition Failed'
+MESSAGE_INTERNAL_SERVER_ERROR = 'Internal Server Error'
+
+# Reserved configuration sections
+RESERVED_SECTIONS = {'server', 'ssl', 'github', 'gitee', 'gitlab', 'custom'}
+
+# Configuration file paths (in priority order)
+CONFIG_PATH_USER = "~/.gitwebhooks.ini"
+CONFIG_PATH_LOCAL = "/usr/local/etc/gitwebhooks.ini"
+CONFIG_PATH_SYSTEM = "/etc/gitwebhooks.ini"
+CONFIG_SEARCH_PATHS = [CONFIG_PATH_USER, CONFIG_PATH_LOCAL, CONFIG_PATH_SYSTEM]
+
+# Sensitive field keywords
+SENSITIVE_KEYWORDS = {"secret", "password", "token", "key", "passphrase"}
+
+# ANSI color codes for sensitive field highlighting
+COLOR_SENSITIVE = "\033[33m"  # Yellow
+COLOR_RESET = "\033[0m"

gitwebhooks/utils/exceptions.py

@@ -0,0 +1,34 @@
+"""Custom exception classes
+
+Defines all exception types used in the project.
+"""
+
+
+class WebhookError(Exception):
+    """Webhook processing error base class"""
+    pass
+
+
+class SignatureValidationError(WebhookError):
+    """Signature verification failed"""
+    pass
+
+
+class UnsupportedEventError(WebhookError):
+    """Unsupported event type"""
+    pass
+
+
+class UnsupportedProviderError(WebhookError):
+    """Unrecognized platform provider"""
+    pass
+
+
+class ConfigurationError(WebhookError):
+    """Configuration error or missing"""
+    pass
+
+
+class RequestParseError(WebhookError):
+    """Request parsing failed"""
+    pass

gitwebhooks/utils/executor.py

@@ -0,0 +1,34 @@
+"""Command executor
+
+Asynchronously executes deployment commands.
+"""
+
+import logging
+import subprocess
+
+
+def execute_deployment(repo_name: str, cwd: str, cmd: str) -> None:
+    """Execute deployment command
+
+    Args:
+        repo_name: Repository name (for logging)
+        cwd: Working directory
+        cmd: Command to execute
+
+    Note:
+        Command executes asynchronously without blocking the server.
+        stdin is set to DEVNULL to prevent file descriptor leaks.
+    """
+    logging.info('[%s] Executing: %s', repo_name, cmd)
+
+    try:
+        subprocess.Popen(
+            cmd,
+            cwd=cwd,
+            shell=True,
+            stdin=subprocess.DEVNULL,  # Prevent inheriting stdin, avoid fd leaks
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+    except (OSError, subprocess.SubprocessError) as e:
+        logging.warning('[%s] Execution failed: %s', repo_name, e)