stackport 0.3.4__tar.gz → 0.3.7__tar.gz

{stackport-0.3.4/stackport.egg-info → stackport-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.3.4
+Version: 0.3.7
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT
@@ -29,6 +29,7 @@ Requires-Dist: websockets>=12.0
 Requires-Dist: python-multipart>=0.0.26
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
 Requires-Dist: httpx>=0.27.0; extra == "dev"
 Requires-Dist: moto[dynamodb,iam,lambda,s3,sqs]>=5.0; extra == "dev"
 Dynamic: license-file

{stackport-0.3.4 → stackport-0.3.7}/backend/main.py

@@ -17,7 +17,7 @@ from botocore.exceptions import (
 )
 
 from backend.config import LOG_LEVEL, STACKPORT_ALLOW_WRITES, STACKPORT_PORT
-from backend.routes import dynamodb, ec2, endpoints, iam, lambda_svc, logs, resources, s3, secretsmanager, sqs, stats, stepfunctions, tags
+from backend.routes import dynamodb, ec2, endpoints, iam, lambda_svc, logs, resources, rds, s3, secretsmanager, sqs, stats, stepfunctions, tags
 from backend.websocket import probe_loop, websocket_endpoint
 
 
@@ -120,12 +120,13 @@ app.include_router(dynamodb.router, prefix="/api/dynamodb")
 app.include_router(lambda_svc.router, prefix="/api/lambda", tags=["lambda"])
 app.include_router(sqs.router, prefix="/api/sqs", tags=["sqs"])
 app.include_router(iam.router, prefix="/api/iam", tags=["iam"])
-app.include_router(ec2.router, prefix="/api/ec2", tags=["ec2"])
+app.include_router(ec2.router, prefix="/api/ec2", tags=["ec2", "autoscaling"])
 app.include_router(logs.router, prefix="/api/logs", tags=["logs"])
 app.include_router(secretsmanager.router, prefix="/api/secretsmanager", tags=["secretsmanager"])
 app.include_router(stepfunctions.router, prefix="/api/stepfunctions", tags=["stepfunctions"])
 app.include_router(tags.router, prefix="/api", tags=["tags"])
 app.include_router(resources.router, prefix="/api")
+app.include_router(rds.router, prefix="/api/rds", tags=["rds"])
 
 
 # WebSocket endpoint for real-time updates

{stackport-0.3.4 → stackport-0.3.7}/backend/routes/ec2.py

@@ -38,6 +38,49 @@ def _decode_user_data(encoded: str | None) -> str | None:
     except Exception:
         return None
 
+def _map_asg_instance(inst: dict) -> dict:
+    """Map an Auto Scaling Group instance to a camelCase shape."""
+    return {
+        "instanceId": inst.get("InstanceId"),
+        "instanceType": inst.get("InstanceType"),
+        "lifecycleState": inst.get("LifecycleState"),
+        "healthStatus": inst.get("HealthStatus"),
+        "availabilityZone": inst.get("AvailabilityZone"),
+    }
+
+
+@router.get("/asgs")
+def list_autoscaling_groups(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """List all Auto Scaling Groups with their instances."""
+    try:
+        client = get_client("autoscaling", **ep.client_kwargs())
+        paginator = client.get_paginator("describe_auto_scaling_groups")
+
+        all_groups = []
+        for page in paginator.paginate():
+            for group in page.get("AutoScalingGroups", []):
+                created_time = group.get("CreatedTime")
+                instances = group.get("Instances", [])
+                all_groups.append(
+                    {
+                        "autoScalingGroupARN": group["AutoScalingGroupARN"],
+                        "autoScalingGroupName": group["AutoScalingGroupName"],
+                        "createdTime": created_time.isoformat() if created_time else None,
+                        "desiredCapacity": group["DesiredCapacity"],
+                        "maxSize": group["MaxSize"],
+                        "minSize": group["MinSize"],
+                        "availabilityZones": group.get("AvailabilityZones", []),
+                        "healthCheckGracePeriod": group.get("HealthCheckGracePeriod", 0),
+                        "instanceCount": len(instances),
+                        "instances": [_map_asg_instance(i) for i in instances],
+                        "loadBalancerNames": group.get("LoadBalancerNames", []),
+                        "tags": group.get("Tags", []),
+                    }
+                )
+        return {"auto_scaling_groups": all_groups}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 
 @router.get("/instances")
 def list_instances(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
@@ -258,6 +301,162 @@ def list_security_groups(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[
         raise HTTPException(status_code=500, detail=str(e))
 
 
+def _get_rule_id(rule: dict, rule_type: str, idx: int) -> str:
+    """Generate a rule ID based on rule properties."""
+    return f"{rule_type}-sgrule-{idx:04d}"
+
+
+def _get_ip_version(ip_range: dict | None, ipv6_range: dict | None) -> str:
+    """Determine IP version from rule."""
+    if ipv6_range:
+        return "IPv6"
+    if ip_range:
+        cidr = ip_range.get("CidrIp", "")
+        return "IPv6" if ":" in cidr else "IPv4"
+    return "IPv4"
+
+
+def _format_port_range(protocol: str, from_port: int | None, to_port: int | None) -> str:
+    """Format port range for display."""
+    if protocol == "-1" or protocol == "all":
+        return "All"
+    if from_port is None and to_port is None:
+        return "All"
+    if from_port is not None and to_port is not None and from_port != to_port:
+        return f"{from_port}-{to_port}"
+    if from_port is not None:
+        return str(from_port)
+    return "All"
+
+
+def _expand_rules(ip_permissions: list[dict], rule_type: str) -> list[dict]:
+    """Expand IP permissions into individual rule rows."""
+    expanded = []
+    rule_idx = 0
+    
+    for perm in ip_permissions:
+        protocol = perm.get("IpProtocol", "tcp")
+        from_port = perm.get("FromPort")
+        to_port = perm.get("ToPort")
+        
+        # Normalize protocol display
+        if protocol == "-1":
+            protocol = "All"
+        
+        # Expand IPv4 ranges
+        for ip_range in perm.get("IpRanges", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv4",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": ip_range.get("CidrIp", ""),
+                "description": ip_range.get("Description", ""),
+            })
+            rule_idx += 1
+        
+        # Expand IPv6 ranges
+        for ipv6_range in perm.get("Ipv6Ranges", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv6",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": ipv6_range.get("CidrIpv6", ""),
+                "description": ipv6_range.get("Description", ""),
+            })
+            rule_idx += 1
+        
+        # Expand prefix list IDs
+        for prefix_list in perm.get("PrefixListIds", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv4",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": prefix_list.get("PrefixListId", ""),
+                "description": "",
+            })
+            rule_idx += 1
+        
+        # Expand user ID group pairs (security group references)
+        for group_pair in perm.get("UserIdGroupPairs", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv4",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": group_pair.get("GroupId", "") or group_pair.get("GroupName", ""),
+                "description": group_pair.get("Description", ""),
+            })
+            rule_idx += 1
+    
+    # If no rules found, return empty list (don't add placeholder)
+    return expanded
+
+
+@router.get("/security-groups/{group_id}/inbound")
+def get_security_group_inbound_rules(group_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get inbound rules for a specific security group with detailed rule information."""
+    try:
+        client = get_client("ec2", **ep.client_kwargs())
+        response = client.describe_security_groups(GroupIds=[group_id])
+
+        if not response.get("SecurityGroups"):
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+
+        sg = response["SecurityGroups"][0]
+        inbound_rules = _expand_rules(sg.get("IpPermissions", []), "inbound")
+
+        return {
+            "groupId": group_id,
+            "groupName": sg["GroupName"],
+            "inboundRules": inbound_rules,
+        }
+    except HTTPException:
+        raise
+    except client.exceptions.ClientError as e:
+        error_code = e.response["Error"]["Code"]
+        if error_code == "InvalidGroupId.NotFound":
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/security-groups/{group_id}/outbound")
+def get_security_group_outbound_rules(group_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get outbound rules for a specific security group with detailed rule information."""
+    try:
+        client = get_client("ec2", **ep.client_kwargs())
+        response = client.describe_security_groups(GroupIds=[group_id])
+
+        if not response.get("SecurityGroups"):
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+
+        sg = response["SecurityGroups"][0]
+        outbound_rules = _expand_rules(sg.get("IpPermissionsEgress", []), "outbound")
+
+        return {
+            "groupId": group_id,
+            "groupName": sg["GroupName"],
+            "outboundRules": outbound_rules,
+        }
+    except HTTPException:
+        raise
+    except client.exceptions.ClientError as e:
+        error_code = e.response["Error"]["Code"]
+        if error_code == "InvalidGroupId.NotFound":
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @router.get("/vpcs")
 def list_vpcs(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
     """List all VPCs with their subnets."""