aws-inventory-manager 0.2.0__py3-none-any.whl

src/snapshot/resource_collectors/elb.py

@@ -0,0 +1,126 @@
+"""ELB/ALB resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class ELBCollector(BaseResourceCollector):
+    """Collector for AWS Load Balancer resources (Classic ELB, ALB, NLB)."""
+
+    @property
+    def service_name(self) -> str:
+        return "elb"
+
+    def collect(self) -> List[Resource]:
+        """Collect ELB resources.
+
+        Returns:
+            List of load balancers
+        """
+        resources = []
+        account_id = self._get_account_id()
+
+        # Collect v2 load balancers (ALB, NLB, GWLB)
+        resources.extend(self._collect_v2_load_balancers(account_id))
+
+        # Collect classic load balancers
+        resources.extend(self._collect_classic_load_balancers(account_id))
+
+        self.logger.debug(f"Collected {len(resources)} load balancers in {self.region}")
+        return resources
+
+    def _collect_v2_load_balancers(self, account_id: str) -> List[Resource]:
+        """Collect ALB/NLB/GWLB load balancers."""
+        resources = []
+
+        try:
+            elbv2_client = self._create_client("elbv2")
+
+            paginator = elbv2_client.get_paginator("describe_load_balancers")
+            for page in paginator.paginate():
+                for lb in page.get("LoadBalancers", []):
+                    lb_arn = lb["LoadBalancerArn"]
+                    lb_name = lb["LoadBalancerName"]
+                    lb_type = lb.get("Type", "application")  # application, network, gateway
+
+                    # Get tags
+                    tags = {}
+                    try:
+                        tag_response = elbv2_client.describe_tags(ResourceArns=[lb_arn])
+                        for tag_desc in tag_response.get("TagDescriptions", []):
+                            tags = {tag["Key"]: tag["Value"] for tag in tag_desc.get("Tags", [])}
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for load balancer {lb_name}: {e}")
+
+                    # Determine resource type
+                    if lb_type == "application":
+                        resource_type = "AWS::ElasticLoadBalancingV2::LoadBalancer::Application"
+                    elif lb_type == "network":
+                        resource_type = "AWS::ElasticLoadBalancingV2::LoadBalancer::Network"
+                    elif lb_type == "gateway":
+                        resource_type = "AWS::ElasticLoadBalancingV2::LoadBalancer::Gateway"
+                    else:
+                        resource_type = "AWS::ElasticLoadBalancingV2::LoadBalancer"
+
+                    # Create resource
+                    resource = Resource(
+                        arn=lb_arn,
+                        resource_type=resource_type,
+                        name=lb_name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(lb),
+                        created_at=lb.get("CreatedTime"),
+                        raw_config=lb,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting v2 load balancers in {self.region}: {e}")
+
+        return resources
+
+    def _collect_classic_load_balancers(self, account_id: str) -> List[Resource]:
+        """Collect classic load balancers."""
+        resources = []
+
+        try:
+            elb_client = self._create_client("elb")
+
+            paginator = elb_client.get_paginator("describe_load_balancers")
+            for page in paginator.paginate():
+                for lb in page.get("LoadBalancerDescriptions", []):
+                    lb_name = lb["LoadBalancerName"]
+
+                    # Build ARN (classic ELBs don't return ARN directly)
+                    lb_arn = f"arn:aws:elasticloadbalancing:{self.region}:{account_id}:loadbalancer/{lb_name}"
+
+                    # Get tags
+                    tags = {}
+                    try:
+                        tag_response = elb_client.describe_tags(LoadBalancerNames=[lb_name])
+                        for tag_desc in tag_response.get("TagDescriptions", []):
+                            tags = {tag["Key"]: tag["Value"] for tag in tag_desc.get("Tags", [])}
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for classic ELB {lb_name}: {e}")
+
+                    # Create resource
+                    resource = Resource(
+                        arn=lb_arn,
+                        resource_type="AWS::ElasticLoadBalancing::LoadBalancer",
+                        name=lb_name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(lb),
+                        created_at=lb.get("CreatedTime"),
+                        raw_config=lb,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting classic load balancers in {self.region}: {e}")
+
+        return resources

src/snapshot/resource_collectors/eventbridge.py

@@ -0,0 +1,156 @@
+"""EventBridge resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class EventBridgeCollector(BaseResourceCollector):
+    """Collector for Amazon EventBridge resources (Event Buses, Rules)."""
+
+    @property
+    def service_name(self) -> str:
+        return "eventbridge"
+
+    def collect(self) -> List[Resource]:
+        """Collect EventBridge resources.
+
+        Collects:
+        - Event Buses (custom and partner buses)
+        - Event Rules (across all buses)
+
+        Returns:
+            List of EventBridge resources
+        """
+        resources = []
+
+        # Collect Event Buses
+        resources.extend(self._collect_event_buses())
+
+        # Collect Event Rules (across all buses)
+        resources.extend(self._collect_event_rules())
+
+        self.logger.debug(f"Collected {len(resources)} EventBridge resources in {self.region}")
+        return resources
+
+    def _collect_event_buses(self) -> List[Resource]:
+        """Collect EventBridge Event Buses.
+
+        Returns:
+            List of Event Bus resources
+        """
+        resources = []
+        client = self._create_client("events")
+
+        try:
+            paginator = client.get_paginator("list_event_buses")
+            for page in paginator.paginate():
+                for bus in page.get("EventBuses", []):
+                    bus_name = bus["Name"]
+                    bus_arn = bus["Arn"]
+
+                    # Get tags
+                    tags = {}
+                    try:
+                        tag_response = client.list_tags_for_resource(ResourceARN=bus_arn)
+                        for tag in tag_response.get("Tags", []):
+                            tags[tag["Key"]] = tag["Value"]
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for event bus {bus_name}: {e}")
+
+                    # Extract creation time (if available)
+                    created_at = bus.get("CreationTime")
+
+                    # Create resource
+                    resource = Resource(
+                        arn=bus_arn,
+                        resource_type="AWS::Events::EventBus",
+                        name=bus_name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(bus),
+                        created_at=created_at,
+                        raw_config=bus,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting EventBridge event buses in {self.region}: {e}")
+
+        return resources
+
+    def _collect_event_rules(self) -> List[Resource]:
+        """Collect EventBridge Rules across all event buses.
+
+        Returns:
+            List of Event Rule resources
+        """
+        resources = []
+        client = self._create_client("events")
+
+        try:
+            # First, get all event buses to collect rules from each
+            event_buses = ["default"]  # Start with default bus
+
+            try:
+                paginator = client.get_paginator("list_event_buses")
+                for page in paginator.paginate():
+                    for bus in page.get("EventBuses", []):
+                        bus_name = bus["Name"]
+                        if bus_name != "default":
+                            event_buses.append(bus_name)
+            except Exception as e:
+                self.logger.debug(f"Error listing event buses: {e}")
+
+            # Collect rules from each bus
+            for bus_name in event_buses:
+                try:
+                    paginator = client.get_paginator("list_rules")
+                    for page in paginator.paginate(EventBusName=bus_name):
+                        for rule in page.get("Rules", []):
+                            rule_name = rule["Name"]
+                            rule_arn = rule["Arn"]
+
+                            # Get tags
+                            tags = {}
+                            try:
+                                tag_response = client.list_tags_for_resource(ResourceARN=rule_arn)
+                                for tag in tag_response.get("Tags", []):
+                                    tags[tag["Key"]] = tag["Value"]
+                            except Exception as e:
+                                self.logger.debug(f"Could not get tags for rule {rule_name}: {e}")
+
+                            # Get full rule details
+                            try:
+                                rule_details = client.describe_rule(Name=rule_name, EventBusName=bus_name)
+                                # Merge with basic rule info
+                                full_rule = {**rule, **rule_details}
+                            except Exception as e:
+                                self.logger.debug(f"Could not get details for rule {rule_name}: {e}")
+                                full_rule = rule
+
+                            # Extract creation time (not typically available for rules)
+                            created_at = None
+
+                            # Create resource
+                            resource = Resource(
+                                arn=rule_arn,
+                                resource_type="AWS::Events::Rule",
+                                name=rule_name,
+                                region=self.region,
+                                tags=tags,
+                                config_hash=compute_config_hash(full_rule),
+                                created_at=created_at,
+                                raw_config=full_rule,
+                            )
+                            resources.append(resource)
+
+                except Exception as e:
+                    self.logger.error(f"Error collecting rules from event bus {bus_name}: {e}")
+
+        except Exception as e:
+            self.logger.error(f"Error collecting EventBridge rules in {self.region}: {e}")
+
+        return resources

src/snapshot/resource_collectors/iam.py

@@ -0,0 +1,188 @@
+"""IAM resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class IAMCollector(BaseResourceCollector):
+    """Collector for AWS IAM resources (roles, users, groups, policies)."""
+
+    @property
+    def service_name(self) -> str:
+        return "iam"
+
+    @property
+    def is_global_service(self) -> bool:
+        return True
+
+    def collect(self) -> List[Resource]:
+        """Collect IAM resources.
+
+        Returns:
+            List of IAM resources (roles, users, groups, policies)
+        """
+        resources = []
+        account_id = self._get_account_id()
+
+        # Collect roles
+        resources.extend(self._collect_roles(account_id))
+
+        # Collect users
+        resources.extend(self._collect_users(account_id))
+
+        # Collect groups
+        resources.extend(self._collect_groups(account_id))
+
+        # Collect policies (customer-managed only)
+        resources.extend(self._collect_policies(account_id))
+
+        self.logger.debug(f"Collected {len(resources)} IAM resources")
+        return resources
+
+    def _collect_roles(self, account_id: str) -> List[Resource]:
+        """Collect IAM roles."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_roles")
+            for page in paginator.paginate():
+                for role in page["Roles"]:
+                    # Build ARN
+                    arn = role["Arn"]
+
+                    # Extract tags
+                    tags = {}
+                    try:
+                        tag_response = client.list_role_tags(RoleName=role["RoleName"])
+                        tags = {tag["Key"]: tag["Value"] for tag in tag_response.get("Tags", [])}
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for role {role['RoleName']}: {e}")
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::IAM::Role",
+                        name=role["RoleName"],
+                        region="global",
+                        tags=tags,
+                        config_hash=compute_config_hash(role),
+                        created_at=role.get("CreateDate"),
+                        raw_config=role,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting IAM roles: {e}")
+
+        return resources
+
+    def _collect_users(self, account_id: str) -> List[Resource]:
+        """Collect IAM users."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_users")
+            for page in paginator.paginate():
+                for user in page["Users"]:
+                    # Build ARN
+                    arn = user["Arn"]
+
+                    # Extract tags
+                    tags = {}
+                    try:
+                        tag_response = client.list_user_tags(UserName=user["UserName"])
+                        tags = {tag["Key"]: tag["Value"] for tag in tag_response.get("Tags", [])}
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for user {user['UserName']}: {e}")
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::IAM::User",
+                        name=user["UserName"],
+                        region="global",
+                        tags=tags,
+                        config_hash=compute_config_hash(user),
+                        created_at=user.get("CreateDate"),
+                        raw_config=user,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting IAM users: {e}")
+
+        return resources
+
+    def _collect_groups(self, account_id: str) -> List[Resource]:
+        """Collect IAM groups."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_groups")
+            for page in paginator.paginate():
+                for group in page["Groups"]:
+                    # Build ARN
+                    arn = group["Arn"]
+
+                    # Create resource (groups don't support tags)
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::IAM::Group",
+                        name=group["GroupName"],
+                        region="global",
+                        tags={},
+                        config_hash=compute_config_hash(group),
+                        created_at=group.get("CreateDate"),
+                        raw_config=group,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting IAM groups: {e}")
+
+        return resources
+
+    def _collect_policies(self, account_id: str) -> List[Resource]:
+        """Collect customer-managed IAM policies."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_policies")
+            # Only get customer-managed policies (not AWS-managed)
+            for page in paginator.paginate(Scope="Local"):
+                for policy in page["Policies"]:
+                    # Build ARN
+                    arn = policy["Arn"]
+
+                    # Extract tags
+                    tags = {}
+                    try:
+                        tag_response = client.list_policy_tags(PolicyArn=arn)
+                        tags = {tag["Key"]: tag["Value"] for tag in tag_response.get("Tags", [])}
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for policy {policy['PolicyName']}: {e}")
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::IAM::Policy",
+                        name=policy["PolicyName"],
+                        region="global",
+                        tags=tags,
+                        config_hash=compute_config_hash(policy),
+                        created_at=policy.get("CreateDate"),
+                        raw_config=policy,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting IAM policies: {e}")
+
+        return resources

src/snapshot/resource_collectors/kms.py

@@ -0,0 +1,111 @@
+"""KMS resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class KMSCollector(BaseResourceCollector):
+    """Collector for AWS KMS (Key Management Service) resources."""
+
+    @property
+    def service_name(self) -> str:
+        return "kms"
+
+    def collect(self) -> List[Resource]:
+        """Collect KMS keys.
+
+        Collects customer-managed KMS keys (not AWS-managed keys).
+
+        Returns:
+            List of KMS key resources
+        """
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_keys")
+            for page in paginator.paginate():
+                for key_item in page.get("Keys", []):
+                    key_id = key_item["KeyId"]
+                    key_arn = key_item["KeyArn"]
+
+                    try:
+                        # Get key metadata
+                        key_metadata = client.describe_key(KeyId=key_id)["KeyMetadata"]
+
+                        # Skip AWS-managed keys (we only want customer-managed keys)
+                        if key_metadata.get("KeyManager") == "AWS":
+                            continue
+
+                        # Skip keys that are pending deletion
+                        if key_metadata.get("KeyState") == "PendingDeletion":
+                            self.logger.debug(f"Skipping key {key_id} - pending deletion")
+                            continue
+
+                        key_alias = None
+
+                        # Get key aliases
+                        try:
+                            aliases_response = client.list_aliases(KeyId=key_id)
+                            aliases = aliases_response.get("Aliases", [])
+                            if aliases:
+                                # Use first alias as the name
+                                key_alias = aliases[0]["AliasName"]
+                        except Exception as e:
+                            self.logger.debug(f"Could not get aliases for key {key_id}: {e}")
+
+                        # Get tags
+                        tags = {}
+                        try:
+                            tag_response = client.list_resource_tags(KeyId=key_id)
+                            for tag in tag_response.get("Tags", []):
+                                tags[tag["TagKey"]] = tag["TagValue"]
+                        except Exception as e:
+                            self.logger.debug(f"Could not get tags for key {key_id}: {e}")
+
+                        # Get key rotation status
+                        rotation_enabled = False
+                        try:
+                            rotation_response = client.get_key_rotation_status(KeyId=key_id)
+                            rotation_enabled = rotation_response.get("KeyRotationEnabled", False)
+                        except Exception as e:
+                            self.logger.debug(f"Could not get rotation status for key {key_id}: {e}")
+
+                        # Build config for hash
+                        config = {
+                            **key_metadata,
+                            "RotationEnabled": rotation_enabled,
+                            "Aliases": [key_alias] if key_alias else [],
+                        }
+
+                        # Extract creation date
+                        created_at = key_metadata.get("CreationDate")
+
+                        # Use alias as name if available, otherwise use key ID
+                        name = key_alias if key_alias else key_id
+
+                        # Create resource
+                        resource = Resource(
+                            arn=key_arn,
+                            resource_type="AWS::KMS::Key",
+                            name=name,
+                            region=self.region,
+                            tags=tags,
+                            config_hash=compute_config_hash(config),
+                            created_at=created_at,
+                            raw_config=config,
+                        )
+                        resources.append(resource)
+
+                    except Exception as e:
+                        self.logger.debug(f"Error processing key {key_id}: {e}")
+                        continue
+
+        except Exception as e:
+            self.logger.error(f"Error collecting KMS keys in {self.region}: {e}")
+
+        self.logger.debug(f"Collected {len(resources)} KMS keys in {self.region}")
+        return resources

