Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
index 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.md
index 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.md
index 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.java
index 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.java
new file mode 100644
index 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.java
index 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, because
diff --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.java
new file mode 100644
index 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.java
index 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 + "\"}"));
+ }
+
@Test
void 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.java
index 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.java
index 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));
+ }
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/redshiftserverless/RedshiftServerlessServiceTest.java
index 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());
}
}