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

src/snapshot/resource_collectors/eks.py

@@ -0,0 +1,200 @@
+"""EKS resource collector."""
+
+from typing import List, Tuple
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class EKSCollector(BaseResourceCollector):
+    """Collector for Amazon EKS (Elastic Kubernetes Service) resources."""
+
+    @property
+    def service_name(self) -> str:
+        return "eks"
+
+    def collect(self) -> List[Resource]:
+        """Collect EKS resources.
+
+        Collects:
+        - EKS Clusters
+        - Node Groups (within each cluster)
+        - Fargate Profiles (within each cluster)
+
+        Returns:
+            List of EKS resources
+        """
+        resources = []
+
+        # Collect clusters
+        cluster_resources, cluster_names = self._collect_clusters()
+        resources.extend(cluster_resources)
+
+        # Collect node groups for each cluster
+        resources.extend(self._collect_node_groups(cluster_names))
+
+        # Collect Fargate profiles for each cluster
+        resources.extend(self._collect_fargate_profiles(cluster_names))
+
+        self.logger.debug(f"Collected {len(resources)} EKS resources in {self.region}")
+        return resources
+
+    def _collect_clusters(self) -> Tuple[List[Resource], List[str]]:  # type: ignore
+        """Collect EKS clusters.
+
+        Returns:
+            Tuple of (list of cluster resources, list of cluster names)
+        """
+        resources = []
+        cluster_names = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_clusters")
+            for page in paginator.paginate():
+                for cluster_name in page.get("clusters", []):
+                    cluster_names.append(cluster_name)
+
+                    try:
+                        # Get detailed cluster info
+                        cluster_response = client.describe_cluster(name=cluster_name)
+                        cluster = cluster_response.get("cluster", {})
+
+                        cluster_arn = cluster.get("arn", "")
+
+                        # Extract tags
+                        tags = cluster.get("tags", {})
+
+                        # Extract creation date
+                        created_at = cluster.get("createdAt")
+
+                        # Create resource
+                        resource = Resource(
+                            arn=cluster_arn,
+                            resource_type="AWS::EKS::Cluster",
+                            name=cluster_name,
+                            region=self.region,
+                            tags=tags,
+                            config_hash=compute_config_hash(cluster),
+                            created_at=created_at,
+                            raw_config=cluster,
+                        )
+                        resources.append(resource)
+
+                    except Exception as e:
+                        self.logger.debug(f"Error processing cluster {cluster_name}: {e}")
+                        continue
+
+        except Exception as e:
+            self.logger.error(f"Error collecting EKS clusters in {self.region}: {e}")
+
+        return resources, cluster_names
+
+    def _collect_node_groups(self, cluster_names: List[str]) -> List[Resource]:
+        """Collect EKS node groups for given clusters.
+
+        Args:
+            cluster_names: List of cluster names to collect node groups from
+
+        Returns:
+            List of node group resources
+        """
+        resources = []
+        client = self._create_client()
+
+        for cluster_name in cluster_names:
+            try:
+                paginator = client.get_paginator("list_nodegroups")
+                for page in paginator.paginate(clusterName=cluster_name):
+                    for nodegroup_name in page.get("nodegroups", []):
+                        try:
+                            # Get detailed node group info
+                            ng_response = client.describe_nodegroup(
+                                clusterName=cluster_name, nodegroupName=nodegroup_name
+                            )
+                            nodegroup = ng_response.get("nodegroup", {})
+
+                            ng_arn = nodegroup.get("nodegroupArn", "")
+
+                            # Extract tags
+                            tags = nodegroup.get("tags", {})
+
+                            # Extract creation date
+                            created_at = nodegroup.get("createdAt")
+
+                            # Create resource
+                            resource = Resource(
+                                arn=ng_arn,
+                                resource_type="AWS::EKS::Nodegroup",
+                                name=f"{cluster_name}/{nodegroup_name}",
+                                region=self.region,
+                                tags=tags,
+                                config_hash=compute_config_hash(nodegroup),
+                                created_at=created_at,
+                                raw_config=nodegroup,
+                            )
+                            resources.append(resource)
+
+                        except Exception as e:
+                            self.logger.debug(f"Error processing node group {nodegroup_name}: {e}")
+                            continue
+
+            except Exception as e:
+                self.logger.debug(f"Error collecting node groups for cluster {cluster_name}: {e}")
+
+        return resources
+
+    def _collect_fargate_profiles(self, cluster_names: List[str]) -> List[Resource]:
+        """Collect EKS Fargate profiles for given clusters.
+
+        Args:
+            cluster_names: List of cluster names to collect Fargate profiles from
+
+        Returns:
+            List of Fargate profile resources
+        """
+        resources = []
+        client = self._create_client()
+
+        for cluster_name in cluster_names:
+            try:
+                paginator = client.get_paginator("list_fargate_profiles")
+                for page in paginator.paginate(clusterName=cluster_name):
+                    for profile_name in page.get("fargateProfileNames", []):
+                        try:
+                            # Get detailed Fargate profile info
+                            profile_response = client.describe_fargate_profile(
+                                clusterName=cluster_name, fargateProfileName=profile_name
+                            )
+                            profile = profile_response.get("fargateProfile", {})
+
+                            profile_arn = profile.get("fargateProfileArn", "")
+
+                            # Extract tags
+                            tags = profile.get("tags", {})
+
+                            # Extract creation date
+                            created_at = profile.get("createdAt")
+
+                            # Create resource
+                            resource = Resource(
+                                arn=profile_arn,
+                                resource_type="AWS::EKS::FargateProfile",
+                                name=f"{cluster_name}/{profile_name}",
+                                region=self.region,
+                                tags=tags,
+                                config_hash=compute_config_hash(profile),
+                                created_at=created_at,
+                                raw_config=profile,
+                            )
+                            resources.append(resource)
+
+                        except Exception as e:
+                            self.logger.debug(f"Error processing Fargate profile {profile_name}: {e}")
+                            continue
+
+            except Exception as e:
+                self.logger.debug(f"Error collecting Fargate profiles for cluster {cluster_name}: {e}")
+
+        return resources

