runbooks 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

runbooks/remediation/base.py

@@ -392,7 +392,7 @@ class BaseRemediation(ABC):
         if self._session is None:
             try:
                 # Use management profile for remediation operations requiring cross-account access
-                self._session = create_management_session(profile=self.profile)
+                self._session = create_management_session(profile_name=self.profile)
             except Exception as e:
                 logger.warning(f"Failed to create session with profile {self.profile}: {e}")
                 self._session = create_management_session()  # Use default profile

runbooks/remediation/commons.py

@@ -154,19 +154,20 @@ def get_method_details(client, rest_api_id, resource_id, http_method):
 # Global profile variable for cost optimization commands
 _profile = None
 
+
 def get_client(client_name: str, profile_name: str = None, region_name: str = None):
     """
     Enhanced client creation with profile support for cost optimization commands.
-    
+
     Enterprise pattern: Uses profile-based sessions like other runbooks modules.
     Supports both environment variables and profile-based authentication.
     """
     # Determine the profile to use (priority order)
     profile_to_use = profile_name or _profile or os.environ.get("AWS_PROFILE")
-    
+
     # Determine the region to use
     region_to_use = region_name or os.environ.get("AWS_REGION", "us-east-1")
-    
+
     if profile_to_use:
         # Use profile-based session (enterprise pattern)
         session = boto3.Session(profile_name=profile_to_use)
