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

runbooks/inventory/collectors/aws_networking.py

@@ -8,7 +8,7 @@ Strategic Enhancement: Migrated VPC discovery capabilities from vpc module follo
 Maintains 100% compatibility with AWS Cloud Foundations inventory-scripts:
 - all_my_vpcs.py -> Enhanced VPCCollector with topology mapping
 - all_my_subnets.py -> SubnetCollector
-- all_my_elbs.py -> ELBCollector  
+- all_my_elbs.py -> ELBCollector
 - all_my_enis.py -> ENICollector
 - all_my_phzs.py -> Route53Collector
 
@@ -293,32 +293,33 @@ if __name__ == "__main__":
 # NEW VPC MODULE MIGRATION - Network Topology Discovery
 # ============================================================================
 
+
 class NetworkTopologyCollector(BaseResourceCollector):
     """
     Network Topology Collector - Migrated from vpc module networking_wrapper.py
-    
+
     Provides comprehensive VPC topology mapping and cross-region relationships
     following enterprise discovery patterns with Rich CLI integration.
     """
-    
+
     def __init__(self, session: Optional[boto3.Session] = None):
         super().__init__(resource_type=ResourceType.VPC, session=session)  # Using VPC as base type
-        
+
     @aws_api_retry
     def collect_network_topology(self, account: AWSAccount, regions: List[str] = None) -> Dict[str, Any]:
         """
         Collect comprehensive network topology across regions.
-        
+
         Args:
             account: AWS account to analyze
             regions: List of regions to analyze (default: all available)
-            
+
         Returns:
             Dictionary with complete network topology mapping
         """
         if not regions:
             regions = ["us-east-1", "us-west-2", "eu-west-1"]  # Default enterprise regions
-            
+
         print_header("Network Topology Discovery", "latest version")
         topology = {
             "account_id": account.account_id,
@@ -331,9 +332,9 @@ class NetworkTopologyCollector(BaseResourceCollector):
             "vpc_peering": [],
             "total_vpcs": 0,
             "total_subnets": 0,
-            "recommendations": []
+            "recommendations": [],
         }
-        
+
         for region in regions:
             try:
                 print_info(f"Analyzing network topology in {region}")
@@ -341,22 +342,24 @@ class NetworkTopologyCollector(BaseResourceCollector):
                 topology["vpc_topology"][region] = region_topology
                 topology["total_vpcs"] += len(region_topology["vpcs"])
                 topology["total_subnets"] += len(region_topology["subnets"])
-                
+
             except Exception as e:
                 self.logger.error(f"Failed to collect topology from {region}: {e}")
                 continue
-                
+
         # Analyze cross-region connections
         topology["cross_region_connections"] = self._analyze_cross_region_connections(topology["vpc_topology"])
         topology["recommendations"] = self._generate_topology_recommendations(topology)
-        
-        print_success(f"Network topology discovery completed: {topology['total_vpcs']} VPCs, {topology['total_subnets']} subnets")
+
+        print_success(
+            f"Network topology discovery completed: {topology['total_vpcs']} VPCs, {topology['total_subnets']} subnets"
+        )
         return topology
-    
+
     def _collect_region_topology(self, region: str, account: AWSAccount) -> Dict[str, Any]:
         """Collect detailed network topology for a specific region."""
         ec2 = self.session.client("ec2", region_name=region)
-        
+
         region_topology = {
             "region": region,
             "vpcs": [],
@@ -365,38 +368,38 @@ class NetworkTopologyCollector(BaseResourceCollector):
             "internet_gateways": [],
             "nat_gateways": [],
             "vpc_endpoints": [],
-            "network_interfaces": []
+            "network_interfaces": [],
         }
-        
+
         try:
             # Collect VPCs with enhanced metadata
             vpcs_response = ec2.describe_vpcs()
             for vpc in vpcs_response["Vpcs"]:
                 vpc_data = self._enhance_vpc_data(ec2, vpc, region, account)
                 region_topology["vpcs"].append(vpc_data)
-                
+
             # Collect NAT Gateways
             nat_response = ec2.describe_nat_gateways()
             for nat in nat_response["NatGateways"]:
                 if nat["State"] != "deleted":
                     nat_data = self._enhance_nat_gateway_data(ec2, nat, region)
                     region_topology["nat_gateways"].append(nat_data)
