aws-inventory-manager 0.13.2__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/efs_collector.py

@@ -0,0 +1,102 @@
+"""EFS resource collector."""
+
+from __future__ import annotations
+
+from typing import List
+
+from botocore.exceptions import ClientError
+
+from ...models.efs_resource import EFSFileSystem
+from ...models.resource import Resource
+from .base import BaseResourceCollector
+
+
+class EFSCollector(BaseResourceCollector):
+    """Collector for AWS EFS (Elastic File System) resources."""
+
+    @property
+    def service_name(self) -> str:
+        return "efs"
+
+    @property
+    def is_global_service(self) -> bool:
+        return False
+
+    def collect(self) -> List[Resource]:
+        """Collect EFS file systems.
+
+        Returns:
+            List of EFS file system resources
+        """
+        resources = []
+
+        try:
+            client = self._create_client()
+
+            # Use paginator for describe_file_systems
+            paginator = client.get_paginator("describe_file_systems")
+
+            for page in paginator.paginate():
+                for fs in page.get("FileSystems", []):
+                    try:
+                        # Extract basic file system information
+                        file_system_id = fs["FileSystemId"]
+                        arn = fs["FileSystemArn"]
+                        created_at = fs.get("CreationTime")
+                        lifecycle_state = fs.get("LifeCycleState", "unknown")
+                        performance_mode = fs.get("PerformanceMode", "generalPurpose")
+                        encrypted = fs.get("Encrypted", False)
+                        kms_key_id = fs.get("KmsKeyId")
+
+                        # Extract tags
+                        tags = {}
+                        for tag in fs.get("Tags", []):
+                            tags[tag["Key"]] = tag["Value"]
+
+                        # Create EFSFileSystem model
+                        efs_fs = EFSFileSystem(
+                            file_system_id=file_system_id,
+                            arn=arn,
+                            encryption_enabled=encrypted,
+                            kms_key_id=kms_key_id,
+                            performance_mode=performance_mode,
+                            lifecycle_state=lifecycle_state,
+                            tags=tags,
+                            region=self.region,
+                            created_at=created_at,
+                        )
+
+                        # Convert to Resource
+                        resource_dict = efs_fs.to_resource_dict()
+                        resource = Resource(
+                            arn=resource_dict["arn"],
+                            resource_type=resource_dict["resource_type"],
+                            name=resource_dict["name"],
+                            region=resource_dict["region"],
+                            tags=resource_dict["tags"],
+                            config_hash=resource_dict["config_hash"],
+                            created_at=resource_dict["created_at"],
+                            raw_config=resource_dict["raw_config"],
+                        )
+
+                        resources.append(resource)
+
+                    except Exception as e:
+                        self.logger.debug(f"Error processing EFS file system {fs.get('FileSystemId', 'unknown')}: {e}")
+                        continue
+
+        except ClientError as e:
+            error_code = e.response.get("Error", {}).get("Code", "Unknown")
+            # Handle regions where EFS is not available or access denied
+            if error_code in ["OptInRequired", "AccessDenied", "InvalidAction"]:
+                self.logger.debug(f"EFS not available or access denied in {self.region}: {error_code}")
+            else:
+                self.logger.error(f"Error collecting EFS file systems in {self.region}: {e}")
+            return []
+
+        except Exception as e:
+            self.logger.error(f"Error collecting EFS file systems in {self.region}: {e}")
+            return []
+
+        self.logger.debug(f"Collected {len(resources)} EFS file systems in {self.region}")
+        return resources