src/snapshot/resource_collectors/elasticache_collector.py

@@ -0,0 +1,79 @@
+"""ElastiCache resource collector."""
+
+from __future__ import annotations
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class ElastiCacheCollector(BaseResourceCollector):
+    """Collector for AWS ElastiCache resources (Redis and Memcached clusters)."""
+
+    @property
+    def service_name(self) -> str:
+        return "elasticache"
+
+    def collect(self) -> List[Resource]:
+        """Collect ElastiCache cluster resources.
+
+        Collects both Redis and Memcached clusters using the ElastiCache API.
+
+        Returns:
+            List of ElastiCache cluster resources
+        """
+        resources = []
+        account_id = self._get_account_id()
+
+        # Collect cache clusters (both Redis and Memcached)
+        resources.extend(self._collect_cache_clusters(account_id))
+
+        self.logger.debug(f"Collected {len(resources)} ElastiCache clusters in {self.region}")
+        return resources
+
+    def _collect_cache_clusters(self, account_id: str) -> List[Resource]:
+        """Collect ElastiCache cache clusters.
+
+        Args:
+            account_id: AWS account ID
+
+        Returns:
+            List of Resource objects representing ElastiCache clusters
+        """
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("describe_cache_clusters")
+            # ShowCacheNodeInfo=False for performance (we don't need node-level details)
+            for page in paginator.paginate(ShowCacheNodeInfo=False):
+                for cluster in page.get("CacheClusters", []):
+                    cluster_id = cluster["CacheClusterId"]
+                    cluster_arn = cluster["ARN"]
+
+                    # Extract tags
+                    tags = {}
+                    try:
+                        tag_response = client.list_tags_for_resource(ResourceName=cluster_arn)
+                        tags = {tag["Key"]: tag["Value"] for tag in tag_response.get("TagList", [])}
+                    except Exception as e:
+                        self.logger.debug(f"Could not get tags for ElastiCache cluster {cluster_id}: {e}")
+
+                    # Create resource
+                    resource = Resource(
+                        arn=cluster_arn,
+                        resource_type="elasticache:cluster",
+                        name=cluster_id,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(cluster),
+                        raw_config=cluster,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting ElastiCache clusters in {self.region}: {e}")
+
+        return resources

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