src/snapshot/resource_collectors/lambda_func.py

@@ -0,0 +1,112 @@
+"""Lambda resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class LambdaCollector(BaseResourceCollector):
+    """Collector for AWS Lambda functions and layers."""
+
+    @property
+    def service_name(self) -> str:
+        return "lambda"
+
+    def collect(self) -> List[Resource]:
+        """Collect Lambda resources.
+
+        Returns:
+            List of Lambda functions and layers
+        """
+        resources = []
+        account_id = self._get_account_id()
+
+        # Collect functions
+        resources.extend(self._collect_functions(account_id))
+
+        # Collect layers
+        resources.extend(self._collect_layers(account_id))
+
+        self.logger.debug(f"Collected {len(resources)} Lambda resources in {self.region}")
+        return resources
+
+    def _collect_functions(self, account_id: str) -> List[Resource]:
+        """Collect Lambda functions."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_functions")
+            for page in paginator.paginate():
+                for function in page["Functions"]:
+                    function_name = function["FunctionName"]
+                    function_arn = function["FunctionArn"]
+
+                    # Get full function configuration (includes tags)
+                    try:
+                        full_config = client.get_function(FunctionName=function_name)
+                        tags = full_config.get("Tags", {})
+                        config_data = full_config.get("Configuration", function)
+                    except Exception as e:
+                        self.logger.debug(f"Could not get full config for {function_name}: {e}")
+                        tags = {}
+                        config_data = function
+
+                    # Create resource
+                    resource = Resource(
+                        arn=function_arn,
+                        resource_type="AWS::Lambda::Function",
+                        name=function_name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(config_data),
+                        created_at=None,  # Lambda doesn't expose creation date easily
+                        raw_config=config_data,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting Lambda functions in {self.region}: {e}")
+
+        return resources
+
+    def _collect_layers(self, account_id: str) -> List[Resource]:
+        """Collect Lambda layers."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_layers")
+            for page in paginator.paginate():
+                for layer in page["Layers"]:
+                    layer_name = layer["LayerName"]
+                    layer_arn = layer["LayerArn"]
+
+                    # Get latest version info
+                    try:
+                        latest_version = layer.get("LatestMatchingVersion", {})
+                        layer_version_arn = latest_version.get("LayerVersionArn", layer_arn)
+                        created_date = latest_version.get("CreatedDate")
+
+                        # Create resource
+                        resource = Resource(
+                            arn=layer_version_arn,
+                            resource_type="AWS::Lambda::LayerVersion",
+                            name=layer_name,
+                            region=self.region,
+                            tags={},  # Layers don't support tags
+                            config_hash=compute_config_hash(layer),
+                            created_at=created_date,
+                            raw_config=layer,
+                        )
+                        resources.append(resource)
+
+                    except Exception as e:
+                        self.logger.debug(f"Could not get layer version for {layer_name}: {e}")
+
+        except Exception as e:
+            self.logger.error(f"Error collecting Lambda layers in {self.region}: {e}")
+
+        return resources