@@ -185,16 +186,16 @@ def get_client(client_name: str, profile_name: str = None, region_name: str = No
 def get_resource(client_name: str, profile_name: str = None, region_name: str = None):
     """
     Enhanced resource creation with profile support for cost optimization commands.
-    
+
     Enterprise pattern: Uses profile-based sessions like other runbooks modules.
     Supports both environment variables and profile-based authentication.
     """
     # Determine the profile to use (priority order)
     profile_to_use = profile_name or _profile or os.environ.get("AWS_PROFILE")
-    
+
     # Determine the region to use
     region_to_use = region_name or os.environ.get("AWS_REGION", "us-east-1")
-    
+
     if profile_to_use:
         # Use profile-based session (enterprise pattern)
         session = boto3.Session(profile_name=profile_to_use)
@@ -372,7 +373,9 @@ def get_price(service_code, region_name, instance_type):
 @LRU_cache(maxsize=32)
 def get_product_pricing(instance_type, region_name, service_code):
     # Pricing API available only in selected regions
-    pricing = botocore.session.get_session().create_client("pricing", region_name=os.getenv("AWS_DEFAULT_REGION", "us-east-1"))
+    pricing = botocore.session.get_session().create_client(
+        "pricing", region_name=os.getenv("AWS_DEFAULT_REGION", "us-east-1")
+    )
     response = pricing.get_products(
         ServiceCode=service_code,
         Filters=[

runbooks/remediation/commvault_ec2_analysis.py

@@ -15,8 +15,14 @@ from botocore.exceptions import ClientError
 
 from .commons import display_aws_account_info, get_client, write_to_csv
 from ..common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning,
-    create_table, create_progress_bar, format_cost
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    create_table,
+    create_progress_bar,
+    format_cost,
 )
 from ..common.profile_utils import create_operational_session
 
@@ -26,41 +32,41 @@ logger = logging.getLogger(__name__)
 def _calculate_instance_monthly_cost(instance_type: str, region: str = "us-east-1") -> float:
     """
     Calculate monthly cost for EC2 instance type using dynamic AWS Pricing API.
-    
+
     ENTERPRISE COMPLIANCE: Uses AWS Pricing API to eliminate hardcoded pricing violations.
-    
+
     Args:
         instance_type: EC2 instance type (e.g., 't3.micro', 'm5.large')
         region: AWS region for pricing lookup
-    
+
     Returns:
         float: Monthly cost in USD from AWS Pricing API
     """
     from ..common.aws_pricing import get_ec2_monthly_cost
     from ..common.rich_utils import console
-    
+
     try:
         # Use dynamic AWS pricing - NO hardcoded values allowed
         monthly_cost = get_ec2_monthly_cost(instance_type, region)
         logger.debug(f"Dynamic pricing for {instance_type}: ${monthly_cost:.2f}/month")
         return monthly_cost
-        
+
     except Exception as e:
         console.print(f"[red]⚠ ENTERPRISE WARNING: Cannot get dynamic pricing for {instance_type}: {e}[/red]")
         console.print(f"[yellow]Falling back to AWS pricing pattern calculation...[/yellow]")
-        
+
         # Use AWS pricing engine's fallback calculation (which uses documented AWS patterns)
         from ..common.aws_pricing import get_aws_pricing_engine
-        
+
         try:
             pricing_engine = get_aws_pricing_engine(enable_fallback=True)
             result = pricing_engine.get_ec2_instance_pricing(instance_type, region)
             logger.warning(f"Using fallback pricing for {instance_type}: ${result.monthly_cost:.2f}/month")
             return result.monthly_cost
-            
+
         except Exception as fallback_error:
             logger.error(f"All pricing methods failed for {instance_type}: {fallback_error}")
-            
+
             # Complete failure - cannot proceed without violating enterprise standards
             raise RuntimeError(
                 f"ENTERPRISE VIOLATION: Cannot get dynamic pricing for {instance_type} "
@@ -70,27 +76,25 @@ def _calculate_instance_monthly_cost(instance_type: str, region: str = "us-east-
             ) from e
 
 
-
-
 def calculate_ec2_cost_impact(instances_data: List[Dict]) -> Dict[str, float]:
     """
     Calculate potential cost impact for EC2 instances.
-    
+
     JIRA FinOps-25: Focuses on Commvault backup account utilization analysis
     """
     total_instances = len(instances_data)
     running_instances = [i for i in instances_data if i.get("State", {}).get("Name") == "running"]
     idle_instances = [i for i in instances_data if i.get("CpuUtilization", 0) < 5.0]  # <5% CPU
-    
+
     # Dynamic cost estimation using environment configuration
     estimated_monthly_cost = 0.0
     for instance in running_instances:
         instance_type = instance.get("InstanceType", "t3.micro")
-        
+
         # Dynamic cost calculation based on instance type
         # Using AWS pricing calculation: hours * daily_hours * monthly_days
         estimated_monthly_cost += _calculate_instance_monthly_cost(instance_type)
-    
+
     return {
         "total_instances": total_instances,
         "running_instances": len(running_instances),
@@ -103,30 +107,32 @@ def calculate_ec2_cost_impact(instances_data: List[Dict]) -> Dict[str, float]:
 
 @click.command()
 @click.option("--output-file", default="./tmp/commvault_ec2_investigation.csv", help="Output CSV file path")
-@click.option("--account", help="Commvault backup account ID (JIRA FinOps-25). If not specified, uses current AWS account.")
+@click.option(
+    "--account", help="Commvault backup account ID (JIRA FinOps-25). If not specified, uses current AWS account."
+)
 @click.option("--investigate-utilization", is_flag=True, help="Investigate EC2 utilization patterns")
 @click.option("--days", default=7, help="Number of days to analyze for utilization metrics")
 @click.option("--dry-run", is_flag=True, default=True, help="Preview analysis without execution")
 def investigate_commvault_ec2(output_file, account, investigate_utilization, days, dry_run):
     """
     FinOps-25: Commvault EC2 investigation for cost optimization.
-    
+
     Challenge: Determine if EC2 instances are actively used for backups or idle
     """
     print_header("JIRA FinOps-25: Commvault EC2 Investigation", "latest version")
-    
+
     # Auto-detect account if not specified
     if not account:
         try:
             session = create_operational_session()
-            sts = session.client('sts')
+            sts = session.client("sts")
             identity = sts.get_caller_identity()
-            account = identity['Account']
+            account = identity["Account"]
             console.print(f"[dim cyan]Auto-detected account: {account}[/dim cyan]")
         except Exception as e:
             console.print(f"[red]Error detecting account: {e}[/red]")
             raise click.ClickException("Could not determine AWS account. Please specify --account parameter.")
-    
+
     account_info = display_aws_account_info()
     console.print(f"[cyan]Account: {account} - Investigating EC2 usage patterns[/cyan]")
 
@@ -137,10 +143,10 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
         # Get all EC2 instances
         console.print("[yellow]Collecting EC2 instance data...[/yellow]")
         response = ec2_client.describe_instances()
-        
+
         instances_data = []
         all_instances = []
-        
+
         # Flatten instance data
         for reservation in response.get("Reservations", []):
             all_instances.extend(reservation.get("Instances", []))
@@ -157,8 +163,7 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
 
         with create_progress_bar() as progress:
             task_id = progress.add_task(
-                f"Investigating {len(all_instances)} EC2 instances...",
-                total=len(all_instances)
+                f"Investigating {len(all_instances)} EC2 instances...", total=len(all_instances)
             )
 
             for instance in all_instances:
@@ -166,7 +171,7 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
                 instance_type = instance.get("InstanceType", "unknown")
                 state = instance.get("State", {}).get("Name", "unknown")
                 launch_time = instance.get("LaunchTime")
-                
+
                 # Get CPU utilization metrics
                 cpu_utilization = 0.0
                 if investigate_utilization and state == "running":
@@ -180,18 +185,18 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
                             Period=3600,  # 1 hour intervals
                             Statistics=["Average"],
                         )
-                        
+
                         if cpu_response.get("Datapoints"):
-                            cpu_utilization = sum(
-                                dp["Average"] for dp in cpu_response["Datapoints"]
-                            ) / len(cpu_response["Datapoints"])
-                            
+                            cpu_utilization = sum(dp["Average"] for dp in cpu_response["Datapoints"]) / len(
+                                cpu_response["Datapoints"]
+                            )
+
                     except ClientError as e:
                         logger.warning(f"Could not get CPU metrics for {instance_id}: {e}")
 
                 # Get tags for context
                 tags = {tag["Key"]: tag["Value"] for tag in instance.get("Tags", [])}
-                
+
                 instance_data = {
                     "InstanceId": instance_id,
                     "InstanceType": instance_type,
@@ -203,7 +208,7 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
                     "Purpose": tags.get("Purpose", tags.get("Application", "Unknown")),
                     "IsLowUtilization": cpu_utilization < 5.0 if investigate_utilization else False,
                 }
-                
+
                 instances_data.append(instance_data)
                 progress.advance(task_id)
 
@@ -213,47 +218,44 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
 
         # Calculate cost impact analysis
         cost_analysis = calculate_ec2_cost_impact(instances_data)
-        
+
         # Create summary table
         print_header("Commvault EC2 Investigation Summary")
-        
+
         summary_table = create_table(
             title="EC2 Cost Impact Analysis - JIRA FinOps-25",
             columns=[
                 {"header": "Metric", "style": "cyan"},
                 {"header": "Count", "style": "green bold"},
                 {"header": "Monthly Cost", "style": "red"},
-                {"header": "Annual Cost", "style": "red bold"}
-            ]
+                {"header": "Annual Cost", "style": "red bold"},
+            ],
         )
 
         summary_table.add_row(
-            "Total EC2 Instances",
-            str(cost_analysis["total_instances"]),
-            "Mixed Types",
-            "Mixed Types"
+            "Total EC2 Instances", str(cost_analysis["total_instances"]), "Mixed Types", "Mixed Types"
         )
-        
+
         summary_table.add_row(
             "Running Instances",
             str(cost_analysis["running_instances"]),
             format_cost(cost_analysis["estimated_monthly_cost"]),
-            format_cost(cost_analysis["estimated_annual_cost"])
+            format_cost(cost_analysis["estimated_annual_cost"]),
         )
-        
+
         if investigate_utilization:
             summary_table.add_row(
                 "Low Utilization (<5% CPU)",
                 str(cost_analysis["idle_instances"]),
                 "Investigation Required",
-                "Investigation Required"
+                "Investigation Required",
             )
-            
+
             summary_table.add_row(
                 "🎯 Potential Savings (if idle)",
                 f"{cost_analysis['idle_instances']} instances",
                 format_cost(cost_analysis["potential_savings_if_idle"] / 12),
-                format_cost(cost_analysis["potential_savings_if_idle"])
+                format_cost(cost_analysis["potential_savings_if_idle"]),
             )
 
         console.print(summary_table)
@@ -261,10 +263,10 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
         # Investigation recommendations
         if investigate_utilization:
             low_util_instances = [i for i in instances_data if i["IsLowUtilization"]]
-            
+
             if low_util_instances:
                 print_warning(f"🔍 Found {len(low_util_instances)} instances with low utilization:")
-                
+
                 # Create detailed investigation table
                 investigation_table = create_table(
                     title="Low Utilization Instances (Investigation Required)",
@@ -274,33 +276,35 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
                         {"header": "CPU %", "style": "yellow"},
                         {"header": "Name", "style": "green"},
                         {"header": "Purpose", "style": "magenta"},
-                        {"header": "State", "style": "red"}
-                    ]
+                        {"header": "State", "style": "red"},
+                    ],
                 )
