regscale-cli 6.16.0.0__py3-none-any.whl

regscale/integrations/commercial/aws/inventory/resources/integration.py

@@ -0,0 +1,237 @@
+"""AWS application integration resource collectors."""
+
+from typing import Dict, List, Any
+
+from ..base import BaseCollector
+
+
+class IntegrationCollector(BaseCollector):
+    """Collector for AWS application integration resources."""
+
+    def get_api_gateways(self) -> Dict[str, List[Dict[str, Any]]]:
+        """
+        Get information about API Gateway APIs (REST and HTTP).
+
+        :return: Dictionary containing API Gateway information
+        :rtype: Dict[str, List[Dict[str, Any]]]
+        """
+        apis = {"REST": [], "HTTP": []}
+        try:
+            # Get REST APIs
+            apigw = self._get_client("apigateway")
+            rest_paginator = apigw.get_paginator("get_rest_apis")
+
+            for page in rest_paginator.paginate():
+                for api in page.get("items", []):
+                    try:
+                        stages = apigw.get_stages(restApiId=api["id"])["item"]
+                        apis["REST"].append(
+                            {
+                                "Region": self.region,
+                                "Id": api.get("id"),
+                                "Name": api.get("name"),
+                                "Description": api.get("description"),
+                                "CreatedDate": str(api.get("createdDate")),
+                                "Version": api.get("version"),
+                                "EndpointConfiguration": api.get("endpointConfiguration", {}),
+                                "Stages": [
+                                    {
+                                        "StageName": stage.get("stageName"),
+                                        "DeploymentId": stage.get("deploymentId"),
+                                        "Description": stage.get("description"),
+                                        "CreatedDate": str(stage.get("createdDate")),
+                                        "LastUpdatedDate": str(stage.get("lastUpdatedDate")),
+                                    }
+                                    for stage in stages
+                                ],
+                            }
+                        )
+                    except Exception as e:
+                        self._handle_error(e, f"REST API {api['name']}")
+
+            # Get HTTP APIs
+            apigwv2 = self._get_client("apigatewayv2")
+            http_paginator = apigwv2.get_paginator("get_apis")
+
+            for page in http_paginator.paginate():
+                for api in page.get("Items", []):
+                    try:
+                        stages = apigwv2.get_stages(ApiId=api["ApiId"])["Items"]
+                        apis["HTTP"].append(
+                            {
+                                "Region": self.region,
+                                "Id": api.get("ApiId"),
+                                "Name": api.get("Name"),
+                                "Description": api.get("Description"),
+                                "ProtocolType": api.get("ProtocolType"),
+                                "CreatedDate": str(api.get("CreatedDate")),
+                                "ApiEndpoint": api.get("ApiEndpoint"),
+                                "Stages": [
+                                    {
+                                        "StageName": stage.get("StageName"),
+                                        "Description": stage.get("Description"),
+                                        "CreatedDate": str(stage.get("CreatedDate")),
+                                        "LastUpdatedDate": str(stage.get("LastUpdatedDate")),
+                                        "DefaultRouteSettings": stage.get("DefaultRouteSettings", {}),
+                                    }
+                                    for stage in stages
+                                ],
+                            }
+                        )
+                    except Exception as e:
+                        self._handle_error(e, f"HTTP API {api['Name']}")
+        except Exception as e:
+            self._handle_error(e, "API Gateway APIs")
+        return apis
+
+    def get_sns_topics(self) -> List[Dict[str, Any]]:
+        """
+        Get information about SNS topics.
+
+        :return: List of SNS topic information
+        :rtype: List[Dict[str, Any]]
+        """
+        topics = []
+        try:
+            sns = self._get_client("sns")
+            paginator = sns.get_paginator("list_topics")
+
+            for page in paginator.paginate():
+                for topic in page.get("Topics", []):
+                    try:
+                        # Get topic attributes
+                        attrs = sns.get_topic_attributes(TopicArn=topic["TopicArn"])["Attributes"]
+                        # Get subscriptions
+                        subs = []
+                        sub_paginator = sns.get_paginator("list_subscriptions_by_topic")
+                        for sub_page in sub_paginator.paginate(TopicArn=topic["TopicArn"]):
+                            subs.extend(sub_page.get("Subscriptions", []))
+
+                        topics.append(
+                            {
+                                "Region": self.region,
+                                "TopicArn": topic.get("TopicArn"),
+                                "Owner": attrs.get("Owner"),
+                                "Policy": attrs.get("Policy"),
+                                "DisplayName": attrs.get("DisplayName"),
+                                "SubscriptionsConfirmed": attrs.get("SubscriptionsConfirmed"),
+                                "SubscriptionsPending": attrs.get("SubscriptionsPending"),
+                                "SubscriptionsDeleted": attrs.get("SubscriptionsDeleted"),
+                                "Subscriptions": [
+                                    {
+                                        "SubscriptionArn": sub.get("SubscriptionArn"),
+                                        "Protocol": sub.get("Protocol"),
+                                        "Endpoint": sub.get("Endpoint"),
+                                    }
+                                    for sub in subs
+                                ],
+                            }
+                        )
+                    except Exception as e:
+                        self._handle_error(e, f"SNS topic {topic['TopicArn']}")
+        except Exception as e:
+            self._handle_error(e, "SNS topics")
+        return topics
+
+    def get_sqs_queues(self) -> List[Dict[str, Any]]:
+        """
+        Get information about SQS queues.
+
+        :return: List of SQS queue information
+        :rtype: List[Dict[str, Any]]
+        """
+        queues = []
+        try:
+            sqs = self._get_client("sqs")
+            paginator = sqs.get_paginator("list_queues")
+
+            for page in paginator.paginate():
+                for queue_url in page.get("QueueUrls", []):
+                    try:
+                        # Get queue attributes
+                        attrs = sqs.get_queue_attributes(QueueUrl=queue_url, AttributeNames=["All"])["Attributes"]
+
+                        queues.append(
+                            {
+                                "Region": self.region,
+                                "QueueUrl": queue_url,
+                                "QueueArn": attrs.get("QueueArn"),
+                                "ApproximateNumberOfMessages": attrs.get("ApproximateNumberOfMessages"),
+                                "ApproximateNumberOfMessagesNotVisible": attrs.get(
+                                    "ApproximateNumberOfMessagesNotVisible"
+                                ),
+                                "ApproximateNumberOfMessagesDelayed": attrs.get("ApproximateNumberOfMessagesDelayed"),
+                                "CreatedTimestamp": attrs.get("CreatedTimestamp"),
+                                "LastModifiedTimestamp": attrs.get("LastModifiedTimestamp"),
+                                "VisibilityTimeout": attrs.get("VisibilityTimeout"),
+                                "MaximumMessageSize": attrs.get("MaximumMessageSize"),
+                                "MessageRetentionPeriod": attrs.get("MessageRetentionPeriod"),
+                                "DelaySeconds": attrs.get("DelaySeconds"),
+                                "Policy": attrs.get("Policy"),
+                                "RedrivePolicy": attrs.get("RedrivePolicy"),
+                            }
+                        )
+                    except Exception as e:
+                        self._handle_error(e, f"SQS queue {queue_url}")
+        except Exception as e:
+            self._handle_error(e, "SQS queues")
+        return queues
+
+    def get_eventbridge_rules(self) -> List[Dict[str, Any]]:
+        """
+        Get information about EventBridge rules.
+
+        :return: List of EventBridge rule information
+        :rtype: List[Dict[str, Any]]
+        """
+        rules = []
+        try:
+            events = self._get_client("events")
+            paginator = events.get_paginator("list_rules")
+
+            for page in paginator.paginate():
+                for rule in page.get("Rules", []):
+                    try:
+                        # Get targets for this rule
+                        targets = events.list_targets_by_rule(Rule=rule["Name"])["Targets"]
+
+                        rules.append(
+                            {
+                                "Region": self.region,
+                                "Name": rule.get("Name"),
+                                "Arn": rule.get("Arn"),
+                                "Description": rule.get("Description"),
+                                "State": rule.get("State"),
+                                "ScheduleExpression": rule.get("ScheduleExpression"),
+                                "EventPattern": rule.get("EventPattern"),
+                                "Targets": [
+                                    {
+                                        "Id": target.get("Id"),
+                                        "Arn": target.get("Arn"),
+                                        "RoleArn": target.get("RoleArn"),
+                                        "Input": target.get("Input"),
+                                        "InputPath": target.get("InputPath"),
+                                    }
+                                    for target in targets
+                                ],
+                            }
+                        )
+                    except Exception as e:
+                        self._handle_error(e, f"EventBridge rule {rule['Name']}")
+        except Exception as e:
+            self._handle_error(e, "EventBridge rules")
+        return rules
+
+    def collect(self) -> Dict[str, Any]:
+        """
+        Collect all application integration resources.
+
+        :return: Dictionary containing all application integration resource information
+        :rtype: Dict[str, Any]
+        """
+        return {
+            "APIGateway": self.get_api_gateways(),
+            "SNSTopics": self.get_sns_topics(),
+            "SQSQueues": self.get_sqs_queues(),
+            "EventBridgeRules": self.get_eventbridge_rules(),
+        }

