runbooks 0.7.6__py3-none-any.whl → 0.7.9__py3-none-any.whl

runbooks/operate/base.py

@@ -11,14 +11,30 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
+import time
 
 import boto3
 from botocore.exceptions import ClientError, NoCredentialsError
 from loguru import logger
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.panel import Panel
+from rich.table import Table
 
 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,18 +134,28 @@ 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
 
     @property
     def session(self) -> boto3.Session:
@@ -185,7 +211,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,16 +222,24 @@ 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
 
     @aws_api_retry
@@ -307,5 +341,83 @@ 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]")