Bruno Sarlo
41fba59bf7
- Create new dss/ Python package at project root - Move MCP core from tools/dss_mcp/ to dss/mcp/ - Move storage layer from tools/storage/ to dss/storage/ - Move domain logic from dss-mvp1/dss/ to dss/ - Move services from tools/api/services/ to dss/services/ - Move API server to apps/api/ - Move CLI to apps/cli/ - Move Storybook assets to storybook/ - Create unified dss/__init__.py with comprehensive exports - Merge configuration into dss/settings.py (Pydantic-based) - Create pyproject.toml for proper package management - Update startup scripts for new paths - Remove old tools/ and dss-mvp1/ directories Architecture changes: - DSS is now MCP-first with 40+ tools for Claude Code - Clean imports: from dss import Projects, Components, FigmaToolSuite - No more sys.path.insert() hacking - apps/ contains thin application wrappers (API, CLI) - Single unified Python package for all DSS logic 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
265 lines
9.2 KiB
Python
265 lines
9.2 KiB
Python
"""
|
|
Base Integration Classes
|
|
|
|
Provides circuit breaker pattern and base classes for external integrations.
|
|
"""
|
|
|
|
import time
|
|
import asyncio
|
|
from typing import Callable, Any, Optional, Dict
|
|
from dataclasses import dataclass
|
|
from datetime import datetime, timedelta
|
|
from enum import Enum
|
|
|
|
from ..config import mcp_config
|
|
from storage.json_store import Cache, read_json, write_json, SYSTEM_DIR
|
|
|
|
|
|
class CircuitState(Enum):
|
|
"""Circuit breaker states"""
|
|
CLOSED = "closed" # Normal operation
|
|
OPEN = "open" # Failing, reject requests
|
|
HALF_OPEN = "half_open" # Testing if service recovered
|
|
|
|
|
|
@dataclass
|
|
class CircuitBreakerStats:
|
|
"""Circuit breaker statistics"""
|
|
state: CircuitState
|
|
failure_count: int
|
|
success_count: int
|
|
last_failure_time: Optional[float]
|
|
last_success_time: Optional[float]
|
|
opened_at: Optional[float]
|
|
next_retry_time: Optional[float]
|
|
|
|
|
|
class CircuitBreakerOpen(Exception):
|
|
"""Exception raised when circuit breaker is open"""
|
|
pass
|
|
|
|
|
|
class CircuitBreaker:
|
|
"""
|
|
Circuit Breaker pattern implementation.
|
|
|
|
Protects external service calls from cascading failures.
|
|
Three states: CLOSED (normal), OPEN (failing), HALF_OPEN (testing).
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
integration_type: str,
|
|
failure_threshold: int = None,
|
|
timeout_seconds: int = None,
|
|
half_open_max_calls: int = 3
|
|
):
|
|
"""
|
|
Args:
|
|
integration_type: Type of integration (figma, jira, confluence, etc.)
|
|
failure_threshold: Number of failures before opening circuit
|
|
timeout_seconds: Seconds to wait before trying again
|
|
half_open_max_calls: Max successful calls in half-open before closing
|
|
"""
|
|
self.integration_type = integration_type
|
|
self.failure_threshold = failure_threshold or mcp_config.CIRCUIT_BREAKER_FAILURE_THRESHOLD
|
|
self.timeout_seconds = timeout_seconds or mcp_config.CIRCUIT_BREAKER_TIMEOUT_SECONDS
|
|
self.half_open_max_calls = half_open_max_calls
|
|
|
|
# In-memory state (could be moved to Redis for distributed setup)
|
|
self.state = CircuitState.CLOSED
|
|
self.failure_count = 0
|
|
self.success_count = 0
|
|
self.last_failure_time: Optional[float] = None
|
|
self.last_success_time: Optional[float] = None
|
|
self.opened_at: Optional[float] = None
|
|
|
|
async def call(self, func: Callable, *args, **kwargs) -> Any:
|
|
"""
|
|
Call a function through the circuit breaker.
|
|
|
|
Args:
|
|
func: Function to call (can be sync or async)
|
|
*args, **kwargs: Arguments to pass to func
|
|
|
|
Returns:
|
|
Function result
|
|
|
|
Raises:
|
|
CircuitBreakerOpen: If circuit is open
|
|
Exception: Original exception from func if it fails
|
|
"""
|
|
# Check circuit state
|
|
if self.state == CircuitState.OPEN:
|
|
# Check if timeout has elapsed
|
|
if time.time() - self.opened_at < self.timeout_seconds:
|
|
await self._record_failure("Circuit breaker is OPEN", db_only=True)
|
|
raise CircuitBreakerOpen(
|
|
f"{self.integration_type} service is temporarily unavailable. "
|
|
f"Retry after {self._seconds_until_retry():.0f}s"
|
|
)
|
|
else:
|
|
# Timeout elapsed, move to HALF_OPEN
|
|
self.state = CircuitState.HALF_OPEN
|
|
self.success_count = 0
|
|
|
|
# Execute function
|
|
try:
|
|
# Handle both sync and async functions
|
|
if asyncio.iscoroutinefunction(func):
|
|
result = await func(*args, **kwargs)
|
|
else:
|
|
result = func(*args, **kwargs)
|
|
|
|
# Success!
|
|
await self._record_success()
|
|
|
|
# If in HALF_OPEN, check if we can close the circuit
|
|
if self.state == CircuitState.HALF_OPEN:
|
|
if self.success_count >= self.half_open_max_calls:
|
|
self.state = CircuitState.CLOSED
|
|
self.failure_count = 0
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
# Failure
|
|
await self._record_failure(str(e))
|
|
|
|
# Check if we should open the circuit
|
|
if self.failure_count >= self.failure_threshold:
|
|
self.state = CircuitState.OPEN
|
|
self.opened_at = time.time()
|
|
|
|
raise
|
|
|
|
async def _record_success(self):
|
|
"""Record successful call"""
|
|
self.success_count += 1
|
|
self.last_success_time = time.time()
|
|
|
|
# Update database
|
|
await self._update_health_db(is_healthy=True, error=None)
|
|
|
|
async def _record_failure(self, error_message: str, db_only: bool = False):
|
|
"""Record failed call"""
|
|
if not db_only:
|
|
self.failure_count += 1
|
|
self.last_failure_time = time.time()
|
|
|
|
# Update database
|
|
await self._update_health_db(is_healthy=False, error=error_message)
|
|
|
|
async def _update_health_db(self, is_healthy: bool, error: Optional[str]):
|
|
"""Update integration health in database"""
|
|
loop = asyncio.get_event_loop()
|
|
|
|
def update_db():
|
|
try:
|
|
with get_connection() as conn:
|
|
circuit_open_until = None
|
|
if self.state == CircuitState.OPEN and self.opened_at:
|
|
circuit_open_until = datetime.fromtimestamp(
|
|
self.opened_at + self.timeout_seconds
|
|
).isoformat()
|
|
|
|
if is_healthy:
|
|
conn.execute(
|
|
"""
|
|
UPDATE integration_health
|
|
SET is_healthy = 1,
|
|
failure_count = 0,
|
|
last_success_at = CURRENT_TIMESTAMP,
|
|
circuit_open_until = NULL,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE integration_type = ?
|
|
""",
|
|
(self.integration_type,)
|
|
)
|
|
else:
|
|
conn.execute(
|
|
"""
|
|
UPDATE integration_health
|
|
SET is_healthy = 0,
|
|
failure_count = ?,
|
|
last_failure_at = CURRENT_TIMESTAMP,
|
|
circuit_open_until = ?,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE integration_type = ?
|
|
""",
|
|
(self.failure_count, circuit_open_until, self.integration_type)
|
|
)
|
|
except Exception as e:
|
|
print(f"Error updating integration health: {e}")
|
|
|
|
await loop.run_in_executor(None, update_db)
|
|
|
|
def _seconds_until_retry(self) -> float:
|
|
"""Get seconds until circuit can be retried"""
|
|
if self.state != CircuitState.OPEN or not self.opened_at:
|
|
return 0
|
|
elapsed = time.time() - self.opened_at
|
|
remaining = self.timeout_seconds - elapsed
|
|
return max(0, remaining)
|
|
|
|
def get_stats(self) -> CircuitBreakerStats:
|
|
"""Get current circuit breaker statistics"""
|
|
next_retry_time = None
|
|
if self.state == CircuitState.OPEN and self.opened_at:
|
|
next_retry_time = self.opened_at + self.timeout_seconds
|
|
|
|
return CircuitBreakerStats(
|
|
state=self.state,
|
|
failure_count=self.failure_count,
|
|
success_count=self.success_count,
|
|
last_failure_time=self.last_failure_time,
|
|
last_success_time=self.last_success_time,
|
|
opened_at=self.opened_at,
|
|
next_retry_time=next_retry_time
|
|
)
|
|
|
|
|
|
class BaseIntegration:
|
|
"""Base class for all external integrations"""
|
|
|
|
def __init__(self, integration_type: str, config: Dict[str, Any]):
|
|
"""
|
|
Args:
|
|
integration_type: Type of integration (figma, jira, etc.)
|
|
config: Integration configuration (decrypted)
|
|
"""
|
|
self.integration_type = integration_type
|
|
self.config = config
|
|
self.circuit_breaker = CircuitBreaker(integration_type)
|
|
|
|
async def call_api(self, func: Callable, *args, **kwargs) -> Any:
|
|
"""
|
|
Call external API through circuit breaker.
|
|
|
|
Args:
|
|
func: API function to call
|
|
*args, **kwargs: Arguments to pass
|
|
|
|
Returns:
|
|
API response
|
|
|
|
Raises:
|
|
CircuitBreakerOpen: If circuit is open
|
|
Exception: Original API exception
|
|
"""
|
|
return await self.circuit_breaker.call(func, *args, **kwargs)
|
|
|
|
def get_health(self) -> Dict[str, Any]:
|
|
"""Get integration health status"""
|
|
stats = self.circuit_breaker.get_stats()
|
|
return {
|
|
"integration_type": self.integration_type,
|
|
"state": stats.state.value,
|
|
"is_healthy": stats.state == CircuitState.CLOSED,
|
|
"failure_count": stats.failure_count,
|
|
"success_count": stats.success_count,
|
|
"last_failure_time": stats.last_failure_time,
|
|
"last_success_time": stats.last_success_time,
|
|
"next_retry_time": stats.next_retry_time
|
|
}
|