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

src/snapshot/resource_collectors/ec2.py

@@ -0,0 +1,240 @@
+"""EC2 resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class EC2Collector(BaseResourceCollector):
+    """Collector for AWS EC2 resources (instances, volumes, VPCs, security groups, etc.)."""
+
+    @property
+    def service_name(self) -> str:
+        return "ec2"
+
+    def collect(self) -> List[Resource]:
+        """Collect EC2 resources.
+
+        Returns:
+            List of EC2 resources
+        """
+        resources = []
+        account_id = self._get_account_id()
+
+        # Collect instances
+        resources.extend(self._collect_instances(account_id))
+
+        # Collect volumes
+        resources.extend(self._collect_volumes(account_id))
+
+        # Collect VPCs
+        resources.extend(self._collect_vpcs(account_id))
+
+        # Collect security groups
+        resources.extend(self._collect_security_groups(account_id))
+
+        # Collect subnets
+        resources.extend(self._collect_subnets(account_id))
+
+        self.logger.debug(f"Collected {len(resources)} EC2 resources in {self.region}")
+        return resources
+
+    def _collect_instances(self, account_id: str) -> List[Resource]:
+        """Collect EC2 instances."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("describe_instances")
+            for page in paginator.paginate():
+                for reservation in page["Reservations"]:
+                    for instance in reservation["Instances"]:
+                        instance_id = instance["InstanceId"]
+
+                        # Extract tags
+                        tags = {}
+                        for tag in instance.get("Tags", []):
+                            tags[tag["Key"]] = tag["Value"]
+
+                        # Get instance name from tags
+                        name = tags.get("Name", instance_id)
+
+                        # Build ARN
+                        arn = f"arn:aws:ec2:{self.region}:{account_id}:instance/{instance_id}"
+
+                        # Create resource
+                        resource = Resource(
+                            arn=arn,
+                            resource_type="AWS::EC2::Instance",
+                            name=name,
+                            region=self.region,
+                            tags=tags,
+                            config_hash=compute_config_hash(instance),
+                            created_at=instance.get("LaunchTime"),
+                            raw_config=instance,
+                        )
+                        resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting EC2 instances in {self.region}: {e}")
+
+        return resources
+
+    def _collect_volumes(self, account_id: str) -> List[Resource]:
+        """Collect EBS volumes."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("describe_volumes")
+            for page in paginator.paginate():
+                for volume in page["Volumes"]:
+                    volume_id = volume["VolumeId"]
+
+                    # Extract tags
+                    tags = {}
+                    for tag in volume.get("Tags", []):
+                        tags[tag["Key"]] = tag["Value"]
+
+                    # Get volume name from tags
+                    name = tags.get("Name", volume_id)
+
+                    # Build ARN
+                    arn = f"arn:aws:ec2:{self.region}:{account_id}:volume/{volume_id}"
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::EC2::Volume",
+                        name=name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(volume),
+                        created_at=volume.get("CreateTime"),
+                        raw_config=volume,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting EBS volumes in {self.region}: {e}")
+
+        return resources
+
+    def _collect_vpcs(self, account_id: str) -> List[Resource]:
+        """Collect VPCs."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            response = client.describe_vpcs()
+            for vpc in response["Vpcs"]:
+                vpc_id = vpc["VpcId"]
+
+                # Extract tags
+                tags = {}
+                for tag in vpc.get("Tags", []):
+                    tags[tag["Key"]] = tag["Value"]
+
+                # Get VPC name from tags
+                name = tags.get("Name", vpc_id)
+
+                # Build ARN
+                arn = f"arn:aws:ec2:{self.region}:{account_id}:vpc/{vpc_id}"
+
+                # Create resource
+                resource = Resource(
+                    arn=arn,
+                    resource_type="AWS::EC2::VPC",
+                    name=name,
+                    region=self.region,
+                    tags=tags,
+                    config_hash=compute_config_hash(vpc),
+                    created_at=None,  # VPCs don't have creation timestamp
+                    raw_config=vpc,
+                )
+                resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting VPCs in {self.region}: {e}")
+
+        return resources
+
+    def _collect_security_groups(self, account_id: str) -> List[Resource]:
+        """Collect security groups."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("describe_security_groups")
+            for page in paginator.paginate():
+                for sg in page["SecurityGroups"]:
+                    sg_id = sg["GroupId"]
+                    sg_name = sg["GroupName"]
+
+                    # Extract tags
+                    tags = {}
+                    for tag in sg.get("Tags", []):
+                        tags[tag["Key"]] = tag["Value"]
+
+                    # Build ARN
+                    arn = f"arn:aws:ec2:{self.region}:{account_id}:security-group/{sg_id}"
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::EC2::SecurityGroup",
+                        name=sg_name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(sg),
+                        created_at=None,  # Security groups don't have creation timestamp
+                        raw_config=sg,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting security groups in {self.region}: {e}")
+
+        return resources
+
+    def _collect_subnets(self, account_id: str) -> List[Resource]:
+        """Collect subnets."""
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("describe_subnets")
+            for page in paginator.paginate():
+                for subnet in page["Subnets"]:
+                    subnet_id = subnet["SubnetId"]
+
+                    # Extract tags
+                    tags = {}
+                    for tag in subnet.get("Tags", []):
+                        tags[tag["Key"]] = tag["Value"]
+
+                    # Get subnet name from tags
+                    name = tags.get("Name", subnet_id)
+
+                    # Build ARN
+                    arn = f"arn:aws:ec2:{self.region}:{account_id}:subnet/{subnet_id}"
+
+                    # Create resource
+                    resource = Resource(
+                        arn=arn,
+                        resource_type="AWS::EC2::Subnet",
+                        name=name,
+                        region=self.region,
+                        tags=tags,
+                        config_hash=compute_config_hash(subnet),
+                        created_at=None,  # Subnets don't have creation timestamp
+                        raw_config=subnet,
+                    )
+                    resources.append(resource)
+
+        except Exception as e:
+            self.logger.error(f"Error collecting subnets in {self.region}: {e}")
+
+        return resources

src/snapshot/resource_collectors/ecs.py

@@ -0,0 +1,215 @@
+"""ECS resource collector."""
+
+from typing import List
+
+from ...models.resource import Resource
+from ...utils.hash import compute_config_hash
+from .base import BaseResourceCollector
+
+
+class ECSCollector(BaseResourceCollector):
+    """Collector for Amazon ECS (Elastic Container Service) resources."""
+
+    @property
+    def service_name(self) -> str:
+        return "ecs"
+
+    def collect(self) -> List[Resource]:
+        """Collect ECS resources.
+
+        Collects:
+        - ECS Clusters
+        - ECS Services (within each cluster)
+        - ECS Task Definitions (active revisions)
+
+        Returns:
+            List of ECS resources
+        """
+        resources = []
+
+        # Collect clusters
+        resources.extend(self._collect_clusters())
+
+        # Collect services (across all clusters)
+        resources.extend(self._collect_services())
+
+        # Collect task definitions
+        resources.extend(self._collect_task_definitions())
+
+        self.logger.debug(f"Collected {len(resources)} ECS resources in {self.region}")
+        return resources
+
+    def _collect_clusters(self) -> List[Resource]:
+        """Collect ECS clusters.
+
+        Returns:
+            List of ECS cluster resources
+        """
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_clusters")
+            for page in paginator.paginate():
+                cluster_arns = page.get("clusterArns", [])
+
+                if not cluster_arns:
+                    continue
+
+                # Get detailed info for clusters (in batches of 100)
+                for i in range(0, len(cluster_arns), 100):
+                    batch = cluster_arns[i : i + 100]
+                    try:
+                        response = client.describe_clusters(clusters=batch, include=["TAGS"])
+                        for cluster in response.get("clusters", []):
+                            cluster_name = cluster["clusterName"]
+                            cluster_arn = cluster["clusterArn"]
+
+                            # Extract tags
+                            tags = {}
+                            for tag in cluster.get("tags", []):
+                                tags[tag["key"]] = tag["value"]
+
+                            # Extract creation timestamp (not always available)
+                            created_at = None
+
+                            # Create resource
+                            resource = Resource(
+                                arn=cluster_arn,
+                                resource_type="AWS::ECS::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 describing cluster batch: {e}")
+
+        except Exception as e:
+            self.logger.error(f"Error collecting ECS clusters in {self.region}: {e}")
+
+        return resources
+
+    def _collect_services(self) -> List[Resource]:
+        """Collect ECS services across all clusters.
+
+        Returns:
+            List of ECS service resources
+        """
+        resources = []
+        client = self._create_client()
+
+        try:
+            # First, get all clusters
+            cluster_arns = []
+            paginator = client.get_paginator("list_clusters")
+            for page in paginator.paginate():
+                cluster_arns.extend(page.get("clusterArns", []))
+
+            # Collect services from each cluster
+            for cluster_arn in cluster_arns:
+                try:
+                    service_paginator = client.get_paginator("list_services")
+                    service_arns = []
+                    for page in service_paginator.paginate(cluster=cluster_arn):
+                        service_arns.extend(page.get("serviceArns", []))
+
+                    if not service_arns:
+                        continue
+
+                    # Get detailed info for services (in batches of 10)
+                    for i in range(0, len(service_arns), 10):
+                        batch = service_arns[i : i + 10]
+                        try:
+                            response = client.describe_services(cluster=cluster_arn, services=batch, include=["TAGS"])
+                            for service in response.get("services", []):
+                                service_name = service["serviceName"]
+                                service_arn = service["serviceArn"]
+
+                                # Extract tags
+                                tags = {}
+                                for tag in service.get("tags", []):
+                                    tags[tag["key"]] = tag["value"]
+
+                                # Extract creation date
+                                created_at = service.get("createdAt")
+
+                                # Create resource
+                                resource = Resource(
+                                    arn=service_arn,
+                                    resource_type="AWS::ECS::Service",
+                                    name=service_name,
+                                    region=self.region,
+                                    tags=tags,
+                                    config_hash=compute_config_hash(service),
+                                    created_at=created_at,
+                                    raw_config=service,
+                                )
+                                resources.append(resource)
+
+                        except Exception as e:
+                            self.logger.debug(f"Error describing service batch: {e}")
+
+                except Exception as e:
+                    self.logger.debug(f"Error collecting services from cluster {cluster_arn}: {e}")
+
+        except Exception as e:
+            self.logger.error(f"Error collecting ECS services in {self.region}: {e}")
+
+        return resources
+
+    def _collect_task_definitions(self) -> List[Resource]:
+        """Collect ECS task definitions (active revisions only).
+
+        Returns:
+            List of ECS task definition resources
+        """
+        resources = []
+        client = self._create_client()
+
+        try:
+            paginator = client.get_paginator("list_task_definitions")
+            for page in paginator.paginate(status="ACTIVE"):
+                for task_def_arn in page.get("taskDefinitionArns", []):
+                    try:
+                        # Get task definition details
+                        response = client.describe_task_definition(taskDefinition=task_def_arn, include=["TAGS"])
+                        task_def = response.get("taskDefinition", {})
+
+                        # Extract family and revision
+                        family = task_def.get("family", "unknown")
+                        revision = task_def.get("revision", 0)
+                        name = f"{family}:{revision}"
+
+                        # Extract tags
+                        tags = {}
+                        for tag in response.get("tags", []):
+                            tags[tag["key"]] = tag["value"]
+
+                        # Task definitions don't have creation timestamp
+                        created_at = None
+
+                        # Create resource
+                        resource = Resource(
+                            arn=task_def_arn,
+                            resource_type="AWS::ECS::TaskDefinition",
+                            name=name,
+                            region=self.region,
+                            tags=tags,
+                            config_hash=compute_config_hash(task_def),
+                            created_at=created_at,
+                            raw_config=task_def,
+                        )
+                        resources.append(resource)
+
+                    except Exception as e:
+                        self.logger.debug(f"Error describing task definition {task_def_arn}: {e}")
+
+        except Exception as e:
+            self.logger.error(f"Error collecting ECS task definitions in {self.region}: {e}")
+
+        return resources

src/snapshot/resource_collectors/eks.py

@@ -0,0 +1,200 @@
+"""EKS resource collector."""
+
+from typing import List
+
+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