regscale/integrations/commercial/aws/inventory/resources/networking.py

@@ -0,0 +1,253 @@
+"""AWS networking resource collectors."""
+
+from typing import Dict, List, Any
+
+from ..base import BaseCollector
+
+
+class NetworkingCollector(BaseCollector):
+    """Collector for AWS networking resources."""
+
+    def get_vpcs(self) -> List[Dict[str, Any]]:
+        """
+        Get information about VPCs.
+
+        :return: List of VPC information
+        :rtype: List[Dict[str, Any]]
+        """
+        vpcs = []
+        try:
+            ec2 = self._get_client("ec2")
+            paginator = ec2.get_paginator("describe_vpcs")
+
+            for page in paginator.paginate():
+                for vpc in page.get("Vpcs", []):
+                    # Get subnets for this VPC
+                    subnets = []
+                    subnet_paginator = ec2.get_paginator("describe_subnets")
+                    for subnet_page in subnet_paginator.paginate(
+                        Filters=[{"Name": "vpc-id", "Values": [vpc["VpcId"]]}]
+                    ):
+                        subnets.extend(subnet_page.get("Subnets", []))
+
+                    # Get security groups for this VPC
+                    security_groups = []
+                    sg_paginator = ec2.get_paginator("describe_security_groups")
+                    for sg_page in sg_paginator.paginate(Filters=[{"Name": "vpc-id", "Values": [vpc["VpcId"]]}]):
+                        security_groups.extend(sg_page.get("SecurityGroups", []))
+
+                    vpcs.append(
+                        {
+                            "Region": self.region,
+                            "VpcId": vpc.get("VpcId"),
+                            "CidrBlock": vpc.get("CidrBlock"),
+                            "State": vpc.get("State"),
+                            "IsDefault": vpc.get("IsDefault"),
+                            "Tags": vpc.get("Tags", []),
+                            "Subnets": [
+                                {
+                                    "SubnetId": subnet.get("SubnetId"),
+                                    "CidrBlock": subnet.get("CidrBlock"),
+                                    "AvailabilityZone": subnet.get("AvailabilityZone"),
+                                    "State": subnet.get("State"),
+                                    "Tags": subnet.get("Tags", []),
+                                }
+                                for subnet in subnets
+                            ],
+                            "SecurityGroups": [
+                                {
+                                    "GroupId": sg.get("GroupId"),
+                                    "GroupName": sg.get("GroupName"),
+                                    "Description": sg.get("Description"),
+                                    "IpPermissions": sg.get("IpPermissions", []),
+                                    "IpPermissionsEgress": sg.get("IpPermissionsEgress", []),
+                                    "Tags": sg.get("Tags", []),
+                                }
+                                for sg in security_groups
+                            ],
+                        }
+                    )
+        except Exception as e:
+            self._handle_error(e, "VPCs")
+        return vpcs
+
+    def get_elastic_ips(self) -> List[Dict[str, Any]]:
+        """
+        Get information about Elastic IPs.
+
+        :return: List of Elastic IP information
+        :rtype: List[Dict[str, Any]]
+        """
+        eips = []
+        try:
+            ec2 = self._get_client("ec2")
+            addresses = ec2.describe_addresses().get("Addresses", [])
+
+            for addr in addresses:
+                eips.append(
+                    {
+                        "Region": self.region,
+                        "PublicIp": addr.get("PublicIp"),
+                        "AllocationId": addr.get("AllocationId"),
+                        "InstanceId": addr.get("InstanceId"),
+                        "NetworkInterfaceId": addr.get("NetworkInterfaceId"),
+                        "NetworkInterfaceOwner": addr.get("NetworkInterfaceOwnerId"),
+                        "PrivateIpAddress": addr.get("PrivateIpAddress"),
+                        "Tags": addr.get("Tags", []),
+                    }
+                )
+        except Exception as e:
+            self._handle_error(e, "Elastic IPs")
+        return eips
+
+    def get_load_balancers(self) -> List[Dict[str, Any]]:
+        """
+        Get information about Load Balancers (ALB/NLB).
+
+        :return: List of Load Balancer information
+        :rtype: List[Dict[str, Any]]
+        """
+        lbs = []
+        try:
+            elb = self._get_client("elbv2")
+            paginator = elb.get_paginator("describe_load_balancers")
+
+            for page in paginator.paginate():
+                for lb in page.get("LoadBalancers", []):
+                    # Get target groups for this LB
+                    target_groups = []
+                    tg_paginator = elb.get_paginator("describe_target_groups")
+                    for tg_page in tg_paginator.paginate(LoadBalancerArn=lb["LoadBalancerArn"]):
+                        target_groups.extend(tg_page.get("TargetGroups", []))
+
+                    lbs.append(
+                        {
+                            "Region": self.region,
+                            "LoadBalancerName": lb.get("LoadBalancerName"),
+                            "DNSName": lb.get("DNSName"),
+                            "Type": lb.get("Type"),
+                            "Scheme": lb.get("Scheme"),
+                            "VpcId": lb.get("VpcId"),
+                            "State": lb.get("State", {}).get("Code"),
+                            "AvailabilityZones": lb.get("AvailabilityZones", []),
+                            "SecurityGroups": lb.get("SecurityGroups", []),
+                            "TargetGroups": [
+                                {
+                                    "TargetGroupName": tg.get("TargetGroupName"),
+                                    "TargetGroupArn": tg.get("TargetGroupArn"),
+                                    "Protocol": tg.get("Protocol"),
+                                    "Port": tg.get("Port"),
+                                    "HealthCheckProtocol": tg.get("HealthCheckProtocol"),
+                                    "HealthCheckPort": tg.get("HealthCheckPort"),
+                                    "HealthCheckPath": tg.get("HealthCheckPath"),
+                                }
+                                for tg in target_groups
+                            ],
+                        }
+                    )
+        except Exception as e:
+            self._handle_error(e, "Load Balancers")
+        return lbs
+
+    def get_cloudfront_distributions(self) -> List[Dict[str, Any]]:
+        """
+        Get information about CloudFront distributions.
+
+        :return: List of CloudFront distribution information
+        :rtype: List[Dict[str, Any]]
+        """
+        distributions = []
+        try:
+            cloudfront = self._get_client("cloudfront")
+            paginator = cloudfront.get_paginator("list_distributions")
+
+            for page in paginator.paginate():
+                for dist in page.get("DistributionList", {}).get("Items", []):
+                    distributions.append(
+                        {
+                            "Region": self.region,
+                            "Id": dist.get("Id"),
+                            "DomainName": dist.get("DomainName"),
+                            "Status": dist.get("Status"),
+                            "Enabled": dist.get("Enabled"),
+                            "Origins": dist.get("Origins", {}).get("Items", []),
+                            "DefaultCacheBehavior": dist.get("DefaultCacheBehavior", {}),
+                            "CacheBehaviors": dist.get("CacheBehaviors", {}).get("Items", []),
+                            "CustomErrorResponses": dist.get("CustomErrorResponses", {}).get("Items", []),
+                            "Comment": dist.get("Comment"),
+                            "PriceClass": dist.get("PriceClass"),
+                            "LastModifiedTime": str(dist.get("LastModifiedTime")),
+                            "WebACLId": dist.get("WebACLId"),
+                        }
+                    )
+        except Exception as e:
+            self._handle_error(e, "CloudFront distributions")
+        return distributions
+
+    def get_route53_info(self) -> Dict[str, List[Dict[str, Any]]]:
+        """
+        Get information about Route53 hosted zones and records.
+
+        :return: Dictionary containing Route53 information
+        :rtype: Dict[str, List[Dict[str, Any]]]
+        """
+        route53_info = {"HostedZones": [], "Records": []}
+        try:
+            route53 = self._get_client("route53")
+
+            # Get hosted zones
+            paginator = route53.get_paginator("list_hosted_zones")
+            for page in paginator.paginate():
+                for zone in page.get("HostedZones", []):
+                    try:
+                        # Get records for this zone
+                        records = []
+                        record_paginator = route53.get_paginator("list_resource_record_sets")
+                        for record_page in record_paginator.paginate(HostedZoneId=zone["Id"]):
+                            for record in record_page.get("ResourceRecordSets", []):
+                                records.append(
+                                    {
+                                        "Name": record.get("Name"),
+                                        "Type": record.get("Type"),
+                                        "TTL": record.get("TTL"),
+                                        "ResourceRecords": record.get("ResourceRecords", []),
+                                        "AliasTarget": record.get("AliasTarget"),
+                                        "Weight": record.get("Weight"),
+                                        "Region": record.get("Region"),
+                                        "GeoLocation": record.get("GeoLocation"),
+                                        "Failover": record.get("Failover"),
+                                        "MultiValueAnswer": record.get("MultiValueAnswer"),
+                                        "HealthCheckId": record.get("HealthCheckId"),
+                                    }
+                                )
+
+                        route53_info["HostedZones"].append(
+                            {
+                                "Id": zone.get("Id"),
+                                "Name": zone.get("Name"),
+                                "CallerReference": zone.get("CallerReference"),
+                                "Config": zone.get("Config", {}),
+                                "ResourceRecordSetCount": zone.get("ResourceRecordSetCount"),
+                                "Records": records,
+                            }
+                        )
+                    except Exception as e:
+                        self._handle_error(e, f"Route53 zone {zone['Name']}")
+        except Exception as e:
+            self._handle_error(e, "Route53 zones")
+        return route53_info
+
+    def collect(self) -> Dict[str, Any]:
+        """
+        Collect all networking resources.
+
+        :return: Dictionary containing all networking resource information
+        :rtype: Dict[str, Any]
+        """
+        return {
+            "VPCs": self.get_vpcs(),
+            "ElasticIPs": self.get_elastic_ips(),
+            "LoadBalancers": self.get_load_balancers(),
+            "CloudFrontDistributions": self.get_cloudfront_distributions(),
+            "Route53": self.get_route53_info(),
+        }