-                    
+
             # Collect VPC Endpoints
             endpoints_response = ec2.describe_vpc_endpoints()
             for endpoint in endpoints_response["VpcEndpoints"]:
                 endpoint_data = self._enhance_vpc_endpoint_data(endpoint, region)
                 region_topology["vpc_endpoints"].append(endpoint_data)
-                
+
         except ClientError as e:
             self.logger.error(f"AWS API error in {region}: {e}")
-            
+
         return region_topology
-        
+
     def _enhance_vpc_data(self, ec2_client, vpc: Dict[str, Any], region: str, account: AWSAccount) -> Dict[str, Any]:
         """Enhance VPC data with topology relationships."""
         tags = {tag["Key"]: tag["Value"] for tag in vpc.get("Tags", [])}
-        
+
         enhanced_vpc = {
             "vpc_id": vpc["VpcId"],
             "cidr_block": vpc["CidrBlock"],
@@ -412,35 +415,35 @@ class NetworkTopologyCollector(BaseResourceCollector):
             "route_tables": [],
             "internet_gateways": [],
             "security_groups": [],
-            "network_acls": []
+            "network_acls": [],
         }
-        
+
         # Get associated subnets
         try:
-            subnets_response = ec2_client.describe_subnets(
-                Filters=[{"Name": "vpc-id", "Values": [vpc["VpcId"]]}]
-            )
+            subnets_response = ec2_client.describe_subnets(Filters=[{"Name": "vpc-id", "Values": [vpc["VpcId"]]}])
             for subnet in subnets_response["Subnets"]:
                 subnet_tags = {tag["Key"]: tag["Value"] for tag in subnet.get("Tags", [])}
-                enhanced_vpc["subnets"].append({
-                    "subnet_id": subnet["SubnetId"],
-                    "cidr_block": subnet["CidrBlock"],
-                    "availability_zone": subnet["AvailabilityZone"],
-                    "available_ip_address_count": subnet["AvailableIpAddressCount"],
-                    "map_public_ip_on_launch": subnet.get("MapPublicIpOnLaunch", False),
-                    "state": subnet["State"],
-                    "tags": subnet_tags,
-                    "name": subnet_tags.get("Name", subnet["SubnetId"])
-                })
+                enhanced_vpc["subnets"].append(
+                    {
+                        "subnet_id": subnet["SubnetId"],
+                        "cidr_block": subnet["CidrBlock"],
+                        "availability_zone": subnet["AvailabilityZone"],
+                        "available_ip_address_count": subnet["AvailableIpAddressCount"],
+                        "map_public_ip_on_launch": subnet.get("MapPublicIpOnLaunch", False),
+                        "state": subnet["State"],
+                        "tags": subnet_tags,
+                        "name": subnet_tags.get("Name", subnet["SubnetId"]),
+                    }
+                )
         except ClientError as e:
             self.logger.warning(f"Failed to get subnets for VPC {vpc['VpcId']}: {e}")
-            
+
         return enhanced_vpc
-        
+
     def _enhance_nat_gateway_data(self, ec2_client, nat: Dict[str, Any], region: str) -> Dict[str, Any]:
         """Enhance NAT Gateway data with usage and cost implications."""
         tags = {tag["Key"]: tag["Value"] for tag in nat.get("Tags", [])}
-        
+
         return {
             "nat_gateway_id": nat["NatGatewayId"],
             "state": nat["State"],
@@ -454,13 +457,13 @@ class NetworkTopologyCollector(BaseResourceCollector):
             # Enhanced with network interface information
             "network_interface_id": nat.get("NatGatewayAddresses", [{}])[0].get("NetworkInterfaceId"),
             "public_ip": nat.get("NatGatewayAddresses", [{}])[0].get("PublicIp"),
-            "private_ip": nat.get("NatGatewayAddresses", [{}])[0].get("PrivateIp")
+            "private_ip": nat.get("NatGatewayAddresses", [{}])[0].get("PrivateIp"),
         }
-        
+
     def _enhance_vpc_endpoint_data(self, endpoint: Dict[str, Any], region: str) -> Dict[str, Any]:
         """Enhance VPC Endpoint data with service and cost information."""
         tags = {tag["Key"]: tag["Value"] for tag in endpoint.get("Tags", [])}
