runbooks 0.7.7__py3-none-any.whl → 0.9.0__py3-none-any.whl

runbooks/operate/base.py

@@ -6,19 +6,40 @@ ensuring consistent patterns, safety features, and enterprise-grade reliability
 across all service-specific operations.
 """
 
+import asyncio
+import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 import boto3
 from botocore.exceptions import ClientError, NoCredentialsError
 from loguru import logger
-
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from runbooks.common.cross_module_integration import DataFlowType, EnterpriseCrossModuleIntegrator
+from runbooks.common.mcp_integration import EnterpriseMCPIntegrator, MCPOperationType
+from runbooks.common.profile_utils import create_operational_session, get_profile_for_operation
+from runbooks.common.rich_utils import print_error, print_info, print_success, print_warning
 from runbooks.inventory.models.account import AWSAccount
 from runbooks.inventory.utils.aws_helpers import aws_api_retry, get_boto3_session
 
+# Enterprise 4-Profile Architecture - Proven FinOps Patterns
+ENTERPRISE_PROFILES = {
+    "BILLING_PROFILE": "ams-admin-Billing-ReadOnlyAccess-909135376185",
+    "MANAGEMENT_PROFILE": "ams-admin-ReadOnlyAccess-909135376185",
+    "CENTRALISED_OPS_PROFILE": "ams-centralised-ops-ReadOnlyAccess-335083429030",
+    "SINGLE_ACCOUNT_PROFILE": "ams-shared-services-non-prod-ReadOnlyAccess-499201730520",
+}
+
+# Rich console instance for consistent formatting
+console = Console()
+
 
 class OperationStatus(Enum):
     """Status of an AWS operation."""
@@ -118,19 +139,36 @@ class BaseOperation(ABC):
 
     def __init__(self, profile: Optional[str] = None, region: Optional[str] = None, dry_run: bool = False):
         """
-        Initialize base operation class.
+        Initialize base operation class with enterprise patterns.
 
         Args:
-            profile: AWS profile name for authentication
+            profile: AWS profile name for authentication (supports ENTERPRISE_PROFILES)
             region: AWS region for operations
             dry_run: Enable dry-run mode for safe testing
         """
-        self.profile = profile
+        # Support enterprise profile shortcuts
+        if profile in ENTERPRISE_PROFILES:
+            self.profile = ENTERPRISE_PROFILES[profile]
+            console.print(f"[blue]Using enterprise profile: {profile} -> {self.profile}[/blue]")
+        else:
+            self.profile = profile
+
         self.region = region or "us-east-1"
         self.dry_run = dry_run
         self._session = None
         self._clients = {}
 
+        # Performance benchmarking
+        self._operation_start_time = None
+        self._performance_target = 2.0  # <2s target for operate operations
+
+        # Phase 4: MCP Integration Framework
+        self.mcp_integrator = EnterpriseMCPIntegrator(self.profile)
+        self.cross_module_integrator = EnterpriseCrossModuleIntegrator(self.profile)
+        self.enable_mcp_validation = True
+
+        print_info(f"BaseOperation initialized with MCP integration for {self.service_name or 'unknown'} service")
+
     @property
     def session(self) -> boto3.Session:
         """Get or create AWS session."""
@@ -185,7 +223,7 @@ class BaseOperation(ABC):
 
     def confirm_operation(self, context: OperationContext, resource_id: str, operation_type: str) -> bool:
         """
-        Request user confirmation for destructive operations.
+        Request user confirmation for destructive operations with Rich CLI.
 
         Args:
             context: Operation context
@@ -196,15 +234,27 @@ class BaseOperation(ABC):
             True if operation is confirmed
         """
         if context.dry_run:
-            logger.info(f"[DRY-RUN] Would perform {operation_type} on {resource_id}")
+            console.print(
+                Panel(
+                    f"[yellow]Would perform {operation_type} on {resource_id}[/yellow]",
+                    title="🏃 DRY-RUN MODE",
+                    border_style="yellow",
+                )
+            )
             return True
 
         if context.force or not self.requires_confirmation:
             return True
 
-        # In a real implementation, this would integrate with CLI for confirmation
-        logger.warning(
-            f"Destructive operation: {operation_type} on {resource_id} in account {context.account.account_id}"
+        # Rich CLI confirmation display
+        console.print(
+            Panel(
+                f"[red]⚠️  Destructive operation: {operation_type}[/red]\n"
+                f"[white]Resource: {resource_id}[/white]\n"
+                f"[white]Account: {context.account.account_id}[/white]",
+                title="🚨 CONFIRMATION REQUIRED",
+                border_style="red",
+            )
         )
         return True  # Simplified for this implementation
 
@@ -307,5 +357,235 @@ class BaseOperation(ABC):
             List of historical operation results
         """
         # In a real implementation, this would query a database or log store