-                
+
                 for instance in low_util_instances[:10]:  # Show first 10
                     investigation_table.add_row(
-                        instance['InstanceId'],
-                        instance['InstanceType'],
+                        instance["InstanceId"],
+                        instance["InstanceType"],
                         f"{instance['CpuUtilization']:.1f}%",
-                        instance['Name'],
-                        instance['Purpose'],
-                        instance['State']
+                        instance["Name"],
+                        instance["Purpose"],
+                        instance["State"],
                     )
-                
+
                 console.print(investigation_table)
-                
+
                 if len(low_util_instances) > 10:
-                    console.print(f"[dim]... and {len(low_util_instances) - 10} more instances requiring investigation[/dim]")
-                    
+                    console.print(
+                        f"[dim]... and {len(low_util_instances) - 10} more instances requiring investigation[/dim]"
+                    )
+
                 # Manual verification checklist
                 print_header("Manual Verification Checklist")
                 console.print("[yellow]For each low-utilization instance, verify:[/yellow]")
                 console.print("[dim]1. Is this instance actively used for Commvault backup operations?[/dim]")
-                console.print("[dim]2. Are there scheduled backup jobs running on this instance?[/dim]") 
+                console.print("[dim]2. Are there scheduled backup jobs running on this instance?[/dim]")
                 console.print("[dim]3. Can this instance be right-sized or terminated safely?[/dim]")
                 console.print("[dim]4. Are there any dependencies or integrations that require this instance?[/dim]")