-        
+
         return {
             "vpc_endpoint_id": endpoint["VpcEndpointId"],
             "vpc_id": endpoint.get("VpcId"),
@@ -473,64 +476,65 @@ class NetworkTopologyCollector(BaseResourceCollector):
             "name": tags.get("Name", endpoint["VpcEndpointId"]),
             "route_table_ids": endpoint.get("RouteTableIds", []),
             "subnet_ids": endpoint.get("SubnetIds", []),
-            "policy_document": endpoint.get("PolicyDocument")
+            "policy_document": endpoint.get("PolicyDocument"),
         }
-        
+
     def _analyze_cross_region_connections(self, vpc_topology: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Analyze potential cross-region network connections."""
         connections = []
         # This would be enhanced to detect VPC peering, Transit Gateway, etc.
         # For now, return empty list as foundation
         return connections
-        
+
     def _generate_topology_recommendations(self, topology: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Generate network topology optimization recommendations."""
         recommendations = []
-        
+
         # Basic recommendations based on topology analysis
         total_nat_gateways = sum(
-            len(region_data.get("nat_gateways", []))
-            for region_data in topology["vpc_topology"].values()
+            len(region_data.get("nat_gateways", [])) for region_data in topology["vpc_topology"].values()
         )
-        
+
         if total_nat_gateways > topology["total_vpcs"]:
-            recommendations.append({
-                "type": "cost_optimization",
-                "priority": "high",
-                "description": f"Multiple NAT Gateways detected ({total_nat_gateways}) across {topology['total_vpcs']} VPCs",
-                "recommendation": "Consider consolidating NAT Gateways to reduce monthly costs",
-                "estimated_savings": f"${(total_nat_gateways - topology['total_vpcs']) * 45:.2f}/month"
-            })
-            
+            recommendations.append(
+                {
+                    "type": "cost_optimization",
+                    "priority": "high",
+                    "description": f"Multiple NAT Gateways detected ({total_nat_gateways}) across {topology['total_vpcs']} VPCs",
+                    "recommendation": "Consider consolidating NAT Gateways to reduce monthly costs",
+                    "estimated_savings": f"${(total_nat_gateways - topology['total_vpcs']) * 45:.2f}/month",
+                }
+            )
+
         return recommendations
 
 
 class TransitGatewayCollector(BaseResourceCollector):
     """
     Transit Gateway Collector - Enhanced discovery from vpc module
-    
+
     Provides comprehensive Transit Gateway and VPC peering discovery
     with enterprise cost analysis integration.
     """
-    
+
     def __init__(self, session: Optional[boto3.Session] = None):
         super().__init__(resource_type=ResourceType.VPC, session=session)
-        
+
     @aws_api_retry
     def collect_transit_gateways(self, account: AWSAccount, regions: List[str] = None) -> Dict[str, Any]:
         """
         Collect Transit Gateway configurations and attachments.
-        
+
         Args:
             account: AWS account to analyze
             regions: List of regions to analyze
-            
+
         Returns:
             Dictionary with Transit Gateway analysis
         """
         if not regions:
             regions = ["us-east-1", "us-west-2", "eu-west-1"]
-            
+
         print_header("Transit Gateway Discovery", "latest version")
         tgw_analysis = {
             "account_id": account.account_id,
@@ -540,18 +544,18 @@ class TransitGatewayCollector(BaseResourceCollector):
             "total_tgw": 0,
             "total_attachments": 0,
             "monthly_cost_estimate": 0,
-            "recommendations": []
+            "recommendations": [],
         }
-        
+
         for region in regions:
             try:
                 print_info(f"Analyzing Transit Gateways in {region}")
                 ec2 = self.session.client("ec2", region_name=region)
-                
+
                 # Get Transit Gateways
                 tgw_response = ec2.describe_transit_gateways()
                 region_tgws = []
-                
+
                 for tgw in tgw_response["TransitGateways"]:
                     if tgw["State"] not in ["deleted", "deleting"]:
                         tgw_data = self._enhance_transit_gateway_data(ec2, tgw, region)
@@ -559,22 +563,24 @@ class TransitGatewayCollector(BaseResourceCollector):
                         tgw_analysis["total_tgw"] += 1
                         tgw_analysis["total_attachments"] += len(tgw_data["attachments"])
                         tgw_analysis["monthly_cost_estimate"] += 36.50  # Base TGW cost per month
-                        
+
                 tgw_analysis["transit_gateways"][region] = region_tgws
-                
+
             except ClientError as e:
                 self.logger.error(f"Failed to collect Transit Gateways from {region}: {e}")
                 continue
-                
+
         tgw_analysis["recommendations"] = self._generate_tgw_recommendations(tgw_analysis)
-        
-        print_success(f"Transit Gateway discovery completed: {tgw_analysis['total_tgw']} TGWs, {tgw_analysis['total_attachments']} attachments")
+
+        print_success(
+            f"Transit Gateway discovery completed: {tgw_analysis['total_tgw']} TGWs, {tgw_analysis['total_attachments']} attachments"
+        )
         return tgw_analysis
-        
+
     def _enhance_transit_gateway_data(self, ec2_client, tgw: Dict[str, Any], region: str) -> Dict[str, Any]:
         """Enhance Transit Gateway data with attachments and routing information."""
         tags = {tag["Key"]: tag["Value"] for tag in tgw.get("Tags", [])}
-        
+
         tgw_data = {
             "transit_gateway_id": tgw["TransitGatewayId"],
             "state": tgw["State"],
@@ -585,42 +591,46 @@ class TransitGatewayCollector(BaseResourceCollector):
             "tags": tags,
             "name": tags.get("Name", tgw["TransitGatewayId"]),
             "attachments": [],
-            "route_tables": []
+            "route_tables": [],
         }
-        
+
         # Get Transit Gateway Attachments
         try:
             attachments_response = ec2_client.describe_transit_gateway_attachments(
                 Filters=[{"Name": "transit-gateway-id", "Values": [tgw["TransitGatewayId"]]}]
             )
-            
+
             for attachment in attachments_response["TransitGatewayAttachments"]:
                 attachment_tags = {tag["Key"]: tag["Value"] for tag in attachment.get("Tags", [])}
-                tgw_data["attachments"].append({
-                    "attachment_id": attachment["TransitGatewayAttachmentId"],
-                    "resource_type": attachment["ResourceType"],
-                    "resource_id": attachment.get("ResourceId"),
-                    "state": attachment["State"],
-                    "tags": attachment_tags,
-                    "name": attachment_tags.get("Name", attachment["TransitGatewayAttachmentId"])
-                })
-                
+                tgw_data["attachments"].append(
+                    {
+                        "attachment_id": attachment["TransitGatewayAttachmentId"],
+                        "resource_type": attachment["ResourceType"],
+                        "resource_id": attachment.get("ResourceId"),
+                        "state": attachment["State"],
+                        "tags": attachment_tags,
+                        "name": attachment_tags.get("Name", attachment["TransitGatewayAttachmentId"]),
+                    }
+                )
+
         except ClientError as e:
             self.logger.warning(f"Failed to get attachments for TGW {tgw['TransitGatewayId']}: {e}")
-            
+
         return tgw_data
-        
+
     def _generate_tgw_recommendations(self, tgw_analysis: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Generate Transit Gateway optimization recommendations."""
         recommendations = []
-        
+
         if tgw_analysis["total_tgw"] > 1:
-            recommendations.append({
-                "type": "cost_optimization",
-                "priority": "medium",
-                "description": f"Multiple Transit Gateways detected ({tgw_analysis['total_tgw']})",
-                "recommendation": "Consider consolidating Transit Gateways to reduce base costs",
-                "estimated_savings": f"${(tgw_analysis['total_tgw'] - 1) * 36.50:.2f}/month"
-            })
-            
+            recommendations.append(
+                {
+                    "type": "cost_optimization",
+                    "priority": "medium",
+                    "description": f"Multiple Transit Gateways detected ({tgw_analysis['total_tgw']})",
+                    "recommendation": "Consider consolidating Transit Gateways to reduce base costs",
+                    "estimated_savings": f"${(tgw_analysis['total_tgw'] - 1) * 36.50:.2f}/month",
+                }
+            )
+
         return recommendations

runbooks/inventory/collectors/base.py

@@ -220,3 +220,7 @@ class BaseResourceCollector(ABC):
         return (
             f"{self.__class__.__name__}(category='{self.service_category}', resources={len(self.supported_resources)})"
         )
+
+
+# Alias for backward compatibility
+BaseCollector = BaseResourceCollector