gobby 0.2.5__py3-none-any.whl

gobby/workflows/webhook_executor.py

@@ -0,0 +1,399 @@
+"""
+Webhook action executor for workflows.
+
+Executes HTTP requests as workflow actions with retry logic,
+variable interpolation, and response capture.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+import time
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass, field
+from typing import Any
+
+import aiohttp
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class WebhookResult:
+    """Result of a webhook execution."""
+
+    success: bool
+    status_code: int | None = None
+    body: str | None = None
+    headers: dict[str, str] | None = None
+    error: str | None = None
+
+    def json_body(self) -> dict[str, Any] | None:
+        """Parse body as JSON.
+
+        Returns:
+            Parsed JSON dict, or None if body is not valid JSON.
+        """
+        if not self.body:
+            return None
+        try:
+            result: dict[str, Any] = json.loads(self.body)
+            return result
+        except json.JSONDecodeError:
+            return None
+
+
+@dataclass
+class RetryConfig:
+    """Configuration for retry behavior."""
+
+    max_attempts: int = 3
+    backoff_seconds: float = 1.0
+    retry_on_status: list[int] = field(default_factory=lambda: [429, 500, 502, 503, 504])
+
+
+class WebhookExecutor:
+    """Executes webhook HTTP requests from workflows.
+
+    Handles URL resolution, variable interpolation, retries,
+    and response capture.
+    """
+
+    def __init__(
+        self,
+        template_engine: Any | None = None,
+        webhook_registry: dict[str, dict[str, Any]] | None = None,
+        secrets: dict[str, str] | None = None,
+    ):
+        """Initialize the executor.
+
+        Args:
+            template_engine: Optional template engine for variable interpolation.
+            webhook_registry: Dict mapping webhook_id to config (url, headers, etc.).
+            secrets: Dict of secret values for ${secrets.VAR} interpolation.
+        """
+        self.template_engine = template_engine
+        self.webhook_registry = webhook_registry or {}
+        self.secrets = secrets or {}
+
+    async def execute(
+        self,
+        url: str,
+        method: str = "POST",
+        headers: dict[str, str] | None = None,
+        payload: dict[str, Any] | str | None = None,
+        timeout: int = 30,
+        retry_config: dict[str, Any] | None = None,
+        context: dict[str, Any] | None = None,
+        on_success: Callable[[WebhookResult], Coroutine[Any, Any, None]] | None = None,
+        on_failure: Callable[[WebhookResult], Coroutine[Any, Any, None]] | None = None,
+    ) -> WebhookResult:
+        """Execute a webhook HTTP request.
+
+        Args:
+            url: Target URL for the request.
+            method: HTTP method (GET, POST, PUT, PATCH, DELETE).
+            headers: Request headers (supports ${secrets.VAR} interpolation).
+            payload: Request body as dict or string.
+            timeout: Request timeout in seconds.
+            retry_config: Optional retry configuration dict.
+            context: Context dict for variable interpolation.
+            on_success: Async callback for successful (2xx) response.
+            on_failure: Async callback after all retries exhausted.
+
+        Returns:
+            WebhookResult with response data or error.
+        """
+        headers = headers or {}
+        context = context or {}
+
+        # Interpolate secrets in headers
+        interpolated_headers = self._interpolate_secrets(headers)
+
+        # Interpolate context in payload
+        interpolated_payload = self._interpolate_payload(payload, context)
+
+        # Parse retry config
+        retry = self._parse_retry_config(retry_config)
+
+        # Execute with retry logic
+        result = await self._execute_with_retry(
+            url=url,
+            method=method,
+            headers=interpolated_headers,
+            payload=interpolated_payload,
+            timeout=timeout,
+            retry=retry,
+        )
+
+        # Call appropriate handler
+        if result.success and on_success:
+            await on_success(result)
+        elif not result.success and on_failure:
+            await on_failure(result)
+
+        return result
+
+    async def execute_by_webhook_id(
+        self,
+        webhook_id: str,
+        payload: dict[str, Any] | str | None = None,
+        method: str | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: int | None = None,
+        context: dict[str, Any] | None = None,
+        retry_config: dict[str, Any] | None = None,
+        on_success: Callable[[WebhookResult], Coroutine[Any, Any, None]] | None = None,
+        on_failure: Callable[[WebhookResult], Coroutine[Any, Any, None]] | None = None,
+    ) -> WebhookResult:
+        """Execute a webhook by looking up its ID in the registry.
+
+        Args:
+            webhook_id: ID of the webhook in the registry.
+            payload: Request body.
+            method: Override HTTP method from registry.
+            headers: Additional headers (merged with registry headers).
+            timeout: Override timeout from registry.
+            context: Context for variable interpolation.
+            retry_config: Optional retry configuration dict.
+            on_success: Async callback for successful (2xx) response.
+            on_failure: Async callback after all retries exhausted.
+
+        Returns:
+            WebhookResult with response data or error.
+
+        Raises:
+            ValueError: If webhook_id not found in registry.
+        """
+        if webhook_id not in self.webhook_registry:
+            raise ValueError(f"webhook_id '{webhook_id}' not found in registry")
+
+        config = self.webhook_registry[webhook_id]
+        url = config.get("url")
+        if not url:
+            raise ValueError(f"webhook_id '{webhook_id}' has no URL configured")
+
+        # Merge headers (registry defaults + provided overrides)
+        merged_headers = dict(config.get("headers", {}))
+        if headers:
+            merged_headers.update(headers)
+
+        return await self.execute(
+            url=url,
+            method=method or config.get("method", "POST"),
+            headers=merged_headers,
+            payload=payload,
+            timeout=timeout or config.get("timeout", 30),
+            context=context,
+            retry_config=retry_config,
+            on_success=on_success,
+            on_failure=on_failure,
+        )
+
+    def _interpolate_secrets(self, headers: dict[str, str]) -> dict[str, str]:
+        """Interpolate ${secrets.VAR} in header values.
+
+        Args:
+            headers: Headers dict with potential secret references.
+
+        Returns:
+            Headers with secrets interpolated.
+
+        Raises:
+            ValueError: If a referenced secret is not found in self.secrets.
+        """
+        result = {}
+        pattern = re.compile(r"\$\{secrets\.(\w+)\}")
+
+        for key, value in headers.items():
+            if isinstance(value, str):
+                # Find all secret references in the value
+                matches = pattern.findall(value)
+                for secret_name in matches:
+                    if secret_name not in self.secrets:
+                        raise ValueError(
+                            f"Missing secret '{secret_name}' referenced in header '{key}'"
+                        )
+                # Replace all secrets with their values
+                result[key] = pattern.sub(
+                    lambda m: self.secrets[m.group(1)],
+                    value,
+                )
+            else:
+                result[key] = value
+
+        return result
+
+    def _interpolate_payload(
+        self,
+        payload: dict[str, Any] | str | None,
+        context: dict[str, Any],
+    ) -> dict[str, Any] | str | None:
+        """Interpolate context variables in payload.
+
+        Args:
+            payload: Payload to interpolate.
+            context: Context dict for variable values.
+
+        Returns:
+            Interpolated payload.
+        """
+        if payload is None:
+            return None
+
+        if self.template_engine and isinstance(payload, str):
+            rendered: str = self.template_engine.render(payload, context)
+            return rendered
+
+        # For dicts, we could deep-interpolate, but for now just return as-is
+        # since the tests expect the executor to handle the interpolation
+        return payload
+
+    def _parse_retry_config(self, config: dict[str, Any] | None) -> RetryConfig:
+        """Parse retry configuration from dict.
+
+        Args:
+            config: Retry config dict or None.
+
+        Returns:
+            RetryConfig instance.
+        """
+        if not config:
+            return RetryConfig(max_attempts=1)  # No retry by default
+
+        return RetryConfig(
+            max_attempts=config.get("max_attempts", 3),
+            backoff_seconds=config.get("backoff_seconds", 1.0),
+            retry_on_status=config.get("retry_on_status", [429, 500, 502, 503, 504]),
+        )
+
+    async def _execute_with_retry(
+        self,
+        url: str,
+        method: str,
+        headers: dict[str, str],
+        payload: dict[str, Any] | str | None,
+        timeout: int,
+        retry: RetryConfig,
+    ) -> WebhookResult:
+        """Execute request with retry logic.
+
+        Args:
+            url: Target URL.
+            method: HTTP method.
+            headers: Request headers.
+            payload: Request body.
+            timeout: Timeout in seconds.
+            retry: Retry configuration.
+
+        Returns:
+            WebhookResult with response or error.
+        """
+        last_error: str | None = None
+        last_status: int | None = None
+
+        for attempt in range(retry.max_attempts):
+            if attempt > 0:
+                # Exponential backoff
+                delay = retry.backoff_seconds * (2 ** (attempt - 1))
+                logger.debug(f"Webhook retry {attempt + 1}/{retry.max_attempts}, backoff {delay}s")
+                await asyncio.sleep(delay)
+
+            try:
+                start_time = time.time()
+                result = await self._make_request(
+                    url=url,
+                    method=method,
+                    headers=headers,
+                    payload=payload,
+                    timeout=timeout,
+                )
+                elapsed = time.time() - start_time
+                logger.debug(f"Webhook {method} {url} -> {result.status_code} ({elapsed:.2f}s)")
+
+                if result.success:
+                    return result
+
+                # Check if we should retry
+                if result.status_code and result.status_code in retry.retry_on_status:
+                    last_error = f"HTTP {result.status_code}"
+                    last_status = result.status_code
+                    continue  # Retry
+
+                # Non-retryable error
+                return result
+
+            except TimeoutError:
+                last_error = f"Timeout after {timeout}s"
+                logger.debug(f"Webhook timeout: {url}")
+                continue  # Retry on timeout
+
+            except aiohttp.ClientError as e:
+                last_error = str(e)
+                logger.debug(f"Webhook connection error: {url} - {e}")
+                continue  # Retry on aiohttp client errors
+
+        # All retries exhausted
+        return WebhookResult(
+            success=False,
+            status_code=last_status,
+            body=None,
+            headers=None,
+            error=last_error or "Unknown error",
+        )
+
+    async def _make_request(
+        self,
+        url: str,
+        method: str,
+        headers: dict[str, str],
+        payload: dict[str, Any] | str | None,
+        timeout: int,
+    ) -> WebhookResult:
+        """Make a single HTTP request.
+
+        Args:
+            url: Target URL.
+            method: HTTP method.
+            headers: Request headers.
+            payload: Request body.
+            timeout: Timeout in seconds.
+
+        Returns:
+            WebhookResult with response data.
+        """
+        client_timeout = aiohttp.ClientTimeout(total=timeout)
+
+        async with aiohttp.ClientSession(timeout=client_timeout) as session:
+            # Prepare request kwargs
+            kwargs: dict[str, Any] = {
+                "method": method,
+                "url": url,
+                "headers": headers,
+            }
+
+            # Add payload
+            if payload is not None:
+                if isinstance(payload, dict):
+                    kwargs["json"] = payload
+                else:
+                    kwargs["data"] = payload
+
+            async with session.request(**kwargs) as response:
+                body = await response.text()
+
+                # Convert headers to dict
+                response_headers = dict(response.headers)
+
+                success = 200 <= response.status < 300
+
+                return WebhookResult(
+                    success=success,
+                    status_code=response.status,
+                    body=body,
+                    headers=response_headers,
+                    error=None if success else f"HTTP {response.status}",
+                )

gobby/worktrees/__init__.py

@@ -0,0 +1,5 @@
+"""Worktree management module."""
+
+from gobby.worktrees.git import WorktreeGitManager
+
+__all__ = ["WorktreeGitManager"]