-        logger.info(f"Operation history requested for {resource_id or 'all resources'}")
+        console.print(f"[blue]📊 Operation history requested for {resource_id or 'all resources'}[/blue]")
         return []
+
+    def start_performance_benchmark(self) -> None:
+        """Start performance timing for operation benchmarking."""
+        self._operation_start_time = time.time()
+
+    def end_performance_benchmark(self, operation_name: str) -> float:
+        """
+        End performance timing and display results.
+
+        Args:
+            operation_name: Name of the operation for reporting
+
+        Returns:
+            Elapsed time in seconds
+        """
+        if self._operation_start_time is None:
+            return 0.0
+
+        elapsed_time = time.time() - self._operation_start_time
+
+        # Performance validation against target
+        if elapsed_time <= self._performance_target:
+            console.print(
+                f"[green]⚡ {operation_name} completed in {elapsed_time:.2f}s (target: {self._performance_target}s) ✅[/green]"
+            )
+        else:
+            console.print(
+                f"[yellow]⚠️  {operation_name} completed in {elapsed_time:.2f}s (exceeded target: {self._performance_target}s)[/yellow]"
+            )
+
+        self._operation_start_time = None
+        return elapsed_time
+
+    def display_operation_summary(self, results: List[OperationResult]) -> None:
+        """
+        Display operation summary using Rich table formatting.
+
+        Args:
+            results: List of operation results to summarize
+        """
+        if not results:
+            console.print("[yellow]No operations to display[/yellow]")
+            return
+
+        table = Table(title="🔧 Operation Summary")
+        table.add_column("Operation", style="cyan")
+        table.add_column("Resource", style="magenta")
+        table.add_column("Status", style="green")
+        table.add_column("Duration", style="blue")
+
+        success_count = 0
+        total_count = len(results)
+
+        for result in results:
+            status_icon = "✅" if result.success else "❌"
+            status_text = f"{status_icon} {result.status.value}"
+
+            duration = "N/A"
+            if result.completed_at and result.started_at:
+                elapsed = (result.completed_at - result.started_at).total_seconds()
+                duration = f"{elapsed:.2f}s"
+
+            if result.success:
+                success_count += 1
+
+            table.add_row(result.operation_type, result.resource_id, status_text, duration)
+
+        console.print(table)
+
+        # Success rate summary
+        success_rate = (success_count / total_count) * 100 if total_count > 0 else 0
+        if success_rate >= 95:
+            console.print(
+                f"[green]🎯 Success Rate: {success_rate:.1f}% ({success_count}/{total_count}) - Excellent![/green]"
+            )
+        elif success_rate >= 90:
+            console.print(
+                f"[yellow]📊 Success Rate: {success_rate:.1f}% ({success_count}/{total_count}) - Good[/yellow]"
+            )
+        else:
+            console.print(
+                f"[red]⚠️  Success Rate: {success_rate:.1f}% ({success_count}/{total_count}) - Needs Attention[/red]"
+            )
+
+    # Phase 4: MCP Integration Methods
+    async def validate_operation_with_mcp(self, operation_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Validate operation results using MCP integration.
+
+        Args:
+            operation_data: Operation results to validate
+
+        Returns:
+            Dictionary containing validation results
+        """
+        try:
+            if not self.enable_mcp_validation:
+                return {"validation_skipped": True, "reason": "MCP validation disabled"}
+
+            print_info("Validating operation results with MCP integration")
+
+            validation_result = await self.mcp_integrator.validate_operate_operations(operation_data)
+
+            if validation_result.success:
+                print_success(f"Operation MCP validation passed: {validation_result.accuracy_score}% accuracy")
+            else:
+                print_warning("Operation MCP validation encountered issues")
+
+            return validation_result.to_dict()
+
+        except Exception as e:
+            print_error(f"MCP validation failed: {str(e)[:50]}...")
+            return {"validation_error": str(e), "validation_failed": True}
+
+    async def prepare_data_for_finops_analysis(self, operation_results: List[OperationResult]) -> Dict[str, Any]:
+        """
+        Prepare operation results for FinOps cost analysis integration.
+
+        Args:
+            operation_results: List of operation results
+
+        Returns:
+            Dictionary formatted for FinOps module consumption
+        """
+        try:
+            print_info("Preparing operation data for FinOps analysis")
+
+            # Convert operation results to data flow format
+            operation_data = {
+                "operations": [
+                    {
+                        "id": result.operation_id,
+                        "type": result.operation_type,
+                        "resource_id": result.resource_id,
+                        "resource_type": result.resource_type,
+                        "account_id": result.account_id,
+                        "region": result.region,
+                        "success": result.success,
+                        "started_at": result.started_at.isoformat(),
+                        "completed_at": result.completed_at.isoformat() if result.completed_at else None,
+                        "metadata": result.metadata,
+                    }
+                    for result in operation_results
+                ]
+            }
+
+            data_flow_result = await self.cross_module_integrator.execute_data_flow(
+                flow_type=DataFlowType.OPERATE_TO_FINOPS, source_data=operation_data
+            )
+
+            if data_flow_result.success:
+                print_success("Operate → FinOps data flow completed successfully")
+                return data_flow_result.transformed_data
+            else:
+                print_error(f"Data flow failed: {', '.join(data_flow_result.error_details)}")
+                return {}
+
+        except Exception as e:
+            print_error(f"Failed to prepare data for FinOps analysis: {str(e)}")
+            return {}
+
+    def execute_operation_with_validation(
+        self, context: OperationContext, operation_func: Callable, *args, **kwargs
+    ) -> List[OperationResult]:
+        """
+        Execute operation with automatic MCP validation and performance tracking.
+
+        Args:
+            context: Operation context
+            operation_func: Operation function to execute
+            *args: Arguments for operation function
+            **kwargs: Keyword arguments for operation function
+
+        Returns:
+            List of operation results with MCP validation
+        """
+        self.start_performance_benchmark()
+
+        try:
+            # Execute the operation
+            results = operation_func(context, *args, **kwargs)
+
+            # Add MCP validation asynchronously if enabled
+            if self.enable_mcp_validation and results:
+                try:
+                    operation_data = {
+                        "operations": [result.__dict__ for result in results],
+                        "context": context.__dict__,
+                    }
+
+                    validation_result = asyncio.run(self.validate_operation_with_mcp(operation_data))
+
+                    # Add validation results to operation metadata
+                    for result in results:
+                        result.metadata["mcp_validation"] = validation_result
+
+                except Exception as e:
+                    print_warning(f"MCP validation failed: {str(e)[:50]}... - operation completed without validation")
+
+            # End performance benchmark
+            elapsed_time = self.end_performance_benchmark(f"{context.operation_type} operation")
+
+            # Add performance metrics to results
+            for result in results:
+                result.metadata["performance_seconds"] = elapsed_time
+                result.metadata["performance_target_met"] = elapsed_time <= self._performance_target
+
+            return results
+
+        except Exception as e:
+            self.end_performance_benchmark(f"{context.operation_type} operation (failed)")
+            raise e
+
+    def get_mcp_integration_status(self) -> Dict[str, Any]:
+        """
+        Get current MCP integration status and configuration.
+
+        Returns:
+            Dictionary containing MCP integration details
+        """
+        return {
+            "service_name": self.service_name,
+            "mcp_validation_enabled": self.enable_mcp_validation,
+            "mcp_integrator_initialized": self.mcp_integrator is not None,
+            "cross_module_integrator_initialized": self.cross_module_integrator is not None,
+            "supported_operations": list(self.supported_operations),
+            "performance_target_seconds": self._performance_target,
+            "profile": self.profile,
+            "region": self.region,
+        }