-                
+
             else:
                 print_success("✓ No low-utilization instances detected")
 
@@ -310,4 +314,4 @@ def investigate_commvault_ec2(output_file, account, investigate_utilization, day
 
     except Exception as e:
         logger.error(f"Failed to investigate Commvault EC2: {e}")
-        raise
+        raise

runbooks/remediation/ec2_unattached_ebs_volumes.py

@@ -307,6 +307,7 @@ def detect_and_delete_volumes(dry_run: bool, max_age_days: int, output_file: Opt
 
                 # Real-time EBS cost from AWS Pricing API - NO hardcoded defaults
                 from runbooks.common.aws_pricing_api import pricing_api
+
                 if volume_type == "gp3":
                     cost_per_gb = pricing_api.get_ebs_gp3_cost_per_gb(region_name)
                 else:

runbooks/remediation/multi_account.py

@@ -71,7 +71,10 @@ from loguru import logger
 from runbooks.inventory.models.account import AWSAccount
 from runbooks.remediation.base import BaseRemediation, RemediationContext, RemediationResult, RemediationStatus
 from runbooks.common.profile_utils import create_management_session
-from runbooks.remediation.universal_account_discovery import UniversalAccountDiscovery, AWSAccount as UniversalAWSAccount
+from runbooks.remediation.universal_account_discovery import (
+    UniversalAccountDiscovery,
+    AWSAccount as UniversalAWSAccount,
+)
 
 
 class MultiAccountRemediator:
@@ -572,16 +575,16 @@ class MultiAccountRemediator:
 def get_accounts_from_environment(profile: Optional[str] = None) -> Optional[List[AWSAccount]]:
     """
     Get AWS accounts using universal account discovery system.
-    
+
     Uses enhanced discovery with support for:
     - Environment variables (REMEDIATION_TARGET_ACCOUNTS)
     - Configuration files (REMEDIATION_ACCOUNT_CONFIG)
     - AWS Organizations API (automatic discovery)
     - Current account fallback (single account mode)
-    
+
     Args:
         profile: AWS profile to use for discovery
-    
+
     Returns:
         List of AWSAccount objects or None if not configured
     """
@@ -589,22 +592,22 @@ def get_accounts_from_environment(profile: Optional[str] = None) -> Optional[Lis
         # Use universal account discovery system
         discovery = UniversalAccountDiscovery(profile=profile)
         universal_accounts = discovery.discover_target_accounts()
-        
+
         if not universal_accounts:
             return None
-        
+
         # Convert to legacy AWSAccount format for compatibility
         legacy_accounts = []
         for universal_account in universal_accounts:
             legacy_account = AWSAccount(
                 universal_account.account_id,
-                universal_account.account_name or f"account-{universal_account.account_id}"
+                universal_account.account_name or f"account-{universal_account.account_id}",
             )
             legacy_accounts.append(legacy_account)
-        
+
         logger.info(f"Using {len(legacy_accounts)} accounts discovered via universal discovery system")
         return legacy_accounts
-        
+
     except Exception as e:
         logger.warning(f"Failed to discover accounts using universal discovery: {e}")
         return None
@@ -613,16 +616,16 @@ def get_accounts_from_environment(profile: Optional[str] = None) -> Optional[Lis
 def discover_organization_accounts(profile: Optional[str] = None) -> List[AWSAccount]:
     """
     Discover AWS accounts using universal discovery system.
-    
+
     Enhanced to use the universal account discovery system which provides:
     - Organizations API discovery (if available)
     - Environment variable fallback
     - Configuration file support
     - Current account fallback
-    
+
     Args:
         profile: AWS profile for discovery (universal profile management)
-        
+
     Returns:
         List of discovered AWSAccount objects
     """
@@ -630,25 +633,25 @@ def discover_organization_accounts(profile: Optional[str] = None) -> List[AWSAcc
         # Use universal account discovery system for Organizations discovery
         discovery = UniversalAccountDiscovery(profile=profile)
         universal_accounts = discovery._get_accounts_from_organizations()
-        
+
         if not universal_accounts:
             # Fallback to other discovery methods
             logger.info("Organizations API not available, trying other discovery methods...")
             universal_accounts = discovery.discover_target_accounts()
-        
+
         # Convert to legacy AWSAccount format for compatibility
         legacy_accounts = []
         for universal_account in universal_accounts:
             if universal_account.status == "ACTIVE":
                 legacy_account = AWSAccount(
                     universal_account.account_id,
-                    universal_account.account_name or f"org-account-{universal_account.account_id}"
+                    universal_account.account_name or f"org-account-{universal_account.account_id}",
                 )
                 legacy_accounts.append(legacy_account)
-        
+
         logger.info(f"Discovered {len(legacy_accounts)} active AWS accounts via universal discovery")
         return legacy_accounts
-        
+
     except Exception as e:
         logger.warning(f"Failed to discover organization accounts: {e}")
         # Universal discovery handles all fallback scenarios
@@ -658,20 +661,20 @@ def discover_organization_accounts(profile: Optional[str] = None) -> List[AWSAcc
 def _determine_account_environment(account_name: str) -> str:
     """
     Determine account environment based on account name patterns.
-    
+
     Args:
         account_name: AWS account name
-        
+
     Returns:
         Environment classification
     """
     name_lower = account_name.lower()
-    
+
     # Common environment patterns
     if any(env in name_lower for env in ["prod", "production"]):
         return "production"
     elif any(env in name_lower for env in ["staging", "stage", "uat"]):
-        return "staging"  
+        return "staging"
     elif any(env in name_lower for env in ["dev", "development"]):
         return "development"
     elif any(env in name_lower for env in ["test", "testing"]):