Light, fluffy, and always free - The AWS Local Emulator alternative
feat(ec2): support VPC peering connections (#2654)
Allen Sanborn14f99a512304
diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 582cf17587..1594fe3718 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -257,10 +257,44 @@ Floci seeds the following resources on first use in each region so Terraform, th| DeleteRouteTable | Deletes a route table from the local EC2 store. || AssociateRouteTable | Associates a route table with a subnet. || DisassociateRouteTable | Removes a route table association. |-| CreateRoute | Adds a route to a route table. |+| CreateRoute | Adds a route to a route table. Accepts `VpcPeeringConnectionId` as a target (alongside `GatewayId`/`NatGatewayId`/`EgressOnlyInternetGatewayId`) and reports it back on `DescribeRouteTables`. || ReplaceRoute | Replaces the target of an existing route. || DeleteRoute | Removes a route from a route table. |+### VPC Peering Connections++| Action | Description |+|--------|-------------|+| CreateVpcPeeringConnection | Creates a peering connection between the local VPC and a peer VPC, in status `pending-acceptance`. |+| AcceptVpcPeeringConnection | Transitions a `pending-acceptance` connection to `active`. |+| DescribeVpcPeeringConnections | Lists or returns stored peering connections. |+| ModifyVpcPeeringConnectionOptions | Sets `allow_remote_vpc_dns_resolution` independently per side. |+| DeleteVpcPeeringConnection | Deletes a peering connection from the local EC2 store. |++Real AWS never auto-accepts a connection, same-account or not: every `CreateVpcPeeringConnection`+starts `pending-acceptance` and stays there until an explicit `AcceptVpcPeeringConnection`. The+`auto_accept` convenience on Terraform's `aws_vpc_peering_connection` and+`aws_vpc_peering_connection_accepter` resources is implemented by the *provider*, which simply+issues that second call itself — so this emulator does not special-case same-account peers.++A connection is stored keyed by its id alone, not `region::id` like every other EC2 resource here.+It is meaningfully addressable from both the requester's and the accepter's side, which can be a+different region (`peer_region`/`accepter_region`); region-scoped storage would leave the accepter's+`AcceptVpcPeeringConnection`/`DescribeVpcPeeringConnections` calls unable to find a connection+created under the requester's region key. `RejectVpcPeeringConnection` is not implemented — no+Gruntwork VPC-peering example exercises it (they use `auto_accept`, not manual rejection).++The accepter VPC named by `PeerVpcId` may belong to another account or region and not be modelled+in this store at all (a cross-account or "external" peer). Its `cidrBlock` is reported only when+that VPC happens to exist locally; the request still succeeds either way, and no CIDR is fabricated.++A connection's storage entry lives under whichever account's request created it, but lookups+(`AcceptVpcPeeringConnection`, `DescribeVpcPeeringConnections`, `ModifyVpcPeeringConnectionOptions`,+`DeleteVpcPeeringConnection`) resolve it across every account's partition, the same pattern used for+RAM-shared IPAM resources. `AcceptVpcPeeringConnection` additionally enforces that the caller is the+connection's accepter — reporting a connection it cannot see as absent, not as a permission error,+matching how AWS itself responds.+### Network ACLs| Action | Description |diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.javaindex efbbc7dd76..5107fbf716 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java@@ -840,8 +840,10 @@ public class CloudFormationResourceProvisioner {String gatewayId = resolveOptional(props, "GatewayId", engine);String natGatewayId = resolveOptional(props, "NatGatewayId", engine);String egressOnlyInternetGatewayId = resolveOptional(props, "EgressOnlyInternetGatewayId", engine);+ String vpcPeeringConnectionId = resolveOptional(props, "VpcPeeringConnectionId", engine);ec2Service.createRoute(region, routeTableId, destinationCidr, destinationIpv6Cidr,- destinationPrefixListId, gatewayId, natGatewayId, egressOnlyInternetGatewayId);+ destinationPrefixListId, gatewayId, natGatewayId, egressOnlyInternetGatewayId,+ vpcPeeringConnectionId);r.setPhysicalId(r.getLogicalId() + "-" + UUID.randomUUID().toString().substring(0, 8));}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.javaindex b0ae22b90c..af1d3db6e9 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java@@ -32,7 +32,7 @@ public class Ec2QueryHandler {private static final List<String> UNSUPPORTED_ROUTE_TARGETS = List.of("CarrierGatewayId", "CoreNetworkArn", "EgressOnlyInternetGatewayId", "InstanceId","LocalGatewayId", "NetworkInterfaceId", "OdbNetworkArn",- "TransitGatewayId", "VpcEndpointId", "VpcPeeringConnectionId");+ "TransitGatewayId", "VpcEndpointId");/** The gateway id a route table's built-in route carries (see Ec2Service#createRouteTable). */private static final String LOCAL_GATEWAY_ID = "local";@@ -188,6 +188,12 @@ public class Ec2QueryHandler {case "DeleteRouteTable" -> handleDeleteRouteTable(params, region);case "AssociateRouteTable" -> handleAssociateRouteTable(params, region);case "DisassociateRouteTable" -> handleDisassociateRouteTable(params, region);+ case "CreateVpcPeeringConnection" -> handleCreateVpcPeeringConnection(params, region);+ case "AcceptVpcPeeringConnection" -> handleAcceptVpcPeeringConnection(params, region);+ case "DescribeVpcPeeringConnections" -> handleDescribeVpcPeeringConnections(params, region);+ case "ModifyVpcPeeringConnectionOptions" -> handleModifyVpcPeeringConnectionOptions(params, region);+ case "DeleteVpcPeeringConnection" -> handleDeleteVpcPeeringConnection(params, region);+case "CreateRoute" -> handleCreateRoute(params, region);case "ReplaceRoute" -> handleReplaceRoute(params, region);case "DeleteRoute" -> handleDeleteRoute(params, region);@@ -2915,7 +2921,8 @@ public class Ec2QueryHandler {// unimplemented), but the id the caller sent is stored and reported back so an IPv6// egress route is not silently rewritten into a targetless one.String eigwId = p.getFirst("EgressOnlyInternetGatewayId");- service.createRoute(region, rtId, dest, destIpv6, destPrefixList, gwId, natGwId, eigwId);+ String pcxId = p.getFirst("VpcPeeringConnectionId");+ service.createRoute(region, rtId, dest, destIpv6, destPrefixList, gwId, natGwId, eigwId, pcxId);return booleanResponse("CreateRoute");}@@ -2935,16 +2942,17 @@ public class Ec2QueryHandler {String destPrefixList = p.getFirst("DestinationPrefixListId");String gwId = p.getFirst("GatewayId");String natGwId = p.getFirst("NatGatewayId");+ String pcxId = p.getFirst("VpcPeeringConnectionId");// Resetting a route to the local target is expressible: `local` is the gateway id the// route table's built-in route already carries, so it needs no new field on Route.if (Boolean.parseBoolean(p.getFirst("LocalTarget"))) {- if (gwId != null || natGwId != null) {+ if (gwId != null || natGwId != null || pcxId != null) {throw new AwsException("InvalidParameterCombination","ReplaceRoute takes exactly one target.", 400);}gwId = LOCAL_GATEWAY_ID;}- service.replaceRoute(region, rtId, dest, destIpv6, destPrefixList, gwId, natGwId);+ service.replaceRoute(region, rtId, dest, destIpv6, destPrefixList, gwId, natGwId, pcxId);return booleanResponse("ReplaceRoute");}@@ -2957,6 +2965,113 @@ public class Ec2QueryHandler {return booleanResponse("DeleteRoute");}+ // ─── VPC Peering Connection handlers ────────────────────────────────────────++ private Response handleCreateVpcPeeringConnection(MultivaluedMap<String, String> p, String region) {+ String vpcId = p.getFirst("VpcId");+ String peerVpcId = p.getFirst("PeerVpcId");+ String peerOwnerId = p.getFirst("PeerOwnerId");+ String peerRegion = p.getFirst("PeerRegion");+ List<Tag> pcxTags = parseTagsForResource(p, "vpc-peering-connection");+ VpcPeeringConnection pcx = service.createVpcPeeringConnection(region, vpcId, peerVpcId, peerOwnerId,+ peerRegion, pcxTags);+ XmlBuilder xml = new XmlBuilder()+ .start("CreateVpcPeeringConnectionResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("vpcPeeringConnection").raw(vpcPeeringConnectionXml(pcx)).end("vpcPeeringConnection")+ .end("CreateVpcPeeringConnectionResponse");+ return xmlResponse(xml.build());+ }++ private Response handleAcceptVpcPeeringConnection(MultivaluedMap<String, String> p, String region) {+ VpcPeeringConnection pcx = service.acceptVpcPeeringConnection(region, p.getFirst("VpcPeeringConnectionId"));+ XmlBuilder xml = new XmlBuilder()+ .start("AcceptVpcPeeringConnectionResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("vpcPeeringConnection").raw(vpcPeeringConnectionXml(pcx)).end("vpcPeeringConnection")+ .end("AcceptVpcPeeringConnectionResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeVpcPeeringConnections(MultivaluedMap<String, String> p, String region) {+ List<String> ids = getList(p, "VpcPeeringConnectionId");+ Map<String, List<String>> filters = getFilters(p);+ List<VpcPeeringConnection> connections = service.describeVpcPeeringConnections(region, ids, filters);+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeVpcPeeringConnectionsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("vpcPeeringConnectionSet");+ for (VpcPeeringConnection pcx : connections) {+ xml.start("item").raw(vpcPeeringConnectionXml(pcx)).end("item");+ }+ xml.end("vpcPeeringConnectionSet").end("DescribeVpcPeeringConnectionsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleModifyVpcPeeringConnectionOptions(MultivaluedMap<String, String> p, String region) {+ String pcxId = p.getFirst("VpcPeeringConnectionId");+ Boolean accepterDns = parseOptionalBoolean(+ p.getFirst("AccepterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc"),+ "AccepterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc");+ Boolean requesterDns = parseOptionalBoolean(+ p.getFirst("RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc"),+ "RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc");+ VpcPeeringConnection pcx = service.modifyVpcPeeringConnectionOptions(region, pcxId, accepterDns, requesterDns);+ XmlBuilder xml = new XmlBuilder()+ .start("ModifyVpcPeeringConnectionOptionsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("accepterPeeringConnectionOptions")+ .elem("allowDnsResolutionFromRemoteVpc", String.valueOf(pcx.isAccepterAllowRemoteVpcDnsResolution()))+ .end("accepterPeeringConnectionOptions")+ .start("requesterPeeringConnectionOptions")+ .elem("allowDnsResolutionFromRemoteVpc", String.valueOf(pcx.isRequesterAllowRemoteVpcDnsResolution()))+ .end("requesterPeeringConnectionOptions")+ .end("ModifyVpcPeeringConnectionOptionsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDeleteVpcPeeringConnection(MultivaluedMap<String, String> p, String region) {+ service.deleteVpcPeeringConnection(region, p.getFirst("VpcPeeringConnectionId"));+ return booleanResponse("DeleteVpcPeeringConnection");+ }++ private String vpcPeeringConnectionXml(VpcPeeringConnection pcx) {+ XmlBuilder xml = new XmlBuilder()+ .elem("vpcPeeringConnectionId", pcx.getVpcPeeringConnectionId());+ xml.raw(vpcPeeringConnectionVpcInfoXml("requesterVpcInfo", pcx.getRequesterVpcInfo(),+ pcx.isRequesterAllowRemoteVpcDnsResolution()));+ xml.raw(vpcPeeringConnectionVpcInfoXml("accepterVpcInfo", pcx.getAccepterVpcInfo(),+ pcx.isAccepterAllowRemoteVpcDnsResolution()));+ if (pcx.getStatus() != null) {+ xml.start("status")+ .elem("code", pcx.getStatus().getCode())+ .elem("message", pcx.getStatus().getMessage())+ .end("status");+ }+ xml.raw(tagSetXml(pcx.getTags()));+ return xml.build();+ }++ private String vpcPeeringConnectionVpcInfoXml(String elementName, VpcPeeringConnectionVpcInfo info,+ boolean allowRemoteVpcDnsResolution) {+ if (info == null) {+ return "";+ }+ XmlBuilder xml = new XmlBuilder()+ .start(elementName)+ .elem("vpcId", info.getVpcId())+ .elem("ownerId", info.getOwnerId())+ .elem("region", info.getRegion());+ if (info.getCidrBlock() != null) {+ xml.elem("cidrBlock", info.getCidrBlock());+ }+ xml.start("peeringOptions")+ .elem("allowDnsResolutionFromRemoteVpc", String.valueOf(allowRemoteVpcDnsResolution))+ .end("peeringOptions");+ xml.end(elementName);+ return xml.build();+ }+// ─── Network ACL handlers ─────────────────────────────────────────────────private Response handleCreateNetworkAcl(MultivaluedMap<String, String> p, String region) {@@ -3700,6 +3815,7 @@ public class Ec2QueryHandler {.elem("gatewayId", r.getGatewayId()).elem("natGatewayId", r.getNatGatewayId()).elem("egressOnlyInternetGatewayId", r.getEgressOnlyInternetGatewayId())+ .elem("vpcPeeringConnectionId", r.getVpcPeeringConnectionId()).elem("state", r.getState()).elem("origin", r.getOrigin()).end("item");diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex 10297378db..34d9254e60 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -28,6 +28,7 @@ import org.jboss.logging.Logger;import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RequestContext;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsRegions;@@ -36,6 +37,7 @@ import io.github.hectorvent.floci.core.common.ContainerTeardown;import io.github.hectorvent.floci.core.resource.ExplorerResource;import io.github.hectorvent.floci.core.resource.ResourceProvider;import io.github.hectorvent.floci.core.resource.SupportedResourceType;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.InMemoryStorage;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;@@ -93,10 +95,14 @@ import io.github.hectorvent.floci.services.ec2.model.VolumeAttachment;import io.github.hectorvent.floci.services.ec2.model.Vpc;import io.github.hectorvent.floci.services.ec2.model.VpcCidrBlockAssociation;import io.github.hectorvent.floci.services.ec2.model.VpcEndpoint;+import io.github.hectorvent.floci.services.ec2.model.VpcPeeringConnection;+import io.github.hectorvent.floci.services.ec2.model.VpcPeeringConnectionStateReason;+import io.github.hectorvent.floci.services.ec2.model.VpcPeeringConnectionVpcInfo;import jakarta.annotation.PostConstruct;import io.github.hectorvent.floci.services.ec2.model.LaunchSpecification;import io.github.hectorvent.floci.services.ec2.model.SpotInstanceRequest;import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.context.ContextNotActiveException;import jakarta.inject.Inject;@ApplicationScoped@@ -123,6 +129,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {private static final long CONTAINER_LAUNCH_POLL_MILLIS = 50;private final String accountId;+ private final jakarta.enterprise.inject.Instance<RequestContext> requestContextInstance;private final EmulatorConfig config;private final Ec2ContainerManager containerManager;private final Ec2PortForwardManager portForwardManager;@@ -156,17 +163,30 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {private final StorageBackend<String, TransitGatewayVpcAttachment> transitGatewayVpcAttachments;private final StorageBackend<String, TransitGatewayRouteTablePropagation> transitGatewayPropagations;private final StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes;+ // Keyed by id alone, not region::id — see VpcPeeringConnection's class Javadoc.+ private final StorageBackend<String, VpcPeeringConnection> vpcPeeringConnections;// resourceId → List<Tag>private final StorageBackend<String, List<Tag>> tags;private final Set<String> seededRegions = ConcurrentHashMap.newKeySet();// subnetId → counter for IP assignment (runtime-only, not persisted)private final Map<String, AtomicInteger> subnetIpCounters = new ConcurrentHashMap<>();- @Inject+ // Public, no request context — for callers (and tests) that construct this service directly+ // without CDI. Caller-identity resolution falls back to the configured default account.public Ec2Service(EmulatorConfig config, Ec2ContainerManager containerManager,Ec2PortForwardManager portForwardManager,AmiImageResolver amiImageResolver, Ec2ImageCatalog imageCatalog,Ec2InstanceTypeCatalog instanceTypeCatalog, StorageFactory storageFactory) {+ this(config, containerManager, portForwardManager, amiImageResolver, imageCatalog,+ instanceTypeCatalog, storageFactory, null);+ }++ @Inject+ public Ec2Service(EmulatorConfig config, Ec2ContainerManager containerManager,+ Ec2PortForwardManager portForwardManager,+ AmiImageResolver amiImageResolver, Ec2ImageCatalog imageCatalog,+ Ec2InstanceTypeCatalog instanceTypeCatalog, StorageFactory storageFactory,+ jakarta.enterprise.inject.Instance<RequestContext> requestContextInstance) {this(config, containerManager, portForwardManager, amiImageResolver, imageCatalog, instanceTypeCatalog,storageFactory.create("ec2", "ec2-vpcs.json", new TypeReference<Map<String, Vpc>>() {}),storageFactory.create("ec2", "ec2-subnets.json", new TypeReference<Map<String, Subnet>>() {}),@@ -195,7 +215,10 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {storageFactory.create("ec2", "ec2-transit-gateway-propagations.json",new TypeReference<Map<String, TransitGatewayRouteTablePropagation>>() {}),storageFactory.create("ec2", "ec2-transit-gateway-routes.json",- new TypeReference<Map<String, TransitGatewayRoute>>() {}));+ new TypeReference<Map<String, TransitGatewayRoute>>() {}),+ storageFactory.create("ec2", "ec2-vpc-peering-connections.json",+ new TypeReference<Map<String, VpcPeeringConnection>>() {}),+ requestContextInstance);}// Package-private for hermetic tests (pass in-memory or temp-dir-backed StorageBackends directly).@@ -227,7 +250,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {addresses, instances, volumes, registeredImages, snapshots, launchTemplates, vpcEndpoints,natGateways, spotInstanceRequests, networkAcls, managedPrefixLists, tags,new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),- new InMemoryStorage<>(), new InMemoryStorage<>());+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(), null);}// Package-private for hermetic tests, transit-gateway-aware. The shorter overload above keeps its@@ -259,8 +282,50 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {StorageBackend<String, TransitGatewayRouteTable> transitGatewayRouteTables,StorageBackend<String, TransitGatewayVpcAttachment> transitGatewayVpcAttachments,StorageBackend<String, TransitGatewayRouteTablePropagation> transitGatewayPropagations,- StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes) {+ StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes,+ StorageBackend<String, VpcPeeringConnection> vpcPeeringConnections) {+ this(config, containerManager, portForwardManager, amiImageResolver, imageCatalog, instanceTypeCatalog,+ vpcs, subnets, securityGroups, securityGroupRules, internetGateways, routeTables, keyPairs,+ addresses, instances, volumes, registeredImages, snapshots, launchTemplates, vpcEndpoints,+ natGateways, spotInstanceRequests, networkAcls, managedPrefixLists, tags,+ transitGateways, transitGatewayRouteTables, transitGatewayVpcAttachments,+ transitGatewayPropagations, transitGatewayRoutes, vpcPeeringConnections, null);+ }++ // Package-private for hermetic tests that also need to control which account a caller resolves+ // to (e.g. cross-account VPC peering scenarios), without touching every other test fixture's arity.+ Ec2Service(EmulatorConfig config, Ec2ContainerManager containerManager,+ Ec2PortForwardManager portForwardManager,+ AmiImageResolver amiImageResolver, Ec2ImageCatalog imageCatalog,+ Ec2InstanceTypeCatalog instanceTypeCatalog,+ StorageBackend<String, Vpc> vpcs,+ StorageBackend<String, Subnet> subnets,+ StorageBackend<String, SecurityGroup> securityGroups,+ StorageBackend<String, SecurityGroupRule> securityGroupRules,+ StorageBackend<String, InternetGateway> internetGateways,+ StorageBackend<String, RouteTable> routeTables,+ StorageBackend<String, KeyPair> keyPairs,+ StorageBackend<String, Address> addresses,+ StorageBackend<String, Instance> instances,+ StorageBackend<String, Volume> volumes,+ StorageBackend<String, Image> registeredImages,+ StorageBackend<String, Snapshot> snapshots,+ StorageBackend<String, LaunchTemplate> launchTemplates,+ StorageBackend<String, VpcEndpoint> vpcEndpoints,+ StorageBackend<String, NatGateway> natGateways,+ StorageBackend<String, SpotInstanceRequest> spotInstanceRequests,+ StorageBackend<String, NetworkAcl> networkAcls,+ StorageBackend<String, ManagedPrefixList> managedPrefixLists,+ StorageBackend<String, List<Tag>> tags,+ StorageBackend<String, TransitGateway> transitGateways,+ StorageBackend<String, TransitGatewayRouteTable> transitGatewayRouteTables,+ StorageBackend<String, TransitGatewayVpcAttachment> transitGatewayVpcAttachments,+ StorageBackend<String, TransitGatewayRouteTablePropagation> transitGatewayPropagations,+ StorageBackend<String, TransitGatewayRoute> transitGatewayRoutes,+ StorageBackend<String, VpcPeeringConnection> vpcPeeringConnections,+ jakarta.enterprise.inject.Instance<RequestContext> requestContextInstance) {this.accountId = config.defaultAccountId();+ this.requestContextInstance = requestContextInstance;this.config = config;this.containerManager = containerManager;this.portForwardManager = portForwardManager;@@ -291,6 +356,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {this.transitGatewayVpcAttachments = transitGatewayVpcAttachments;this.transitGatewayPropagations = transitGatewayPropagations;this.transitGatewayRoutes = transitGatewayRoutes;+ this.vpcPeeringConnections = vpcPeeringConnections;}@PostConstruct@@ -4704,13 +4770,34 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {}}+ /**+ * A peering connection is a target in its own right, same as an egress-only gateway. Without+ * this check CreateRoute would silently accept both a gateway/NAT-gateway target and a+ * VpcPeeringConnectionId on the same route, storing an AWS-invalid multi-target route that+ * DescribeRouteTables would then echo back and ReplaceRoute could never reconcile.+ */+ private static void requireVpcPeeringConnectionIsTheOnlyTarget(String gatewayId, String natGatewayId,+ String egressOnlyInternetGatewayId,+ String vpcPeeringConnectionId) {+ if (!isSet(vpcPeeringConnectionId)) {+ return;+ }+ if (isSet(gatewayId) || isSet(natGatewayId) || isSet(egressOnlyInternetGatewayId)) {+ throw new AwsException("InvalidParameterCombination",+ "VpcPeeringConnectionId cannot be combined with GatewayId, NatGatewayId or "+ + "EgressOnlyInternetGatewayId; a route takes one target.", 400);+ }+ }+public void createRoute(String region, String routeTableId, String destinationCidrBlock,String destinationIpv6CidrBlock, String destinationPrefixListId,String gatewayId, String natGatewayId,- String egressOnlyInternetGatewayId) {+ String egressOnlyInternetGatewayId, String vpcPeeringConnectionId) {requireExactlyOneDestination("CreateRoute", destinationCidrBlock, destinationIpv6CidrBlock,destinationPrefixListId);requireEgressOnlyGatewayIsTheOnlyTarget(gatewayId, natGatewayId, egressOnlyInternetGatewayId);+ requireVpcPeeringConnectionIsTheOnlyTarget(gatewayId, natGatewayId, egressOnlyInternetGatewayId,+ vpcPeeringConnectionId);final String canonicalDestinationCidrBlock = canonicalizeIpv4Cidr(destinationCidrBlock);ensureDefaultResources(region);synchronized (lockFor(key(region, routeTableId))) {@@ -4733,6 +4820,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {route.setDestinationPrefixListId(destinationPrefixListId);route.setNatGatewayId(natGatewayId);route.setEgressOnlyInternetGatewayId(egressOnlyInternetGatewayId);+ route.setVpcPeeringConnectionId(vpcPeeringConnectionId);next.add(route);current.setRoutes(next);routeTables.put(key(region, routeTableId), current);@@ -4741,17 +4829,19 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {public void replaceRoute(String region, String routeTableId, String destinationCidrBlock,String destinationIpv6CidrBlock, String destinationPrefixListId,- String gatewayId, String natGatewayId) {+ String gatewayId, String natGatewayId, String vpcPeeringConnectionId) {requireExactlyOneDestination("ReplaceRoute", destinationCidrBlock, destinationIpv6CidrBlock,destinationPrefixListId);// AWS takes exactly one target. Rejecting both-or-neither also keeps the targets this- // emulator cannot model (transit gateway, network interface, peering connection, ...) from- // silently clearing the route and reporting success.+ // emulator cannot model (transit gateway, network interface, ...) from silently clearing+ // the route and reporting success.boolean hasGateway = isSet(gatewayId);boolean hasNatGateway = isSet(natGatewayId);- if (hasGateway == hasNatGateway) {+ boolean hasPeeringConnection = isSet(vpcPeeringConnectionId);+ if ((hasGateway ? 1 : 0) + (hasNatGateway ? 1 : 0) + (hasPeeringConnection ? 1 : 0) != 1) {throw new AwsException("InvalidParameterCombination",- "ReplaceRoute takes exactly one target, and only GatewayId or NatGatewayId is supported.", 400);+ "ReplaceRoute takes exactly one target, and only GatewayId, NatGatewayId or "+ + "VpcPeeringConnectionId is supported.", 400);}final String canonicalDestinationCidrBlock = canonicalizeIpv4Cidr(destinationCidrBlock);@@ -4775,6 +4865,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {replacement.setDestinationIpv6CidrBlock(destinationIpv6CidrBlock);replacement.setDestinationPrefixListId(destinationPrefixListId);replacement.setNatGatewayId(hasNatGateway ? natGatewayId : null);+ replacement.setVpcPeeringConnectionId(hasPeeringConnection ? vpcPeeringConnectionId : null);next.set(next.indexOf(existing), replacement);current.setRoutes(next);routeTables.put(key(region, routeTableId), current);@@ -4805,6 +4896,298 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {return rt;}+ // ─── VPC Peering Connections ─────────────────────────────────────────────────+ //+ // Real AWS never auto-accepts a connection, same-account or not (#floci-k41): every+ // CreateVpcPeeringConnection starts "pending-acceptance" and stays there until an explicit+ // AcceptVpcPeeringConnection. Terraform's own `auto_accept` convenience (on+ // aws_vpc_peering_connection and aws_vpc_peering_connection_accepter) is implemented by the+ // *provider*, which simply issues that second call itself — so the emulator does not need to+ // special-case same-account peers to satisfy it.++ public VpcPeeringConnection createVpcPeeringConnection(String region, String vpcId, String peerVpcId,+ String peerOwnerId, String peerRegion,+ List<Tag> peeringTags) {+ ensureDefaultResources(region);+ Vpc vpc = getRequiredVpc(region, vpcId);++ String pcxId = "pcx-" + randomHex(17);+ VpcPeeringConnection pcx = new VpcPeeringConnection();+ pcx.setVpcPeeringConnectionId(pcxId);+ pcx.setRegion(region);++ String callerAccountId = callerAccountId();+ VpcPeeringConnectionVpcInfo requester = new VpcPeeringConnectionVpcInfo();+ requester.setVpcId(vpcId);+ requester.setOwnerId(callerAccountId);+ requester.setRegion(region);+ requester.setCidrBlock(vpc.getCidrBlock());+ pcx.setRequesterVpcInfo(requester);++ String accepterRegion = isSet(peerRegion) ? peerRegion : region;+ // The accepter VPC may be a cross-account or "external" peer that this store never seeded+ // (vpc-peering-cross-accounts, vpc-peering-external), in which case there is nothing to+ // validate PeerOwnerId against and the caller's claim is trusted. But when the peer VPC+ // *is* known locally, its storage partition — not the requester-supplied PeerOwnerId — is+ // authoritative: otherwise a requester could name another account's VPC and claim itself+ // as that account, which AcceptVpcPeeringConnection would then let it self-authorize.+ Optional<AccountAwareStorageBackend.OwnedEntry<Vpc>> accepterVpcEntry =+ findAnyVpcEntry(accepterRegion, peerVpcId);+ if (accepterVpcEntry.isEmpty() && vpcKnownInSomeOtherRegion(peerVpcId)) {+ // The peer VPC is real, but it does not live in the region the requester named. Trusting+ // PeerOwnerId here would reopen the forgery the block above closes: a requester could+ // name another account's VPC, point PeerRegion at a region that VPC is absent from, and+ // have its own claimed ownership recorded unchallenged. Real AWS resolves the peer VPC+ // globally and rejects the mismatch outright, so do the same.+ throw new AwsException("InvalidVpcID.NotFound",+ "The vpc ID '" + peerVpcId + "' does not exist in region " + accepterRegion, 400);+ }+ String accepterOwnerId = accepterVpcEntry.map(AccountAwareStorageBackend.OwnedEntry::account)+ .orElseGet(() -> isSet(peerOwnerId) ? peerOwnerId : callerAccountId);+ Vpc accepterVpc = accepterVpcEntry.map(AccountAwareStorageBackend.OwnedEntry::value).orElse(null);+ VpcPeeringConnectionVpcInfo accepter = new VpcPeeringConnectionVpcInfo();+ accepter.setVpcId(peerVpcId);+ accepter.setOwnerId(accepterOwnerId);+ accepter.setRegion(accepterRegion);+ accepter.setCidrBlock(accepterVpc != null ? accepterVpc.getCidrBlock() : null);+ pcx.setAccepterVpcInfo(accepter);++ pcx.setStatus(new VpcPeeringConnectionStateReason("pending-acceptance",+ "Pending Acceptance by " + accepterOwnerId));+ if (peeringTags != null) {+ pcx.setTags(new ArrayList<>(peeringTags));+ }++ vpcPeeringConnections.put(pcxId, pcx);+ return pcx;+ }++ /**+ * A peering connection is visible from a region only if that region is the requester's or the+ * accepter's — same as real AWS, where a cross-region connection shows up in exactly the two+ * endpoints that are actually party to it. An unfiltered Describe against every other region+ * must not leak it.+ */+ private static boolean visibleFromRegion(VpcPeeringConnection pcx, String region) {+ String requesterRegion = pcx.getRequesterVpcInfo() != null ? pcx.getRequesterVpcInfo().getRegion() : null;+ String accepterRegion = pcx.getAccepterVpcInfo() != null ? pcx.getAccepterVpcInfo().getRegion() : null;+ return region.equals(requesterRegion) || region.equals(accepterRegion);+ }++ /**+ * A peering connection is visible to an account only if that account is the requester or the+ * accepter — same as real AWS, where a connection never shows up in a describe issued by an+ * unrelated third account.+ */+ private static boolean visibleToAccount(VpcPeeringConnection pcx, String callerAccountId) {+ return callerAccountId.equals(ownerId(pcx.getRequesterVpcInfo()))+ || callerAccountId.equals(ownerId(pcx.getAccepterVpcInfo()));+ }++ private static String ownerId(VpcPeeringConnectionVpcInfo side) {+ return side != null ? side.getOwnerId() : null;+ }++ /**+ * Resolves a VPC across every account's partition, the same pattern used to resolve a+ * peering connection by id — {@code vpcs} is otherwise scoped to the caller's own account,+ * so a plain {@code get} could never find a peer VPC that belongs to a different account.+ */+ /**+ * Reports whether a VPC id is stored under <em>any</em> region, in any account's partition.+ * Only used to tell "this peer VPC is external and was never seeded here" — where trusting the+ * requester's PeerOwnerId is the modelled behaviour — apart from "this peer VPC exists, but not+ * in the region you named", which must not be trusted.+ */+ private boolean vpcKnownInSomeOtherRegion(String vpcId) {+ String suffix = "::" + vpcId;+ if (vpcs instanceof AccountAwareStorageBackend<?> rawAccountAware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<Vpc> accountAware = (AccountAwareStorageBackend<Vpc>) rawAccountAware;+ return !accountAware.scanAllAccountEntries(k -> k.endsWith(suffix)).isEmpty();+ }+ return vpcs.keys().stream().anyMatch(k -> k.endsWith(suffix));+ }++ private Optional<AccountAwareStorageBackend.OwnedEntry<Vpc>> findAnyVpcEntry(String region, String vpcId) {+ if (vpcs instanceof AccountAwareStorageBackend<?> rawAccountAware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<Vpc> accountAware = (AccountAwareStorageBackend<Vpc>) rawAccountAware;+ return accountAware.findAnyAccountEntry(key(region, vpcId));+ }+ return vpcs.get(key(region, vpcId)).map(v -> new AccountAwareStorageBackend.OwnedEntry<>(null, v));+ }++ public List<VpcPeeringConnection> describeVpcPeeringConnections(String region, List<String> ids,+ Map<String, List<String>> filters) {+ ensureDefaultResources(region);+ String caller = callerAccountId();+ return allVpcPeeringConnections().stream()+ .filter(pcx -> visibleToAccount(pcx, caller))+ .filter(pcx -> visibleFromRegion(pcx, region))+ .filter(pcx -> ids.isEmpty() || ids.contains(pcx.getVpcPeeringConnectionId()))+ .filter(pcx -> matchesFilters(pcx, filters, region))+ .collect(Collectors.toList());+ }++ public VpcPeeringConnection acceptVpcPeeringConnection(String region, String vpcPeeringConnectionId) {+ synchronized (lockFor(vpcPeeringConnectionId)) {+ OwnedVpcPeeringConnection owned = getRequiredOwnedVpcPeeringConnection(vpcPeeringConnectionId);+ VpcPeeringConnection current = owned.pcx();+ String accepterOwnerId = current.getAccepterVpcInfo() != null+ ? current.getAccepterVpcInfo().getOwnerId() : null;+ // Reported as absent, not as a permission error: AWS does not confirm the existence+ // of a connection the caller cannot see, whether that's because it belongs to another+ // account or because this endpoint's region isn't party to it (same invariant Describe+ // enforces).+ if (!callerAccountId().equals(accepterOwnerId) || !visibleFromRegion(current, region)) {+ throw vpcPeeringConnectionNotFound(vpcPeeringConnectionId);+ }+ String code = current.getStatus() != null ? current.getStatus().getCode() : null;+ if (!"pending-acceptance".equals(code)) {+ throw new AwsException("InvalidStateTransition",+ "VPC Peering Connection " + vpcPeeringConnectionId+ + " is not eligible for acceptance (state: " + code + ")", 400);+ }+ current.setStatus(new VpcPeeringConnectionStateReason("active", "Active"));+ saveVpcPeeringConnection(owned);+ return current;+ }+ }++ public VpcPeeringConnection modifyVpcPeeringConnectionOptions(String region, String vpcPeeringConnectionId,+ Boolean accepterAllowRemoteVpcDnsResolution,+ Boolean requesterAllowRemoteVpcDnsResolution) {+ synchronized (lockFor(vpcPeeringConnectionId)) {+ OwnedVpcPeeringConnection owned = getRequiredOwnedVpcPeeringConnection(vpcPeeringConnectionId);+ VpcPeeringConnection current = owned.pcx();+ if (!visibleToAccount(current, callerAccountId()) || !visibleFromRegion(current, region)) {+ throw vpcPeeringConnectionNotFound(vpcPeeringConnectionId);+ }+ String caller = callerAccountId();+ // Each side's options block is that side's own VPC setting: only its owner may change+ // it. A participant setting only its own side (the normal case) never trips this; it+ // rejects the cross-account case where one side reaches into the other's block.+ if (accepterAllowRemoteVpcDnsResolution != null+ && !caller.equals(ownerId(current.getAccepterVpcInfo()))) {+ throw new AwsException("OperationNotPermitted",+ "You do not have permission to modify accepterPeeringConnectionOptions on "+ + vpcPeeringConnectionId + "; only the accepter VPC's owner may.", 400);+ }+ if (requesterAllowRemoteVpcDnsResolution != null+ && !caller.equals(ownerId(current.getRequesterVpcInfo()))) {+ throw new AwsException("OperationNotPermitted",+ "You do not have permission to modify requesterPeeringConnectionOptions on "+ + vpcPeeringConnectionId + "; only the requester VPC's owner may.", 400);+ }+ if (accepterAllowRemoteVpcDnsResolution != null) {+ current.setAccepterAllowRemoteVpcDnsResolution(accepterAllowRemoteVpcDnsResolution);+ }+ if (requesterAllowRemoteVpcDnsResolution != null) {+ current.setRequesterAllowRemoteVpcDnsResolution(requesterAllowRemoteVpcDnsResolution);+ }+ saveVpcPeeringConnection(owned);+ return current;+ }+ }++ public void deleteVpcPeeringConnection(String region, String vpcPeeringConnectionId) {+ // Same lock accept/modify take: without it, delete can run between one of those loading+ // the connection and saving it back, and that unconditional save resurrects the row this+ // call just removed.+ synchronized (lockFor(vpcPeeringConnectionId)) {+ OwnedVpcPeeringConnection owned = getRequiredOwnedVpcPeeringConnection(vpcPeeringConnectionId);+ if (!visibleToAccount(owned.pcx(), callerAccountId()) || !visibleFromRegion(owned.pcx(), region)) {+ throw vpcPeeringConnectionNotFound(vpcPeeringConnectionId);+ }+ deleteVpcPeeringConnection(owned);+ }+ }++ /** A peering connection together with the account partition its storage entry lives under. */+ private record OwnedVpcPeeringConnection(String storageAccountId, VpcPeeringConnection pcx) {}++ /**+ * A peering connection is a globally-addressable id, like an S3 bucket name, but is stored+ * under whichever account created it (see the class Javadoc on {@link #vpcPeeringConnections}).+ * The accepter — and, cross-region, either side — can be a different account than the one that+ * created it, so lookups by id must search every account's partition rather than only the+ * caller's own, the same pattern {@code Ec2IpamService} uses for RAM-shared IPAM resources.+ */+ private List<VpcPeeringConnection> allVpcPeeringConnections() {+ if (vpcPeeringConnections instanceof AccountAwareStorageBackend<?> rawAccountAware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<VpcPeeringConnection> accountAware =+ (AccountAwareStorageBackend<VpcPeeringConnection>) rawAccountAware;+ return accountAware.scanAllAccounts();+ }+ return vpcPeeringConnections.scan(k -> true);+ }++ private OwnedVpcPeeringConnection getRequiredOwnedVpcPeeringConnection(String vpcPeeringConnectionId) {+ if (vpcPeeringConnections instanceof AccountAwareStorageBackend<?> rawAccountAware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<VpcPeeringConnection> accountAware =+ (AccountAwareStorageBackend<VpcPeeringConnection>) rawAccountAware;+ var entry = accountAware.findAnyAccountEntry(vpcPeeringConnectionId)+ .orElseThrow(() -> vpcPeeringConnectionNotFound(vpcPeeringConnectionId));+ return new OwnedVpcPeeringConnection(entry.account(), entry.value());+ }+ VpcPeeringConnection pcx = vpcPeeringConnections.get(vpcPeeringConnectionId)+ .orElseThrow(() -> vpcPeeringConnectionNotFound(vpcPeeringConnectionId));+ return new OwnedVpcPeeringConnection(null, pcx);+ }++ private void saveVpcPeeringConnection(OwnedVpcPeeringConnection owned) {+ if (owned.storageAccountId() != null+ && vpcPeeringConnections instanceof AccountAwareStorageBackend<?> rawAccountAware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<VpcPeeringConnection> accountAware =+ (AccountAwareStorageBackend<VpcPeeringConnection>) rawAccountAware;+ accountAware.putForAccount(owned.storageAccountId(), owned.pcx().getVpcPeeringConnectionId(), owned.pcx());+ return;+ }+ vpcPeeringConnections.put(owned.pcx().getVpcPeeringConnectionId(), owned.pcx());+ }++ private void deleteVpcPeeringConnection(OwnedVpcPeeringConnection owned) {+ if (owned.storageAccountId() != null+ && vpcPeeringConnections instanceof AccountAwareStorageBackend<?> rawAccountAware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<VpcPeeringConnection> accountAware =+ (AccountAwareStorageBackend<VpcPeeringConnection>) rawAccountAware;+ accountAware.deleteForAccount(owned.storageAccountId(), owned.pcx().getVpcPeeringConnectionId());+ return;+ }+ vpcPeeringConnections.delete(owned.pcx().getVpcPeeringConnectionId());+ }++ private static AwsException vpcPeeringConnectionNotFound(String vpcPeeringConnectionId) {+ return new AwsException("InvalidVpcPeeringConnectionID.NotFound",+ "The VPC peering connection ID '" + vpcPeeringConnectionId + "' does not exist", 400);+ }++ /**+ * The account making the current request, resolved the same way {@code AccountAwareStorageBackend}+ * derives its key prefix, so an identity comparison against a resolved peering connection's+ * requester/accepter owner id is meaningful both in and out of a request scope.+ */+ private String callerAccountId() {+ if (requestContextInstance != null) {+ try {+ String caller = requestContextInstance.get().getAccountId();+ if (caller != null) {+ return caller;+ }+ } catch (ContextNotActiveException e) {+ // Tolerated: callers outside a request scope (startup, internal provisioning)+ // legitimately fall through to the default account.+ LOG.debugv("No active request context — resolving caller as default account {0}", accountId);+ }+ }+ return accountId;+ }+// ─── NAT Gateways ─────────────────────────────────────────────────────────public NatGateway createNatGateway(String region, String subnetId, String allocationId,@@ -5230,6 +5613,25 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {default -> true;};}+ if (resource instanceof VpcPeeringConnection pcx) {+ return switch (filterName) {+ case "vpc-peering-connection-id" -> matchesValue(values, pcx.getVpcPeeringConnectionId());+ case "status-code" -> pcx.getStatus() != null && matchesValue(values, pcx.getStatus().getCode());+ case "requester-vpc-info.vpc-id" -> pcx.getRequesterVpcInfo() != null+ && matchesValue(values, pcx.getRequesterVpcInfo().getVpcId());+ case "requester-vpc-info.owner-id" -> pcx.getRequesterVpcInfo() != null+ && matchesValue(values, pcx.getRequesterVpcInfo().getOwnerId());+ case "requester-vpc-info.region" -> pcx.getRequesterVpcInfo() != null+ && matchesValue(values, pcx.getRequesterVpcInfo().getRegion());+ case "accepter-vpc-info.vpc-id" -> pcx.getAccepterVpcInfo() != null+ && matchesValue(values, pcx.getAccepterVpcInfo().getVpcId());+ case "accepter-vpc-info.owner-id" -> pcx.getAccepterVpcInfo() != null+ && matchesValue(values, pcx.getAccepterVpcInfo().getOwnerId());+ case "accepter-vpc-info.region" -> pcx.getAccepterVpcInfo() != null+ && matchesValue(values, pcx.getAccepterVpcInfo().getRegion());+ default -> true;+ };+ }if (resource instanceof Instance inst) {return switch (filterName) {case "instance-id" -> matchesValue(values, inst.getInstanceId());@@ -5405,6 +5807,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider {if (resource instanceof TransitGateway gateway) return gateway.getTags();if (resource instanceof TransitGatewayRouteTable routeTable) return routeTable.getTags();if (resource instanceof TransitGatewayVpcAttachment attachment) return attachment.getTags();+ if (resource instanceof VpcPeeringConnection pcx) return pcx.getTags();return Collections.emptyList();}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/Route.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Route.javaindex fd9fbeed5c..c0e8ec416a 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/model/Route.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Route.java@@ -14,6 +14,7 @@ public class Route {private String gatewayId;private String natGatewayId;private String egressOnlyInternetGatewayId;+ private String vpcPeeringConnectionId;private String state = "active";private String origin;@@ -66,6 +67,9 @@ public class Route {public String getEgressOnlyInternetGatewayId() { return egressOnlyInternetGatewayId; }public void setEgressOnlyInternetGatewayId(String egressOnlyInternetGatewayId) { this.egressOnlyInternetGatewayId = egressOnlyInternetGatewayId; }+ public String getVpcPeeringConnectionId() { return vpcPeeringConnectionId; }+ public void setVpcPeeringConnectionId(String vpcPeeringConnectionId) { this.vpcPeeringConnectionId = vpcPeeringConnectionId; }+public String getState() { return state; }public void setState(String state) { this.state = state; }diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnection.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnection.javanew file mode 100644index 0000000000..9399fddd5a--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnection.java@@ -0,0 +1,65 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.List;++/**+ * Stored keyed by id alone rather than {@code region::id} like every other EC2 resource here+ * (see Ec2Service#createVpcPeeringConnection) — a deliberate simplification. A peering connection+ * is meaningfully addressable from both the requester's and the accepter's side, which can be a+ * different region (the {@code vpc-peering-cross-accounts} example sets {@code accepter_region}+ * independently of the requester region). Region-scoped storage would make the accepter's+ * {@code AcceptVpcPeeringConnection}/{@code DescribeVpcPeeringConnections} calls unable to find a+ * connection created under the requester's region key.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class VpcPeeringConnection {++ private String vpcPeeringConnectionId;+ // The region the connection was created in (the requester's region). Informational only —+ // lookups are by id, not region::id; see the class Javadoc.+ private String region;+ private VpcPeeringConnectionVpcInfo requesterVpcInfo;+ private VpcPeeringConnectionVpcInfo accepterVpcInfo;+ private VpcPeeringConnectionStateReason status;+ // aws_vpc_peering_connection_options models one boolean per side here (allow_remote_vpc_dns_resolution),+ // the only PeeringConnectionOptions field the vpc-peering / vpc-peering-cross-accounts examples set.+ // The ClassicLink-era options (long deprecated) are not modelled.+ private boolean accepterAllowRemoteVpcDnsResolution;+ private boolean requesterAllowRemoteVpcDnsResolution;+ private List<Tag> tags = new ArrayList<>();++ public VpcPeeringConnection() {}++ public String getVpcPeeringConnectionId() { return vpcPeeringConnectionId; }+ public void setVpcPeeringConnectionId(String vpcPeeringConnectionId) { this.vpcPeeringConnectionId = vpcPeeringConnectionId; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public VpcPeeringConnectionVpcInfo getRequesterVpcInfo() { return requesterVpcInfo; }+ public void setRequesterVpcInfo(VpcPeeringConnectionVpcInfo requesterVpcInfo) { this.requesterVpcInfo = requesterVpcInfo; }++ public VpcPeeringConnectionVpcInfo getAccepterVpcInfo() { return accepterVpcInfo; }+ public void setAccepterVpcInfo(VpcPeeringConnectionVpcInfo accepterVpcInfo) { this.accepterVpcInfo = accepterVpcInfo; }++ public VpcPeeringConnectionStateReason getStatus() { return status; }+ public void setStatus(VpcPeeringConnectionStateReason status) { this.status = status; }++ public boolean isAccepterAllowRemoteVpcDnsResolution() { return accepterAllowRemoteVpcDnsResolution; }+ public void setAccepterAllowRemoteVpcDnsResolution(boolean accepterAllowRemoteVpcDnsResolution) {+ this.accepterAllowRemoteVpcDnsResolution = accepterAllowRemoteVpcDnsResolution;+ }++ public boolean isRequesterAllowRemoteVpcDnsResolution() { return requesterAllowRemoteVpcDnsResolution; }+ public void setRequesterAllowRemoteVpcDnsResolution(boolean requesterAllowRemoteVpcDnsResolution) {+ this.requesterAllowRemoteVpcDnsResolution = requesterAllowRemoteVpcDnsResolution;+ }++ public List<Tag> getTags() { return tags; }+ public void setTags(List<Tag> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnectionStateReason.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnectionStateReason.javanew file mode 100644index 0000000000..20abe5f098--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnectionStateReason.java@@ -0,0 +1,25 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class VpcPeeringConnectionStateReason {++ private String code;+ private String message;++ public VpcPeeringConnectionStateReason() {}++ public VpcPeeringConnectionStateReason(String code, String message) {+ this.code = code;+ this.message = message;+ }++ public String getCode() { return code; }+ public void setCode(String code) { this.code = code; }++ public String getMessage() { return message; }+ public void setMessage(String message) { this.message = message; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnectionVpcInfo.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnectionVpcInfo.javanew file mode 100644index 0000000000..a4532d7279--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcPeeringConnectionVpcInfo.java@@ -0,0 +1,34 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * One side (requester or accepter) of a {@link VpcPeeringConnection}. The accepter side may name a+ * VPC that does not exist in this store at all — a cross-account or "external" peer, per the+ * {@code vpc-peering-cross-accounts} and {@code vpc-peering-external} examples — so {@code cidrBlock}+ * is best-effort and can be {@code null}.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class VpcPeeringConnectionVpcInfo {++ private String vpcId;+ private String ownerId;+ private String region;+ private String cidrBlock;++ public VpcPeeringConnectionVpcInfo() {}++ public String getVpcId() { return vpcId; }+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }++ public String getOwnerId() { return ownerId; }+ public void setOwnerId(String ownerId) { this.ownerId = ownerId; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public String getCidrBlock() { return cidrBlock; }+ public void setCidrBlock(String cidrBlock) { this.cidrBlock = cidrBlock; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.javaindex 9b8967093a..8d5360d278 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ServicePersistenceTest.java@@ -225,12 +225,12 @@ class Ec2ServicePersistenceTest {// (b) CreateRoute with an equivalent-but-differently-spelled destination is a duplicate,// not a new route, of the legacy one.AwsException duplicate = assertThrows(AwsException.class, () -> restarted.createRoute(- REGION, routeTableId, "100.68.63.255/18", null, null, "igw-other00000000000", null, null));+ REGION, routeTableId, "100.68.63.255/18", null, null, "igw-other00000000000", null, null, null));assertEquals("RouteAlreadyExists", duplicate.getErrorCode());// (c) ReplaceRoute against the legacy route's original, non-canonical spelling finds the// same route rather than throwing InvalidRoute.NotFound.- restarted.replaceRoute(REGION, routeTableId, "100.68.0.18/18", null, null, "igw-replaced0000000", null);+ restarted.replaceRoute(REGION, routeTableId, "100.68.0.18/18", null, null, "igw-replaced0000000", null, null);RouteTable afterReplace =restarted.describeRouteTables(REGION, List.of(routeTableId), Map.of()).getFirst();assertEquals(1, afterReplace.getRoutes().size(), "replace must update the existing route in place");diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VpcPeeringConnectionCrossAccountIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VpcPeeringConnectionCrossAccountIntegrationTest.javanew file mode 100644index 0000000000..30ac7a58b5--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VpcPeeringConnectionCrossAccountIntegrationTest.java@@ -0,0 +1,533 @@+package io.github.hectorvent.floci.services.ec2;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.emptyOrNullString;+import static org.hamcrest.Matchers.equalTo;++import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import io.quarkus.test.junit.QuarkusTest;++/**+ * Covers the cross-account and multi-target scenarios the same-account lifecycle test+ * (Ec2VpcPeeringConnectionIntegrationTest) cannot exercise on its own: only the actual accepter+ * account may accept a connection, a describe issued from an unrelated region must not see it,+ * ReplaceRoute must accept a peering connection as a target, and CreateRoute must reject a+ * peering connection combined with another target.+ *+ * <p>Uses 12-digit numeric access key IDs so they resolve directly to distinct account IDs+ * (see AccountIsolationIntegrationTest for the same pattern).+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class Ec2VpcPeeringConnectionCrossAccountIntegrationTest {++ // 000000000000 is the emulator's configured default account — distinct from every account+ // below, so it stands in for "an unrelated account that happens to be the default".+ private static final String DEFAULT_ACCOUNT = "000000000000";+ private static final String REQUESTER_ACCOUNT = "000000000101";+ private static final String ACCEPTER_ACCOUNT = "000000000102";+ private static final String OTHER_ACCOUNT = "000000000103";++ private static final String DEFAULT_ACCOUNT_AUTH =+ "AWS4-HMAC-SHA256 Credential=" + DEFAULT_ACCOUNT + "/20260215/us-east-1/ec2/aws4_request";+ private static final String REQUESTER_AUTH =+ "AWS4-HMAC-SHA256 Credential=" + REQUESTER_ACCOUNT + "/20260215/us-east-1/ec2/aws4_request";+ private static final String ACCEPTER_AUTH =+ "AWS4-HMAC-SHA256 Credential=" + ACCEPTER_ACCOUNT + "/20260215/us-east-1/ec2/aws4_request";+ private static final String OTHER_ACCOUNT_AUTH =+ "AWS4-HMAC-SHA256 Credential=" + OTHER_ACCOUNT + "/20260215/us-east-1/ec2/aws4_request";+ // Same requester account, different region — used to prove a describe (and, below, a+ // mutation) issued from a region unrelated to either side of the connection does not see it.+ private static final String REQUESTER_AUTH_OTHER_REGION =+ "AWS4-HMAC-SHA256 Credential=" + REQUESTER_ACCOUNT + "/20260215/us-west-2/ec2/aws4_request";++ private static String requesterVpcId;+ private static String pcxId;++ @Test+ @Order(1)+ void requesterCreatesAConnectionAddressedToTheAccepterAccount() {+ requesterVpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.40.0.0/16")+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ pcxId = given()+ .formParam("Action", "CreateVpcPeeringConnection")+ .formParam("VpcId", requesterVpcId)+ .formParam("PeerVpcId", "vpc-accepter00000000")+ .formParam("PeerOwnerId", ACCEPTER_ACCOUNT)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.ownerId",+ equalTo(ACCEPTER_ACCOUNT))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.status.code",+ equalTo("pending-acceptance"))+ .extract().path("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.vpcPeeringConnectionId");+ }++ /** The requester created the connection but is not the accepter and cannot activate it. */+ @Test+ @Order(2)+ void requesterCannotAcceptItsOwnConnection() {+ given()+ .formParam("Action", "AcceptVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcPeeringConnectionID.NotFound"));+ }++ /** An unrelated third account cannot see or accept the connection either. */+ @Test+ @Order(3)+ void anUnrelatedAccountCannotSeeOrAcceptTheConnection() {+ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet", emptyOrNullString());++ given()+ .formParam("Action", "AcceptVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcPeeringConnectionID.NotFound"));+ }++ /** A describe issued from a region that is neither side of the connection must not see it. */+ @Test+ @Order(4)+ void describeFromAnUnrelatedRegionDoesNotSeeTheConnection() {+ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", REQUESTER_AUTH_OTHER_REGION)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet", emptyOrNullString());+ }++ /** The actual accepter account can see and accept it. */+ @Test+ @Order(5)+ void theAccepterAccountCanAcceptTheConnection() {+ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", ACCEPTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet.item.vpcPeeringConnectionId",+ equalTo(pcxId));++ given()+ .formParam("Action", "AcceptVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", ACCEPTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("AcceptVpcPeeringConnectionResponse.vpcPeeringConnection.status.code", equalTo("active"));+ }++ /**+ * CreateRoute must reject a route that names both a peering connection and another target+ * (here: GatewayId) — AWS accepts exactly one target per route.+ */+ @Test+ @Order(6)+ void createRouteRejectsAPeeringConnectionCombinedWithAnotherTarget() {+ String routeTableId = given()+ .formParam("Action", "CreateRouteTable")+ .formParam("VpcId", requesterVpcId)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateRouteTableResponse.routeTable.routeTableId");++ given()+ .formParam("Action", "CreateRoute")+ .formParam("RouteTableId", routeTableId)+ .formParam("DestinationCidrBlock", "10.50.0.0/16")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("GatewayId", "igw-conflicting00000")+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterCombination"));+ }++ /**+ * ReplaceRoute must accept a peering connection as the replacement target — the peering+ * examples repoint a route at the connection after it goes active, same as CreateRoute.+ */+ @Test+ @Order(7)+ void replaceRouteAcceptsThePeeringConnectionAsTheTarget() {+ String routeTableId = given()+ .formParam("Action", "CreateRouteTable")+ .formParam("VpcId", requesterVpcId)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateRouteTableResponse.routeTable.routeTableId");++ given()+ .formParam("Action", "CreateRoute")+ .formParam("RouteTableId", routeTableId)+ .formParam("DestinationCidrBlock", "10.60.0.0/16")+ .formParam("GatewayId", "igw-replaceable00000")+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .formParam("Action", "ReplaceRoute")+ .formParam("RouteTableId", routeTableId)+ .formParam("DestinationCidrBlock", "10.60.0.0/16")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ReplaceRouteResponse.return", equalTo("true"));++ given()+ .formParam("Action", "DescribeRouteTables")+ .formParam("RouteTableId.1", routeTableId)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeRouteTablesResponse.routeTableSet.item.routeSet.item"+ + ".find { it.destinationCidrBlock == '10.60.0.0/16' }.vpcPeeringConnectionId",+ equalTo(pcxId));+ }++ /**+ * The requester account (not the emulator's configured default account) must be able to+ * describe and modify the connection it created. Recording requesterVpcInfo.ownerId as the+ * fixed default account, rather than the account that actually made the request, would deny+ * the real requester while handing an unrelated account participant-level access.+ */+ @Test+ @Order(8)+ void theRequesterAccountCanManageItsOwnConnectionButTheDefaultAccountCannot() {+ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet.item.vpcPeeringConnectionId",+ equalTo(pcxId));++ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", DEFAULT_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet", emptyOrNullString());++ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "true")+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyVpcPeeringConnectionOptionsResponse.requesterPeeringConnectionOptions"+ + ".allowDnsResolutionFromRemoteVpc", equalTo("true"));++ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "false")+ .header("Authorization", DEFAULT_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcPeeringConnectionID.NotFound"));+ }++ /**+ * Each side's DNS-resolution option is that side's own setting: being a legitimate+ * participant in the connection is not enough to change the *other* side's option, only+ * your own — same as AWS, where accepterPeeringConnectionOptions is the accepter VPC+ * owner's setting and requesterPeeringConnectionOptions is the requester VPC owner's.+ */+ @Test+ @Order(9)+ void aParticipantCannotModifyTheOppositeEndpointsOptions() {+ // The requester may set its own side...+ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "true")+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ // ...but not the accepter's side, even though it is a legitimate participant.+ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("AccepterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "true")+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("OperationNotPermitted"));++ // Symmetrically, the accepter may set its own side but not the requester's.+ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("AccepterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "true")+ .header("Authorization", ACCEPTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "false")+ .header("Authorization", ACCEPTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("OperationNotPermitted"));+ }++ /**+ * Accept, modify and delete must enforce the same regional-visibility invariant Describe+ * does: an endpoint in a region belonging to neither side must not be able to act on the+ * connection, even when the caller's account is a legitimate participant.+ */+ @Test+ @Order(10)+ void mutationsFromAnUnrelatedRegionAreRejected() {+ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "true")+ .header("Authorization", REQUESTER_AUTH_OTHER_REGION)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcPeeringConnectionID.NotFound"));++ given()+ .formParam("Action", "DeleteVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", REQUESTER_AUTH_OTHER_REGION)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcPeeringConnectionID.NotFound"));++ // Still there, and still manageable from the correct region.+ given()+ .formParam("Action", "DeleteVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", REQUESTER_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DeleteVpcPeeringConnectionResponse.return", equalTo("true"));+ }++ /**+ * A requester cannot forge accepter ownership by naming another account's real VPC while+ * claiming a different PeerOwnerId (e.g. its own account) — the peer VPC's actual storage+ * partition must win, or the requester could self-authorize AcceptVpcPeeringConnection for a+ * connection it does not actually control.+ */+ @Test+ @Order(11)+ void creationCannotForgeAccepterOwnershipForALocallyKnownPeerVpc() {+ String victimAccount = "000000000199";+ String victimAuth =+ "AWS4-HMAC-SHA256 Credential=" + victimAccount + "/20260215/us-east-1/ec2/aws4_request";++ String victimVpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.70.0.0/16")+ .header("Authorization", victimAuth)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ String forgingVpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.71.0.0/16")+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ // OTHER_ACCOUNT names the victim's real VPC but falsely claims itself as PeerOwnerId.+ String forgedPcxId = given()+ .formParam("Action", "CreateVpcPeeringConnection")+ .formParam("VpcId", forgingVpcId)+ .formParam("PeerVpcId", victimVpcId)+ .formParam("PeerOwnerId", OTHER_ACCOUNT)+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ // The recorded accepter owner is the VPC's real account, not the claimed one.+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.ownerId",+ equalTo(victimAccount))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.cidrBlock",+ equalTo("10.70.0.0/16"))+ .extract().path("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.vpcPeeringConnectionId");++ // The requester cannot self-authorize acceptance despite its false claim.+ given()+ .formParam("Action", "AcceptVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", forgedPcxId)+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcPeeringConnectionID.NotFound"));++ // The real owner of the peer VPC can accept it.+ given()+ .formParam("Action", "AcceptVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", forgedPcxId)+ .header("Authorization", victimAuth)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("AcceptVpcPeeringConnectionResponse.vpcPeeringConnection.status.code", equalTo("active"));+ }++ /**+ * The same forgery, hidden behind a mismatched PeerRegion: naming another account's real VPC+ * but pointing PeerRegion at a region that VPC is absent from must not degrade into trusting+ * the requester-supplied PeerOwnerId. Real AWS resolves the peer VPC globally and answers+ * InvalidVpcID.NotFound, so nothing is created for the requester to then self-accept.+ */+ @Test+ @Order(12)+ void creationCannotForgeAccepterOwnershipByNamingTheWrongPeerRegion() {+ String victimAccount = "000000000198";+ String victimAuth =+ "AWS4-HMAC-SHA256 Credential=" + victimAccount + "/20260215/us-east-1/ec2/aws4_request";++ String victimVpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.72.0.0/16")+ .header("Authorization", victimAuth)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ String forgingVpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.73.0.0/16")+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ // The victim's VPC is in us-east-1; PeerRegion names eu-west-1, where it does not exist.+ given()+ .formParam("Action", "CreateVpcPeeringConnection")+ .formParam("VpcId", forgingVpcId)+ .formParam("PeerVpcId", victimVpcId)+ .formParam("PeerRegion", "eu-west-1")+ .formParam("PeerOwnerId", OTHER_ACCOUNT)+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcID.NotFound"));++ // A genuinely external peer VPC — one this emulator has never seen in any region — is+ // still accepted on the requester's word, as before.+ given()+ .formParam("Action", "CreateVpcPeeringConnection")+ .formParam("VpcId", forgingVpcId)+ .formParam("PeerVpcId", "vpc-0f00d0f00d0f00d00")+ .formParam("PeerRegion", "eu-west-1")+ .formParam("PeerOwnerId", "000000000197")+ .header("Authorization", OTHER_ACCOUNT_AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.ownerId",+ equalTo("000000000197"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VpcPeeringConnectionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VpcPeeringConnectionIntegrationTest.javanew file mode 100644index 0000000000..a338103b2a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VpcPeeringConnectionIntegrationTest.java@@ -0,0 +1,325 @@+package io.github.hectorvent.floci.services.ec2;++import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.emptyOrNullString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;++import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import io.quarkus.test.junit.QuarkusTest;+import static io.restassured.RestAssured.given;++/**+ * CreateVpcPeeringConnection was entirely unimplemented (floci-k41), blocking all three VPC-peering+ * examples in terraform-aws-vpc (vpc-peering, vpc-peering-cross-accounts, vpc-peering-external).+ * These tests walk the lifecycle those examples actually exercise: create -> accept -> describe ->+ * route via the peering connection -> options -> delete.+ *+ * <p>Real AWS never auto-accepts a connection (same-account or not); every connection starts+ * "pending-acceptance" until an explicit AcceptVpcPeeringConnection. Terraform's own `auto_accept`+ * convenience is implemented by the *provider* re-issuing that call, not by the API — so that is+ * what these tests pin at the API layer.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class Ec2VpcPeeringConnectionIntegrationTest {++ private static final String AUTH_HEADER =+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/ec2/aws4_request";++ private static String requesterVpcId;+ private static String accepterVpcId;+ private static String pcxId;+ private static String routeTableId;++ @Test+ @Order(1)+ void createVpcPeeringConnectionStartsPendingAcceptance() {+ requesterVpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.20.0.0/16")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ accepterVpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.30.0.0/16")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ pcxId = given()+ .formParam("Action", "CreateVpcPeeringConnection")+ .formParam("VpcId", requesterVpcId)+ .formParam("PeerVpcId", accepterVpcId)+ .formParam("TagSpecification.1.ResourceType", "vpc-peering-connection")+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", "pcx-example")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.requesterVpcInfo.vpcId",+ equalTo(requesterVpcId))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.requesterVpcInfo.cidrBlock",+ equalTo("10.20.0.0/16"))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.vpcId",+ equalTo(accepterVpcId))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.cidrBlock",+ equalTo("10.30.0.0/16"))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.status.code",+ equalTo("pending-acceptance"))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.tagSet.item.value",+ equalTo("pcx-example"))+ .extract().path("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.vpcPeeringConnectionId");+ }++ @Test+ @Order(2)+ void describeReflectsThePendingConnection() {+ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet.item.vpcPeeringConnectionId",+ equalTo(pcxId))+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet.item.status.code",+ equalTo("pending-acceptance"));+ }++ @Test+ @Order(3)+ void acceptTransitionsTheConnectionToActive() {+ given()+ .formParam("Action", "AcceptVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("AcceptVpcPeeringConnectionResponse.vpcPeeringConnection.status.code", equalTo("active"));++ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet.item.status.code",+ equalTo("active"));+ }++ /** Accepting an already-active connection is not a valid state transition. */+ @Test+ @Order(4)+ void acceptingAnAlreadyActiveConnectionIsRejected() {+ given()+ .formParam("Action", "AcceptVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidStateTransition"));+ }++ /**+ * aws_vpc_peering_connection_options: both modules/vpc-peering and+ * modules/vpc-peering-cross-accounts-accepter set allow_remote_vpc_dns_resolution on one or+ * both sides.+ */+ @Test+ @Order(5)+ void modifyPeeringConnectionOptionsSetsDnsResolutionPerSide() {+ given()+ .formParam("Action", "ModifyVpcPeeringConnectionOptions")+ .formParam("VpcPeeringConnectionId", pcxId)+ .formParam("AccepterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "true")+ .formParam("RequesterPeeringConnectionOptions.AllowDnsResolutionFromRemoteVpc", "true")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyVpcPeeringConnectionOptionsResponse.accepterPeeringConnectionOptions"+ + ".allowDnsResolutionFromRemoteVpc", equalTo("true"))+ .body("ModifyVpcPeeringConnectionOptionsResponse.requesterPeeringConnectionOptions"+ + ".allowDnsResolutionFromRemoteVpc", equalTo("true"));++ // Terraform's aws_vpc_peering_connection_options resource reads this back via Describe on+ // every plan, not by re-issuing Modify — it must round-trip here or the provider sees+ // permanent drift on a value it just set.+ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet.item"+ + ".accepterVpcInfo.peeringOptions.allowDnsResolutionFromRemoteVpc", equalTo("true"))+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet.item"+ + ".requesterVpcInfo.peeringOptions.allowDnsResolutionFromRemoteVpc", equalTo("true"));+ }++ /**+ * modules/vpc-peering routes traffic to the peer over the connection via aws_route with+ * vpc_peering_connection_id as the target — this must round-trip on DescribeRouteTables or the+ * provider sees permanent drift on the route resource it just created.+ */+ @Test+ @Order(6)+ void createRouteWithThePeeringConnectionAsTargetRoundTrips() {+ routeTableId = given()+ .formParam("Action", "CreateRouteTable")+ .formParam("VpcId", requesterVpcId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateRouteTableResponse.routeTable.routeTableId");++ given()+ .formParam("Action", "CreateRoute")+ .formParam("RouteTableId", routeTableId)+ .formParam("DestinationCidrBlock", "10.30.0.0/16")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateRouteResponse.return", equalTo("true"));++ given()+ .formParam("Action", "DescribeRouteTables")+ .formParam("RouteTableId.1", routeTableId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeRouteTablesResponse.routeTableSet.item.routeSet.item"+ + ".find { it.destinationCidrBlock == '10.30.0.0/16' }.vpcPeeringConnectionId",+ equalTo(pcxId));+ }++ @Test+ @Order(7)+ void deleteRemovesTheConnection() {+ given()+ .formParam("Action", "DeleteVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DeleteVpcPeeringConnectionResponse.return", equalTo("true"));++ given()+ .formParam("Action", "DescribeVpcPeeringConnections")+ .formParam("VpcPeeringConnectionId.1", pcxId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcPeeringConnectionsResponse.vpcPeeringConnectionSet", emptyOrNullString());+ }++ @Test+ @Order(8)+ void deletingAnUnknownConnectionIsRejected() {+ given()+ .formParam("Action", "DeleteVpcPeeringConnection")+ .formParam("VpcPeeringConnectionId", "pcx-0000000000000dead")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcPeeringConnectionID.NotFound"));+ }++ /**+ * vpc-peering-cross-accounts and vpc-peering-external both peer against a VPC id this account+ * never seeded (a different account/region's VPC). The accepter side must still be reported —+ * without a fabricated CIDR — rather than the request failing outright.+ */+ @Test+ @Order(9)+ void peeringToAnUnknownAccepterVpcSucceedsWithNoAccepterCidr() {+ String vpcId = given()+ .formParam("Action", "CreateVpc")+ .formParam("CidrBlock", "10.2.0.0/16")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateVpcResponse.vpc.vpcId");++ String response = given()+ .formParam("Action", "CreateVpcPeeringConnection")+ .formParam("VpcId", vpcId)+ .formParam("PeerVpcId", "vpc-external0000000")+ .formParam("PeerOwnerId", "999999999999")+ .formParam("PeerRegion", "us-west-2")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.vpcId",+ equalTo("vpc-external0000000"))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.ownerId",+ equalTo("999999999999"))+ .body("CreateVpcPeeringConnectionResponse.vpcPeeringConnection.accepterVpcInfo.region",+ equalTo("us-west-2"))+ .extract().asString();++ // The requester side (a VPC this account did seed) does carry a cidrBlock; only the+ // accepter side — a VPC never seeded here — must not have one fabricated.+ String accepterInfo = response.substring(response.indexOf("<accepterVpcInfo>"));+ assertThat(accepterInfo, not(containsString("<cidrBlock>")));+ }++ @Test+ @Order(10)+ void createOnAnUnknownVpcIsRejected() {+ given()+ .formParam("Action", "CreateVpcPeeringConnection")+ .formParam("VpcId", "vpc-0000000000000dead")+ .formParam("PeerVpcId", "vpc-0000000000000beef")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidVpcID.NotFound"));+ }+}