Light, fluffy, and always free - The AWS Local Emulator alternative
feat(redshift-serverless): add resource policy actions for snapshots (#5730)
Vũ Thế Huya68e6bc76800
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.javaindex 65d6103bb0..fd86a639fc 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RedshiftServerlessTest.java@@ -288,6 +288,32 @@ class RedshiftServerlessTest {}}+ @Test+ void resourcePolicyUsesAwsSdk() {+ assumeFalse(TestFixtures.isRealAws(), "Creates resources and asserts emulator-local behavior");++ try (RedshiftServerlessClient client = TestFixtures.redshiftServerlessClient()) {+ String namespaceName = "floci-compat-policy-ns";+ String snapshotName = "floci-compat-policy-snap";+ try {+ client.createNamespace(request -> request.namespaceName(namespaceName).adminUsername("admin")+ .adminUserPassword("Secret123!"));+ String snapshotArn = client.createSnapshot(request -> request+ .snapshotName(snapshotName).namespaceName(namespaceName)).snapshot().snapshotArn();++ client.putResourcePolicy(request -> request.resourceArn(snapshotArn).policy("{\"Version\":\"2012-10-17\"}"));+ assertThat(client.getResourcePolicy(request -> request.resourceArn(snapshotArn))+ .resourcePolicy().policy()).contains("2012-10-17");+ client.deleteResourcePolicy(request -> request.resourceArn(snapshotArn));+ assertThatThrownBy(() -> client.getResourcePolicy(request -> request.resourceArn(snapshotArn)))+ .isInstanceOf(ResourceNotFoundException.class);+ } finally {+ deleteSnapshotBestEffort(client, snapshotName);+ deleteBestEffort(client, namespaceName);+ }+ }+ }+private static void deleteSnapshotBestEffort(RedshiftServerlessClient client, String snapshotName) {try {client.deleteSnapshot(request -> request.snapshotName(snapshotName));diff --git a/docs/services/index.md b/docs/services/index.mdindex e4da0bcb7c..ae7e0918ae 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -77,7 +77,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [DMS](dms.md) | `POST /` + `X-Amz-Target: AmazonDMSv20160101.*` | JSON 1.1 | 20 || [Redshift](redshift.md) | `POST /` with `Action=` param + PostgreSQL container | Query + PostgreSQL wire (+ CFN) | 43 || [Redshift Data API](redshift-data.md) | `POST /` + `X-Amz-Target: RedshiftData.*` | JSON 1.1 | 11 |-| [Redshift Serverless](redshift-serverless.md) | `POST /` + `X-Amz-Target: RedshiftServerless.*` | JSON 1.1 | 33 |+| [Redshift Serverless](redshift-serverless.md) | `POST /` + `X-Amz-Target: RedshiftServerless.*` | JSON 1.1 | 36 || [EMR](emr.md) | `POST /` + `X-Amz-Target: ElasticMapReduce.*` | JSON 1.1 | 37 || [EMR Serverless](emr-serverless.md) | `/applications/*`, `/tags/*` | REST JSON | 10 || [Data Firehose](firehose.md) | `POST /` + `X-Amz-Target: Firehose_20150804.*` | JSON 1.1 | 12 |diff --git a/docs/services/redshift-serverless.md b/docs/services/redshift-serverless.mdindex d9a759a7eb..087f0642d6 100644--- a/docs/services/redshift-serverless.md+++ b/docs/services/redshift-serverless.md@@ -37,6 +37,9 @@ For the upstream API shape, see the [Amazon Redshift Serverless API Reference](h| `ListTagsForResource` | Return the tags on the namespace or workgroup named by `resourceArn` || `TagResource` | Merge tags into the namespace or workgroup named by `resourceArn` || `UntagResource` | Remove tags by key from the namespace or workgroup named by `resourceArn` |+| `PutResourcePolicy` | Replace the resource policy of a snapshot; the policy must be a JSON object and is stored, not evaluated |+| `GetResourcePolicy` | Return the resource policy of a snapshot |+| `DeleteResourcePolicy` | Remove the resource policy of a snapshot || `GetTrack` | Return one of the release tracks `current` and `trailing`; a track carries no `workgroupVersion` || `ListTracks` | Page through the two release tracks || `ListManagedWorkgroups` | Always an empty list: Floci models no Glue zero-ETL managed workgroups |@@ -119,3 +122,4 @@ aws redshift-serverless delete-namespace --namespace-name analytics```- **Snapshots dump the database.** While the namespace's workgroup is running, `CreateSnapshot` runs `pg_dump` on its container and stores the dump under `<persistent-path>/redshift-serverless-dumps/<account>/<region>/`. `RestoreFromSnapshot` drops every user schema (the catalog bootstrap schema excepted) and replays the dump with `psql`, stopping at the first failing statement, so rows written after the snapshot are gone. The current contents are dumped first and put back if the replay fails, and a restore whose recorded dump file has gone missing fails instead of reporting success. A snapshot taken with no running workgroup is metadata only, and restoring it leaves the database untouched. `DeleteSnapshot` removes the dump. Snapshot ARNs use the snapshot name as their id, snapshot names are 3-255 lowercase letters, digits and hyphens, and `retentionPeriod` is `-1` (indefinite, the default) or 1 to 3653 days. Snapshots are taggable by ARN. `snapshotName` and `snapshotArn` cannot be sent together. Floci's own `floci_internal` bootstrap schema, which feeds the `svv_external_*` views from the Glue catalog, is left out of both the dump and the reset, matching AWS where the Glue catalog is outside a namespace snapshot, so a client schema with that exact name is not captured. A real snapshot expires after its retention period; Floci reports `snapshotRemainingDays` but does not expire snapshots.- **`UpdateSnapshot` changes only `retentionPeriod`.** It is validated like `CreateSnapshot` (`-1` or 1 to 3653 days), `-1` makes the snapshot indefinite, and an omitted period leaves the snapshot unchanged. `snapshotRemainingDays` keeps counting from the creation time, because Floci stores no separate retention start.+- **Resource policies are recorded, not acted on.** A policy is stored per account and Region, echoed in the shape of the API model, and dropped on read once the snapshot it belongs to is gone. A snapshot recreated under the same name is a different snapshot: the record keeps the snapshot's creation time, so the policy is not inherited. `PutResourcePolicy` accepts a JSON object for a snapshot ARN of this account and Region; no principal in it gains access. A foreign or non-snapshot ARN is a `ValidationException`.diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.javaindex af13f19ddd..dd8acc2f79 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdminJsonHandler.java@@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.core.common.PaginatedResult;import io.github.hectorvent.floci.core.common.Pagination;+import io.github.hectorvent.floci.services.redshiftserverless.model.ResourcePolicy;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import jakarta.ws.rs.core.Response;@@ -25,14 +26,26 @@ public class RedshiftServerlessAdminJsonHandler {private static final List<String> TRACK_NAMES = RedshiftServerlessService.TRACK_NAMES;private final ObjectMapper objectMapper;+ private final RedshiftServerlessResourcePolicyService resourcePolicies;@Inject- public RedshiftServerlessAdminJsonHandler(ObjectMapper objectMapper) {+ public RedshiftServerlessAdminJsonHandler(ObjectMapper objectMapper,+ RedshiftServerlessResourcePolicyService resourcePolicies) {this.objectMapper = objectMapper;+ this.resourcePolicies = resourcePolicies;}Supplier<Response> operation(String action, JsonNode request, String region) {return switch (action) {+ case "PutResourcePolicy" -> () -> resourcePolicyResponse(resourcePolicies.putResourcePolicy(+ ServerlessSupport.text(request, "resourceArn"), ServerlessSupport.text(request, "policy"),+ region));+ case "GetResourcePolicy" -> () -> resourcePolicyResponse(resourcePolicies.getResourcePolicy(+ ServerlessSupport.text(request, "resourceArn"), region));+ case "DeleteResourcePolicy" -> () -> {+ resourcePolicies.deleteResourcePolicy(ServerlessSupport.text(request, "resourceArn"), region);+ return Response.ok(objectMapper.createObjectNode()).build();+ };case "GetTrack" -> () -> getTrack(ServerlessSupport.text(request, "trackName"));case "ListTracks" -> () -> listTracks(request);case "ListManagedWorkgroups" -> () -> listWithoutItems(request, "managedWorkgroups");@@ -62,6 +75,17 @@ public class RedshiftServerlessAdminJsonHandler {+ ServerlessSupport.text(request, "offeringId") + " was not found.");}+ // ── Resource policy ────────────────────────────────────────────────────++ private Response resourcePolicyResponse(ResourcePolicy policy) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("policy", policy.getPolicy());+ node.put("resourceArn", policy.getResourceArn());+ ObjectNode response = objectMapper.createObjectNode();+ response.set("resourcePolicy", node);+ return Response.ok(response).build();+ }+// ── Tracks, managed workgroups and reservations ────────────────────────/**diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessResourcePolicyService.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessResourcePolicyService.javanew file mode 100644index 0000000000..e96a3ef416--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessResourcePolicyService.java@@ -0,0 +1,112 @@+package io.github.hectorvent.floci.services.redshiftserverless;++import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.DeserializationFeature;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.ObjectReader;+import io.github.hectorvent.floci.core.common.Resettable;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.redshiftserverless.model.RedshiftServerlessSnapshot;+import io.github.hectorvent.floci.services.redshiftserverless.model.ResourcePolicy;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.io.IOException;+import java.util.Map;+import java.util.Objects;+import java.util.Optional;++/**+ * Resource policies for Redshift Serverless snapshots. A policy is stored and echoed, not+ * evaluated: no principal named in it gains access.+ *+ * <p>A policy belongs to a snapshot but lives in its own store, so deleting the snapshot needs no+ * hook here. Each read checks that the snapshot is still there and drops the policy otherwise.+ */+@ApplicationScoped+public class RedshiftServerlessResourcePolicyService implements Resettable {++ private final AccountAwareStorageBackend<ResourcePolicy> policies;+ private final RedshiftServerlessService serverless;+ private final ObjectReader strictPolicyReader;++ @Inject+ public RedshiftServerlessResourcePolicyService(StorageFactory storageFactory,+ RedshiftServerlessService serverless,+ ObjectMapper objectMapper) {+ this.policies = storageFactory.create("redshiftserverless", "redshiftserverless-resourcepolicies.json",+ new TypeReference<Map<String, ResourcePolicy>>() {});+ this.serverless = serverless;+ this.strictPolicyReader = objectMapper.reader().with(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);+ }++ /** Replaces the policy on the snapshot {@code resourceArn} names. */+ public synchronized ResourcePolicy putResourcePolicy(String resourceArn, String policy, String region) {+ requireJsonObject(policy);+ RedshiftServerlessSnapshot snapshot = findSnapshot(resourceArn, region)+ .orElseThrow(() -> ServerlessSupport.notFound("The resource " + resourceArn + " was not found."));+ ResourcePolicy stored = new ResourcePolicy(resourceArn, policy);+ stored.setSnapshotCreateTime(snapshot.getSnapshotCreateTime());+ policies.put(storageKey(region, resourceArn), stored);+ return new ResourcePolicy(resourceArn, policy);+ }++ public synchronized ResourcePolicy getResourcePolicy(String resourceArn, String region) {+ ResourcePolicy stored = require(resourceArn, region);+ return new ResourcePolicy(stored.getResourceArn(), stored.getPolicy());+ }++ public synchronized void deleteResourcePolicy(String resourceArn, String region) {+ require(resourceArn, region);+ policies.delete(storageKey(region, resourceArn));+ }++ @Override+ public void clear() {+ policies.clear();+ }++ private ResourcePolicy require(String resourceArn, String region) {+ serverless.snapshotNameFromArn(resourceArn, region, "resourceArn");+ ResourcePolicy stored = policies.get(storageKey(region, resourceArn)).orElse(null);+ if (stored != null && !isOnSameSnapshot(stored, region)) {+ policies.delete(storageKey(region, resourceArn));+ stored = null;+ }+ if (stored == null) {+ throw ServerlessSupport.notFound("The resource " + resourceArn + " has no resource policy.");+ }+ return stored;+ }++ /**+ * A snapshot ARN carries only the snapshot's name, so a snapshot recreated under the same name+ * is told apart by its creation time: a policy left by its predecessor is not this snapshot's.+ */+ private boolean isOnSameSnapshot(ResourcePolicy stored, String region) {+ return findSnapshot(stored.getResourceArn(), region)+ .map(snapshot -> Objects.equals(snapshot.getSnapshotCreateTime(), stored.getSnapshotCreateTime()))+ .orElse(false);+ }++ private Optional<RedshiftServerlessSnapshot> findSnapshot(String resourceArn, String region) {+ return serverless.findSnapshot(serverless.snapshotNameFromArn(resourceArn, region, "resourceArn"), region);+ }++ private void requireJsonObject(String policy) {+ try {+ JsonNode parsed = strictPolicyReader.readTree(policy);+ if (parsed == null || !parsed.isObject()) {+ throw ServerlessSupport.validation("policy must be a JSON policy document.");+ }+ } catch (IOException e) {+ throw ServerlessSupport.validation("policy must be a JSON policy document.");+ }+ }++ private static String storageKey(String region, String resourceArn) {+ return region + "::" + resourceArn;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.javaindex 20e748dc66..10d43cfdf8 100644--- a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessService.java@@ -464,13 +464,22 @@ public class RedshiftServerlessService implements Resettable {* Region or resource type rather than resolving it to a local snapshot of the same name.*/public String snapshotNameFromArn(String snapshotArn, String region) {+ return snapshotNameFromArn(snapshotArn, region, "snapshotArn");+ }++ public String snapshotNameFromArn(String snapshotArn, String region, String memberName) {String prefix = regionResolver.buildArn("redshift-serverless", region, "snapshot/");if (snapshotArn == null || !snapshotArn.startsWith(prefix) || snapshotArn.length() == prefix.length()) {- throw ServerlessSupport.validation("snapshotArn does not identify a snapshot in this account and Region.");+ throw ServerlessSupport.validation(memberName + " does not identify a snapshot in this account and Region.");}return snapshotArn.substring(prefix.length());}+ /** The snapshot called {@code snapshotName} in {@code region}, empty when there is none. */+ public Optional<RedshiftServerlessSnapshot> findSnapshot(String snapshotName, String region) {+ return snapshotName == null ? Optional.empty() : snapshots.get(storageKey(region, snapshotName));+ }+/*** Changes a snapshot's retention. An omitted period leaves the snapshot as it is, and -1 makes* it indefinite. {@code snapshotRemainingDays} keeps counting from the creation time, becausediff --git a/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/ResourcePolicy.java b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/ResourcePolicy.javanew file mode 100644index 0000000000..52dbf5434e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/redshiftserverless/model/ResourcePolicy.java@@ -0,0 +1,49 @@+package io.github.hectorvent.floci.services.redshiftserverless.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++/** The resource policy attached to a Redshift Serverless snapshot. Floci stores it but does not evaluate it. */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class ResourcePolicy {++ private String resourceArn;+ private String policy;+ private Instant snapshotCreateTime;++ public ResourcePolicy() {+ }++ public ResourcePolicy(String resourceArn, String policy) {+ this.resourceArn = resourceArn;+ this.policy = policy;+ }++ /** The creation time of the snapshot the policy was put on, which tells a recreated snapshot apart. */+ public Instant getSnapshotCreateTime() {+ return snapshotCreateTime;+ }++ public void setSnapshotCreateTime(Instant snapshotCreateTime) {+ this.snapshotCreateTime = snapshotCreateTime;+ }++ public String getResourceArn() {+ return resourceArn;+ }++ public void setResourceArn(String resourceArn) {+ this.resourceArn = resourceArn;+ }++ public String getPolicy() {+ return policy;+ }++ public void setPolicy(String policy) {+ this.policy = policy;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdministrationHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdministrationHandlerTest.javaindex 2e8cfb22ab..cdda887e54 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdministrationHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessAdministrationHandlerTest.java@@ -1,17 +1,31 @@package io.github.hectorvent.floci.services.redshiftserverless;+import com.fasterxml.jackson.core.type.TypeReference;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.redshift.RedshiftIamDbUserResolver;+import io.github.hectorvent.floci.services.redshift.model.Endpoint;import jakarta.ws.rs.core.Response;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import java.io.IOException;+import java.time.Instant;+import java.util.List;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyBoolean;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;/*** Covers the metadata-only Redshift Serverless actions through the handler, so both the stored@@ -19,15 +33,111 @@ import static org.mockito.Mockito.mock;*/class RedshiftServerlessAdministrationHandlerTest {private static final String REGION = "us-east-1";+ private static final String ACCOUNT_ID = "123456789012";+ private static final String CERTIFICATE_ARN =+ "arn:aws:acm:us-east-1:123456789012:certificate/11111111-2222-3333-4444-555555555555";private final ObjectMapper mapper = new ObjectMapper();private RedshiftServerlessJsonHandler handler;+ private RedshiftServerlessService serverlessService;@BeforeEach+ @SuppressWarnings({"unchecked", "rawtypes"})void setUp() {- handler = new RedshiftServerlessJsonHandler(mock(RedshiftServerlessService.class), mapper,- mock(RedshiftIamDbUserResolver.class), mock(RedshiftServerlessUsageLimitService.class),- new RedshiftServerlessAdminJsonHandler(mapper));+ StorageFactory storageFactory = mock(StorageFactory.class);+ for (String file : List.of("namespaces", "workgroups", "snapshots", "usagelimits", "resourcepolicies",+ "endpointaccess", "snapshotcopyconfigurations", "scheduledactions", "customdomains")) {+ when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-" + file + ".json"),+ any(TypeReference.class))).thenReturn((AccountAwareStorageBackend)+ AccountAwareStorageBackend.inMemory(ACCOUNT_ID));+ }+ RegionResolver regionResolver = mock(RegionResolver.class);+ when(regionResolver.getAccountId()).thenReturn(ACCOUNT_ID);+ when(regionResolver.buildArn(eq("redshift-serverless"), any(String.class), any(String.class)))+ .thenAnswer(invocation -> "arn:aws:redshift-serverless:"+ + invocation.getArgument(1, String.class) + ":" + ACCOUNT_ID + ":"+ + invocation.getArgument(2, String.class));+ RedshiftServerlessEndpoints endpoints = mock(RedshiftServerlessEndpoints.class);+ when(endpoints.allocate()).thenReturn(new Endpoint("localhost", 7100));+ RedshiftServerlessRuntime runtime = mock(RedshiftServerlessRuntime.class);+ when(runtime.generatePassword()).thenReturn("Generated123");+ when(runtime.start(any(String.class), any(String.class), any(String.class), any(String.class),+ any(String.class), any(String.class), any(Endpoint.class), anyBoolean(), any()))+ .thenReturn(new RedshiftServerlessRuntime.Backend("127.0.0.1", 55432));+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.storage().persistentPath()).thenReturn(System.getProperty("java.io.tmpdir"));+ serverlessService =+ new RedshiftServerlessService(storageFactory, regionResolver, endpoints, runtime, config);+ handler = new RedshiftServerlessJsonHandler(serverlessService, mapper, mock(RedshiftIamDbUserResolver.class),+ new RedshiftServerlessUsageLimitService(storageFactory, regionResolver, serverlessService),+ new RedshiftServerlessAdminJsonHandler(mapper,+ new RedshiftServerlessResourcePolicyService(storageFactory, serverlessService, mapper)));+ }++ @Test+ void resourcePolicyIsStoredPerSnapshotAndDroppedWithIt() {+ String snapshotArn = snapshot("policy-ns", "policy-snap");+ String policy = "{\"Version\":\"2012-10-17\",\"Statement\":[]}";++ JsonNode put = ok("PutResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\",\"policy\":"+ + mapper.valueToTree(policy) + "}").get("resourcePolicy");+ assertEquals(snapshotArn, put.get("resourceArn").textValue());+ assertEquals(policy, put.get("policy").textValue());+ assertEquals(policy, ok("GetResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}")+ .get("resourcePolicy").get("policy").textValue());++ assertEquals("ValidationException", errorType("PutResourcePolicy",+ "{\"resourceArn\":\"" + snapshotArn + "\",\"policy\":\"not json\"}"));+ assertEquals("ValidationException", errorType("PutResourcePolicy",+ "{\"resourceArn\":\"" + snapshotArn + "\",\"policy\":\"{}\\ngarbage\"}"));+ assertEquals("ValidationException", errorType("PutResourcePolicy",+ "{\"resourceArn\":\"" + snapshotArn + "\",\"policy\":\"{}{}\"}"));+ assertEquals("ResourceNotFoundException", errorType("PutResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID+ + ":snapshot/missing\",\"policy\":" + mapper.valueToTree(policy) + "}"));+ assertEquals("ValidationException", errorType("PutResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\",\"policy\":"+ + mapper.valueToTree(policy) + "}"));+ assertEquals("resourceArn does not identify a snapshot in this account and Region.",+ errorMessage("PutResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\",\"policy\":"+ + mapper.valueToTree(policy) + "}"));+ assertEquals("ValidationException", errorType("PutResourcePolicy",+ "{\"policy\":" + mapper.valueToTree(policy) + "}"));+ assertEquals("ValidationException", errorType("PutResourcePolicy",+ "{\"resourceArn\":\"" + snapshotArn + "\"}"));+ assertEquals("ValidationException", errorType("GetResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\"}"));+ assertEquals("resourceArn does not identify a snapshot in this account and Region.",+ errorMessage("GetResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\"}"));+ assertEquals("ValidationException", errorType("DeleteResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\"}"));+ assertEquals("resourceArn does not identify a snapshot in this account and Region.",+ errorMessage("DeleteResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\"}"));+ assertEquals("ValidationException", errorType("GetResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/x\"}"));+ assertEquals("resourceArn does not identify a snapshot in this account and Region.",+ errorMessage("GetResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/x\"}"));+ assertEquals("ValidationException", errorType("DeleteResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/x\"}"));+ assertEquals("resourceArn does not identify a snapshot in this account and Region.",+ errorMessage("DeleteResourcePolicy",+ "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:" + ACCOUNT_ID + ":workgroup/x\"}"));+ assertEquals("ValidationException", errorType("GetResourcePolicy", "{}"));+ assertEquals("ValidationException", errorType("DeleteResourcePolicy", "{}"));++ assertEquals(0, ok("DeleteResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}").size());+ assertEquals("ResourceNotFoundException",+ errorType("GetResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}"));++ ok("PutResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\",\"policy\":"+ + mapper.valueToTree(policy) + "}");+ ok("DeleteSnapshot", "{\"snapshotName\":\"policy-snap\"}");+ assertEquals("ResourceNotFoundException",+ errorType("GetResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}"));}@Test@@ -36,10 +146,9 @@ class RedshiftServerlessAdministrationHandlerTest {assertEquals("trailing", track.get("trackName").textValue());assertEquals(0, track.get("updateTargets").size());assertEquals("ResourceNotFoundException", errorType("GetTrack", "{\"trackName\":\"nightly\"}"));- assertEquals("ResourceNotFoundException", errorType("GetTrack", "{\"trackName\":\"preview\"}"));assertEquals("ValidationException", errorType("GetTrack", "{\"trackName\":\"not valid!\"}"));- assertEquals("ValidationException", errorType("GetTrack", "{}"));+ assertEquals("ResourceNotFoundException", errorType("GetTrack", "{\"trackName\":\"preview\"}"));assertEquals(2, ok("ListTracks", "{}").get("tracks").size());JsonNode page = ok("ListTracks", "{\"maxResults\":1}");assertEquals("current", page.get("tracks").get(0).get("trackName").textValue());@@ -93,11 +202,38 @@ class RedshiftServerlessAdministrationHandlerTest {errorType("CreateReservation", "{\"capacity\":128,\"offeringId\":\"o-1\",\"clientToken\":123}"));}+ @Test+ void aSnapshotRecreatedUnderTheSameNameDoesNotInheritItsPolicy() {+ String arn = snapshot("recreate-snap-ns", "recreate-snap");+ ok("PutResourcePolicy", "{\"resourceArn\":\"" + arn + "\",\"policy\":\"{}\"}");++ ok("DeleteSnapshot", "{\"snapshotName\":\"recreate-snap\"}");+ ok("CreateSnapshot", "{\"snapshotName\":\"recreate-snap\",\"namespaceName\":\"recreate-snap-ns\"}");++ assertEquals("ResourceNotFoundException", errorType("GetResourcePolicy", "{\"resourceArn\":\"" + arn + "\"}"));+ }+@Testvoid anUnknownActionIsStillRejected() {assertEquals("UnknownOperationException", errorType("NoSuchOperation", "{}"));}+ private void namespace(String name) {+ ok("CreateNamespace", "{\"namespaceName\":\"" + name + "\",\"adminUsername\":\"admin\"}");+ }++ private void workgroup(String namespaceName, String workgroupName) {+ namespace(namespaceName);+ ok("CreateWorkgroup", "{\"workgroupName\":\"" + workgroupName + "\",\"namespaceName\":\""+ + namespaceName + "\"}");+ }++ private String snapshot(String namespaceName, String snapshotName) {+ namespace(namespaceName);+ return ok("CreateSnapshot", "{\"snapshotName\":\"" + snapshotName + "\",\"namespaceName\":\""+ + namespaceName + "\"}").get("snapshot").get("snapshotArn").textValue();+ }+private JsonNode ok(String action, String json) {Response response = invoke(action, json);assertEquals(200, response.getStatus(), action + " failed: " + response.getEntity());@@ -110,6 +246,12 @@ class RedshiftServerlessAdministrationHandlerTest {return mapper.valueToTree(response.getEntity()).path("__type").asText(null);}+ private String errorMessage(String action, String json) {+ Response response = invoke(action, json);+ assertEquals(400, response.getStatus(), action + " should be rejected: " + response.getEntity());+ return mapper.valueToTree(response.getEntity()).path("message").asText(null);+ }+private Response invoke(String action, String json) {try {return handler.handle(action, mapper.readTree(json), REGION);diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.javaindex 432c73b52f..cdd863bb01 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessIntegrationTest.java@@ -508,6 +508,91 @@ class RedshiftServerlessIntegrationTest {.body("__type", equalTo("ValidationException"));}+ @Test+ void resourcePolicyRoundTripsOverTheWire() {+ call("CreateNamespace", "{\"namespaceName\":\"policy-ns\",\"adminUsername\":\"admin\"}").statusCode(200);+ String snapshotArn = call("CreateSnapshot", "{\"snapshotName\":\"policy-snap\",\"namespaceName\":\"policy-ns\"}")+ .statusCode(200).extract().path("snapshot.snapshotArn");++ call("PutResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\",\"policy\":\"{\\\"Version\\\":\\\"2012-10-17\\\"}\"}")+ .statusCode(200)+ .body("resourcePolicy.resourceArn", equalTo(snapshotArn));+ call("GetResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}")+ .statusCode(200)+ .body("resourcePolicy.policy", equalTo("{\"Version\":\"2012-10-17\"}"));+ call("DeleteResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}").statusCode(200);+ call("GetResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}")+ .statusCode(400)+ .body("__type", equalTo("ResourceNotFoundException"));+ call("PutResourcePolicy", "{\"resourceArn\":\"" + snapshotArn + "\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ call("PutResourcePolicy", "{\"policy\":\"{\\\"Version\\\":\\\"2012-10-17\\\"}\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"));+ call("GetResourcePolicy", "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("resourceArn does not identify a snapshot in this account and Region."));+ call("DeleteResourcePolicy", "{\"resourceArn\":\"arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/x\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("resourceArn does not identify a snapshot in this account and Region."));+ }++ @Test+ void resourcePolicyIsIsolatedPerAccount() {+ String accountA = "111122223333";+ String accountB = "444455556666";+ String policyJson = "{\"Version\":\"2012-10-17\"}";+ String escapedPolicy = "{\\\"Version\\\":\\\"2012-10-17\\\"}";++ callAs(accountA, "CreateNamespace", "{\"namespaceName\":\"acct-ns\",\"adminUsername\":\"admin\"}").statusCode(200);+ String snapArnA = callAs(accountA, "CreateSnapshot", "{\"snapshotName\":\"acct-snap\",\"namespaceName\":\"acct-ns\"}")+ .statusCode(200).extract().path("snapshot.snapshotArn");++ callAs(accountA, "PutResourcePolicy", "{\"resourceArn\":\"" + snapArnA + "\",\"policy\":\"" + escapedPolicy + "\"}")+ .statusCode(200)+ .body("resourcePolicy.resourceArn", equalTo(snapArnA));++ callAs(accountB, "GetResourcePolicy", "{\"resourceArn\":\"" + snapArnA + "\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("resourceArn does not identify a snapshot in this account and Region."));+ callAs(accountB, "DeleteResourcePolicy", "{\"resourceArn\":\"" + snapArnA + "\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("resourceArn does not identify a snapshot in this account and Region."));+ callAs(accountB, "PutResourcePolicy", "{\"resourceArn\":\"" + snapArnA + "\",\"policy\":\"" + escapedPolicy + "\"}")+ .statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("resourceArn does not identify a snapshot in this account and Region."));++ callAs(accountB, "CreateNamespace", "{\"namespaceName\":\"acct-ns\",\"adminUsername\":\"admin\"}").statusCode(200);+ String snapArnB = callAs(accountB, "CreateSnapshot", "{\"snapshotName\":\"acct-snap\",\"namespaceName\":\"acct-ns\"}")+ .statusCode(200).extract().path("snapshot.snapshotArn");++ callAs(accountB, "GetResourcePolicy", "{\"resourceArn\":\"" + snapArnB + "\"}")+ .statusCode(400)+ .body("__type", equalTo("ResourceNotFoundException"));++ callAs(accountA, "GetResourcePolicy", "{\"resourceArn\":\"" + snapArnA + "\"}")+ .statusCode(200)+ .body("resourcePolicy.policy", equalTo(policyJson));+ }++ private static io.restassured.response.ValidatableResponse callAs(String accountId, String action, String body) {+ return given()+ .header("X-Amz-Target", TARGET_PREFIX + action)+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + accountId+ + "/20260904/us-east-1/redshift-serverless/aws4_request")+ .contentType(CONTENT_TYPE)+ .body(body)+ .when()+ .post("/")+ .then();+ }+private static io.restassured.response.ValidatableResponse call(String action, String body) {return given().header("X-Amz-Target", TARGET_PREFIX + action)diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.javaindex 8691a2e509..924cc1a562 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessJsonHandlerTest.java@@ -83,11 +83,22 @@ class RedshiftServerlessJsonHandlerTest {when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-usagelimits.json"),any(TypeReference.class))).thenReturn((AccountAwareStorageBackend)AccountAwareStorageBackend.inMemory(ACCOUNT_ID));+ stubAdministrationStores(storageFactory);RedshiftServerlessService service =new RedshiftServerlessService(storageFactory, regionResolver, endpoints, runtime, config);handler = new RedshiftServerlessJsonHandler(service, mapper, iamDbUserResolver,new RedshiftServerlessUsageLimitService(storageFactory, regionResolver, service),- new RedshiftServerlessAdminJsonHandler(mapper));+ new RedshiftServerlessAdminJsonHandler(mapper,+ new RedshiftServerlessResourcePolicyService(storageFactory, service, mapper)));+ }++ @SuppressWarnings({"unchecked", "rawtypes"})+ private static void stubAdministrationStores(StorageFactory storageFactory) {+ for (String file : List.of("resourcepolicies")) {+ when(storageFactory.create(eq("redshiftserverless"), eq("redshiftserverless-" + file + ".json"),+ any(TypeReference.class))).thenReturn((AccountAwareStorageBackend)+ AccountAwareStorageBackend.inMemory(ACCOUNT_ID));+ }}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.javaindex aef8559a63..5e8816780e 100644--- a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java@@ -870,6 +870,7 @@ class RedshiftServerlessServiceTest {RedshiftServerlessSnapshot snapshot = service.createSnapshot("arn-snap", "arn-ns", null, null, REGION);assertEquals("arn-snap", service.snapshotNameFromArn(snapshot.getSnapshotArn(), REGION));+ assertEquals("arn-snap", service.snapshotNameFromArn(snapshot.getSnapshotArn(), REGION, "resourceArn"));for (String foreign : List.of("arn:aws:redshift-serverless:eu-west-1:" + ACCOUNT_ID + ":snapshot/arn-snap","arn:aws:redshift-serverless:us-east-1:999999999999:snapshot/arn-snap",@@ -877,6 +878,12 @@ class RedshiftServerlessServiceTest {AwsException rejected = assertThrows(AwsException.class,() -> service.snapshotNameFromArn(foreign, REGION));assertEquals("ValidationException", rejected.getErrorCode());+ assertEquals("snapshotArn does not identify a snapshot in this account and Region.", rejected.getMessage());++ AwsException rejectedResource = assertThrows(AwsException.class,+ () -> service.snapshotNameFromArn(foreign, REGION, "resourceArn"));+ assertEquals("ValidationException", rejectedResource.getErrorCode());+ assertEquals("resourceArn does not identify a snapshot in this account and Region.", rejectedResource.getMessage());}}