kailash 0.8.4__py3-none-any.whl → 0.8.5__py3-none-any.whl

kailash/core/resilience/circuit_breaker.py

@@ -396,6 +396,16 @@ class ConnectionCircuitBreaker(Generic[T]):
         if listener in self._listeners:
             self._listeners.remove(listener)
 
+    @property
+    def success_count(self) -> int:
+        """Get number of successful calls."""
+        return self.metrics.successful_calls
+
+    @property
+    def failure_count(self) -> int:
+        """Get number of failed calls."""
+        return self.metrics.failed_calls
+
     def get_status(self) -> Dict[str, Any]:
         """Get current circuit breaker status."""
         return {
@@ -435,10 +445,16 @@ class ConnectionCircuitBreaker(Generic[T]):
 class CircuitBreakerManager:
     """Manages multiple circuit breakers for different resources."""
 
-    def __init__(self):
+    def __init__(self, performance_monitor=None):
         """Initialize circuit breaker manager."""
         self._breakers: Dict[str, ConnectionCircuitBreaker] = {}
         self._default_config = CircuitBreakerConfig()
+        self._performance_monitor = performance_monitor
+        self._patterns = {
+            "database": CircuitBreakerConfig(failure_threshold=5, recovery_timeout=60),
+            "api": CircuitBreakerConfig(failure_threshold=3, recovery_timeout=30),
+            "cache": CircuitBreakerConfig(failure_threshold=2, recovery_timeout=15),
+        }
 
     def get_or_create(
         self, name: str, config: Optional[CircuitBreakerConfig] = None
@@ -450,6 +466,60 @@ class CircuitBreakerManager:
             )
         return self._breakers[name]
 
+    def create_circuit_breaker(
+        self, name: str, config: Optional[CircuitBreakerConfig] = None, pattern: Optional[str] = None
+    ) -> ConnectionCircuitBreaker:
+        """Create a new circuit breaker with optional pattern-based configuration."""
+        if pattern and pattern in self._patterns:
+            config = config or self._patterns[pattern]
+        return self.get_or_create(name, config)
+
+    async def execute_with_circuit_breaker(
+        self, name: str, func: Callable, fallback: Optional[Callable] = None
+    ):
+        """Execute a function with circuit breaker protection."""
+        cb = self.get_or_create(name)
+        try:
+            result = await cb.call(func)
+            return result
+        except CircuitBreakerError:
+            if fallback:
+                if asyncio.iscoroutinefunction(fallback):
+                    return await fallback()
+                else:
+                    return fallback()
+            raise
+
+    def get_circuit_breaker(self, name: str) -> Optional[ConnectionCircuitBreaker]:
+        """Get an existing circuit breaker by name."""
+        return self._breakers.get(name)
+
+    def get_all_circuit_states(self) -> Dict[str, Dict[str, Any]]:
+        """Get the state of all circuit breakers."""
+        return {name: cb.get_status() for name, cb in self._breakers.items()}
+
+    def force_open_circuit_breaker(self, name: str) -> bool:
+        """Manually open a circuit breaker."""
+        cb = self._breakers.get(name)
+        if cb:
+            asyncio.create_task(cb.force_open("Manual override"))
+            return True
+        return False
+
+    def reset_circuit_breaker(self, name: str) -> bool:
+        """Reset a circuit breaker to closed state."""
+        cb = self._breakers.get(name)
+        if cb:
+            asyncio.create_task(cb.reset())
+            return True
+        return False
+
+    def add_global_callback(self, callback: Callable):
+        """Add a global callback for circuit breaker state changes."""
+        # For now, add to all existing breakers
+        for cb in self._breakers.values():
+            cb.add_listener(callback)
+
     def get_all_status(self) -> Dict[str, Dict[str, Any]]:
         """Get status of all circuit breakers."""
         return {name: breaker.get_status() for name, breaker in self._breakers.items()}

kailash/core/resilience/health_monitor.py

@@ -576,3 +576,175 @@ async def quick_health_check(service_name: str) -> bool:
         return result.is_healthy if result else False
     except Exception:
         return False
+
+
+@dataclass
+class HealthSummary:
+    """Health summary for all checks."""
+    
+    total_checks: int
+    healthy_checks: int
+    degraded_checks: int
+    unhealthy_checks: int
+    overall_status: HealthStatus
+    details: List[HealthCheckResult]
+
+
+class HealthCheckManager:
+    """Manager for orchestrating multiple health checks with configuration."""
+    
+    def __init__(self, config: Dict[str, Any]):
+        """Initialize health check manager with configuration."""
+        self.config = config
+        self.enabled = config.get("enabled", True)
+        self.default_interval = config.get("default_interval", 30.0)
+        self.parallel_checks = config.get("parallel_checks", True)
+        self.max_concurrent_checks = config.get("max_concurrent_checks", 10)
+        
+        self.health_checks: Dict[str, HealthCheck] = {}
+        self.check_intervals: Dict[str, float] = {}
+        self.last_results: Dict[str, HealthCheckResult] = {}
+        self.history: Dict[str, List[HealthCheckResult]] = {}
+        self.status_change_callbacks: List[Callable] = []
+        self._running = False
+        
+    def register_health_check(self, health_check: HealthCheck, interval: float = None):
+        """Register a health check with optional interval."""
+        check_name = health_check.check_name
+        self.health_checks[check_name] = health_check
+        self.check_intervals[check_name] = interval or self.default_interval
+        self.history[check_name] = []
+        
+    async def run_health_check(self, check_name: str) -> HealthCheckResult:
+        """Run a specific health check."""
+        if check_name not in self.health_checks:
+            raise ValueError(f"Health check '{check_name}' not found")
+            
+        health_check = self.health_checks[check_name]
+        result = await health_check.check_health()
+        
+        # Store result
+        self.last_results[check_name] = result
+        self.history[check_name].append(result)
+        
+        # Check for status changes
+        await self._check_status_change(check_name, result)
+        
+        return result
+        
+    async def run_all_health_checks(self) -> List[HealthCheckResult]:
+        """Run all registered health checks."""
+        if not self.health_checks:
+            return []
+            
+        if self.parallel_checks:
+            # Run checks in parallel
+            tasks = [
+                self.run_health_check(check_name) 
+                for check_name in self.health_checks.keys()
+            ]
+            
+            # Limit concurrency
+            semaphore = asyncio.Semaphore(self.max_concurrent_checks)
+            
+            async def run_with_semaphore(task):
+                async with semaphore:
+                    return await task
+                    
+            results = await asyncio.gather(*[
+                run_with_semaphore(task) for task in tasks
+            ])
+        else:
+            # Run checks sequentially
+            results = []
+            for check_name in self.health_checks.keys():
+                result = await self.run_health_check(check_name)
+                results.append(result)
+                
+        return results
+        
+    async def get_health_summary(self) -> HealthSummary:
+        """Get summary of all health checks."""
+        results = await self.run_all_health_checks()
+        
+        healthy_count = sum(1 for r in results if r.status == HealthStatus.HEALTHY)
+        degraded_count = sum(1 for r in results if r.status == HealthStatus.DEGRADED)  
+        unhealthy_count = sum(1 for r in results if r.status == HealthStatus.UNHEALTHY)
+        
+        # Determine overall status
+        if unhealthy_count > 0:
+            overall_status = HealthStatus.UNHEALTHY
+        elif degraded_count > 0:
+            overall_status = HealthStatus.DEGRADED
+        elif healthy_count > 0:
+            overall_status = HealthStatus.HEALTHY
+        else:
+            overall_status = HealthStatus.UNKNOWN
+            
+        return HealthSummary(
+            total_checks=len(results),
+            healthy_checks=healthy_count,
+            degraded_checks=degraded_count,
+            unhealthy_checks=unhealthy_count,
+            overall_status=overall_status,
+            details=results
+        )
+        
+    def add_status_change_callback(self, callback: Callable):
+        """Add callback for status changes."""
+        self.status_change_callbacks.append(callback)
+        
+    def get_health_history(self, check_name: str, limit: int = None) -> List[HealthCheckResult]:
+        """Get health check history for a specific check."""
+        history = self.history.get(check_name, [])
+        if limit:
+            return history[-limit:]
+        return history
+        
+    async def _check_status_change(self, check_name: str, result: HealthCheckResult):
+        """Check if status has changed and notify callbacks."""
+        if check_name in self.last_results:
+            previous = self.last_results[check_name]
+            if previous.status != result.status:
+                # Status changed, notify callbacks
+                for callback in self.status_change_callbacks:
+                    try:
+                        await callback(check_name, result)
+                    except Exception as e:
+                        logger.error(f"Error in status change callback: {e}")
+                        
+    async def shutdown(self):
+        """Shutdown the health check manager."""
+        self._running = False
+        # Any cleanup logic here
+
+
+# Add convenience functions for registering health checks
+async def register_database_health_check(name: str, database_node, interval: float = 30.0):
+    """Register a database health check with global manager."""
+    health_check = DatabaseHealthCheck(name, database_node)
+    manager = get_health_manager()
+    if hasattr(manager, 'register_health_check'):
+        manager.register_health_check(health_check, interval)
+    else:
+        manager.register_check(name, health_check)
+
+
+async def register_memory_health_check(name: str, warning_threshold: float = 80.0, 
+                                     critical_threshold: float = 95.0, interval: float = 30.0):
+    """Register a memory health check with global manager."""
+    # This would need MemoryHealthCheck implementation
+    pass
+
+
+async def register_custom_health_check(name: str, check_func: Callable, 
+                                     interval: float = 30.0, timeout: float = 10.0):
+    """Register a custom health check with global manager."""
+    # This would need CustomHealthCheck implementation  
+    pass
+
+
+def get_health_manager():
+    """Get the global health manager instance."""
+    # Return a default HealthMonitor for now
+    return HealthMonitor()

kailash/edge/compliance.py

@@ -785,6 +785,39 @@ class ComplianceRouter:
         """Get recent compliance decisions from audit log."""
         return self.audit_log[-limit:]
 
+    def is_compliant_location(
+        self,
+        location: "EdgeLocation",
+        data_class: DataClassification,
+        required_zones: List[str],
+    ) -> bool:
+        """Check if a location is compliant for given data class and zones.
+
+        Args:
+            location: Edge location to check
+            data_class: Classification of the data
+            required_zones: Required compliance zones
+
+        Returns:
+            True if location is compliant
+        """
+        # Avoid circular import
+        from kailash.edge.location import EdgeRegion
+
+        # Check if location has all required compliance zones
+        location_zones = [z.value for z in location.compliance_zones]
+
+        # For GDPR compliance, PII/EU_PERSONAL data must be in EU regions or GDPR-compliant zones
+        if "gdpr" in required_zones and data_class in [
+            DataClassification.PII,
+            DataClassification.EU_PERSONAL,
+        ]:
+            # Check if location has GDPR compliance zone
+            return "gdpr" in location_zones
+
+        # For other cases, check if location has the required zones
+        return all(zone in location_zones for zone in required_zones)
+
     def get_compliance_summary(self) -> Dict[str, Any]:
         """Get summary of compliance decisions and performance."""
         if not self.audit_log: