Light, fluffy, and always free - The AWS Local Emulator alternative
feat(backup): configure a vault with an access policy, notifications and a lock (#4412)
Allen Sanborn6656c8e5dff3
diff --git a/docs/services/backup.md b/docs/services/backup.mdindex 22ae143c99..2ed4df039d 100644--- a/docs/services/backup.md+++ b/docs/services/backup.md@@ -12,9 +12,32 @@|---|---|---|---|| `CreateBackupVault` | `PUT` | `/backup-vaults/{backupVaultName}` | Create a backup vault || `DescribeBackupVault` | `GET` | `/backup-vaults/{backupVaultName}` | Describe a backup vault |-| `DeleteBackupVault` | `DELETE` | `/backup-vaults/{backupVaultName}` | Delete an empty backup vault |+| `DeleteBackupVault` | `DELETE` | `/backup-vaults/{backupVaultName}` | Delete an empty backup vault, locked or not || `ListBackupVaults` | `GET` | `/backup-vaults/` | List all backup vaults |+### Backup Vault Access Policy++| Action | Method | Path | Description |+|---|---|---|---|+| `PutBackupVaultAccessPolicy` | `PUT` | `/backup-vaults/{backupVaultName}/access-policy` | Attach a resource policy to a vault |+| `GetBackupVaultAccessPolicy` | `GET` | `/backup-vaults/{backupVaultName}/access-policy` | Read a vault's resource policy |+| `DeleteBackupVaultAccessPolicy` | `DELETE` | `/backup-vaults/{backupVaultName}/access-policy` | Remove a vault's resource policy |++### Backup Vault Notifications++| Action | Method | Path | Description |+|---|---|---|---|+| `PutBackupVaultNotifications` | `PUT` | `/backup-vaults/{backupVaultName}/notification-configuration` | Send vault events to an SNS topic |+| `GetBackupVaultNotifications` | `GET` | `/backup-vaults/{backupVaultName}/notification-configuration` | Read a vault's notification configuration |+| `DeleteBackupVaultNotifications` | `DELETE` | `/backup-vaults/{backupVaultName}/notification-configuration` | Remove a vault's notification configuration |++### Backup Vault Lock++| Action | Method | Path | Description |+|---|---|---|---|+| `PutBackupVaultLockConfiguration` | `PUT` | `/backup-vaults/{backupVaultName}/vault-lock` | Apply a governance or compliance lock |+| `DeleteBackupVaultLockConfiguration` | `DELETE` | `/backup-vaults/{backupVaultName}/vault-lock` | Remove a lock that is still changeable |+### Backup Plans| Action | Method | Path | Description |@@ -99,6 +122,76 @@ Actual backup is simulated — no data is read from or written to the referenced- **DeleteBackupVault** returns `InvalidRequestException` (400) if the vault contains recovery points.- **DeleteBackupPlan** returns `InvalidRequestException` (400) if the plan has active selections.- **CreateBackupVault** returns `AlreadyExistsException` (400) on duplicate vault names within the same region.+- **Vault Lock has two modes, and `ChangeableForDays` selects them -- in the direction+ that reads backwards.** *Present* means **compliance** mode: `LockDate` is set that many+ days ahead, the lock can still be changed or deleted before it, and on and after it both+ `PutBackupVaultLockConfiguration` and `DeleteBackupVaultLockConfiguration` return+ `InvalidRequestException` (400). *Absent* means **governance** mode: no `LockDate` is+ set and the lock can be changed or removed at any time. `ChangeableForDays` below 3 is+ rejected, matching AWS's 72-hour cooling-off period; retention days below 1 are rejected.+- **A lock does not stop the vault being deleted.** It protects the recovery points, so an+ empty vault can be deleted even under a compliance lock. The non-empty rule above is the+ one that refuses.+- **What the lock actually enforces, in both directions.**+ `DeleteRecoveryPoint` returns `InvalidRequestException` (400) for a recovery point younger+ than `MinRetentionDays` while the vault is locked, and `StartBackupJob` returns+ `InvalidParameterValueException` (400) when the lifecycle's `DeleteAfterDays` falls outside+ `[MinRetentionDays, MaxRetentionDays]`, **including when the lifecycle is omitted and the+ lock sets a maximum** -- retaining indefinitely is the largest retention there is, so it+ exceeds every finite ceiling, and waving it through would leave the ceiling bypassable by+ dropping one member. An absent lifecycle under a minimum-only lock is accepted, because a+ floor is satisfied by indefinite retention. That scoping is Floci's reading rather than a+ quotation: the reference states the rule for a lifecycle outside the window and does not+ spell out the absent case. Both are the documented purpose of the lock: it+ "prevents the deletion of recovery points before their retention periods expire", and+ "backup jobs will fail if the lifecycle policy of the backup plan is outside the vault+ lock's retention period". **Governance mode enforces here exactly as compliance mode+ does.** On real AWS a principal holding `backup:DisableGovernanceRetention` can override a+ governance lock; Floci does not model that permission, so it does not grant the override.+ That is stricter than AWS for that one privileged caller and identical for every other.+- **The Vault Lock day limits are per field, because AWS documents them per field.**+ `ChangeableForDays` must be 3 or greater and at most 36,500. `MaxRetentionDays` is at+ most 36,500. `MinRetentionDays` has a documented minimum of 1 day and **no documented+ maximum**, so Floci applies none: bounding it would risk refusing a value real AWS+ accepts. `MaxRetentionDays` below `MinRetentionDays` is rejected when both are+ supplied.+- **PutBackupVaultNotifications** rejects any `BackupVaultEvents` value outside the+ documented set with `InvalidParameterValueException` (400), rather than storing it. All+ 30 documented values are accepted, including the ones AWS marks deprecated.+- **A missing parameter and an empty one are different errors.**+ `PutBackupVaultNotifications` returns `MissingParameterValueException` (400) when+ `SNSTopicArn` or `BackupVaultEvents` is absent, which is the error AWS lists in that+ operation's Errors section, and `InvalidParameterValueException` (400) when one is+ present but unusable (`"SNSTopicArn": ""`, or `"BackupVaultEvents": []`). An SDK maps+ the two onto different typed exceptions. The reference names the absent case; the+ present-but-unusable one is Floci's reading, not a quotation.+- **`PutBackupVaultAccessPolicy` accepts a request that omits `Policy`.** AWS documents+ `Policy` as `Required: No`, so refusing one would fail a call real AWS accepts. What+ AWS then stores is **not documented, and we have not measured it**; Floci **clears**+ the stored policy, so a subsequent `GetBackupVaultAccessPolicy` returns+ `ResourceNotFoundException` (400). That is a deliberate choice rather than an observed+ AWS behaviour: it leaves the vault carrying exactly the policy the request carried,+ instead of retaining one the caller did not send. A `Policy` that is present but empty+ is a different case and is rejected with `InvalidParameterValueException` (400).+- **`Policy` must be a JSON object.** A document that does not parse, or parses to+ something other than an object, is rejected with `InvalidParameterValueException` (400)+ rather than stored. Syntax only: Floci does not evaluate what the document grants.+- **`SNSTopicArn` must be a JSON string.** A number or boolean is rejected with+ `InvalidParameterValueException` (400) rather than coerced, so a request carrying+ `"SNSTopicArn": 123` fails instead of storing the topic `"123"`.+- Deleting an access policy or notification configuration that was never set is a no-op,+ so a destroy re-run does not fail.+- **A vault's policy and notification configuration are keyed per vault, not per vault+ name**, so a vault carries only the configuration applied to it. Reusing a deleted vault's+ name therefore starts clean, and cleaning up a deleted vault cannot reach a configuration+ belonging to a later vault of the same name. Deleting a vault removes both, dependents+ first: the three stores have no transaction between them, and that order keeps any+ observable intermediate state a vault without configuration rather than a configuration+ without a vault.+- The access policy and notification configuration are **not** returned by+ `DescribeBackupVault`, matching AWS: each is reachable only through its own `Get`+ operation. The lock fields (`Locked`, `LockDate`, `MinRetentionDays`,+ `MaxRetentionDays`) are on the vault, also matching AWS.## Configuration@@ -109,9 +202,18 @@ Actual backup is simulated — no data is read from or written to the referenced## Not Yet Supported+- **Notification delivery.** `PutBackupVaultNotifications` stores the configuration and+ `GetBackupVaultNotifications` reports it, but no vault event is ever published to the SNS+ topic: a subscriber receives nothing when a backup job completes. The configuration is+ modelled, the delivery is not, so a Terraform configuration that attaches notifications+ applies and reads back correctly while a test asserting on a received message will fail.+- **Access policy enforcement.** `PutBackupVaultAccessPolicy` stores a resource policy and+ `GetBackupVaultAccessPolicy` reports it, but no authorization path consults it: a policy+ denying a vault operation does not prevent that operation, even with IAM enforcement+ enabled. This matches the rest of Floci rather than being specific to Backup -- S3 bucket+ policies are the only resource policies any service enforces today. Stated here because a+ stored-and-ignored policy is otherwise indistinguishable from an enforced one.- Restore jobs (`StartRestoreJob`, `DescribeRestoreJob`, `ListRestoreJobs`)-- Backup vaults with notifications (`PutBackupVaultNotifications`, `GetBackupVaultNotifications`)-- Backup vaults with access policy (`PutBackupVaultAccessPolicy`, `GetBackupVaultAccessPolicy`)- Copy jobs (`StartCopyJob`, `DescribeCopyJob`, `ListCopyJobs`)- Report plans (`CreateReportPlan`, `DescribeReportPlan`, etc.)- Framework operations (`CreateFramework`, etc.)diff --git a/src/main/java/io/github/hectorvent/floci/services/backup/BackupController.java b/src/main/java/io/github/hectorvent/floci/services/backup/BackupController.javaindex eed4154194..fa0ab49a35 100644--- a/src/main/java/io/github/hectorvent/floci/services/backup/BackupController.java+++ b/src/main/java/io/github/hectorvent/floci/services/backup/BackupController.java@@ -88,27 +88,123 @@ public class BackupController {return Response.ok(out).build();}- // Notification configuration is an optional, never-configured aspect of a vault in the- // emulator. Per the AWS Backup API, GetBackupVaultNotifications returns- // ResourceNotFoundException (HTTP 400) when no notification configuration exists for the- // vault. We mirror that exact error contract so SDK clients see the documented- // "not configured" signal rather than an empty 200 or a generic 400 they can't interpret.+ // ── Vault access policy ────────────────────────────────────────────────────+ //+ // These three used to be one unconditional GET that always answered+ // ResourceNotFoundException, on the reasoning that a policy is "an optional,+ // never-configured aspect of a vault in the emulator". That error contract was+ // right and is kept below for the genuinely-unconfigured case; what was missing is+ // any way to configure one. A vault could be created and never given a policy, a+ // lock or a notification target, so every Gruntwork example that configures a vault+ // failed at apply.++ @PUT+ @Path("/backup-vaults/{backupVaultName}/access-policy")+ public Response putBackupVaultAccessPolicy(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName,+ String body) throws IOException {+ String region = regionResolver.resolveRegion(headers);+ JsonNode req = objectMapper.readTree(body == null || body.isBlank() ? "{}" : body);+ // AWS accepts Policy as a JSON string. Terraform sends a string; the console+ // sends a string. An object is accepted too and re-serialised, because refusing+ // it would be stricter than AWS for no benefit to the caller.+ JsonNode policyNode = req.path("Policy");+ String policy = policyNode.isMissingNode() || policyNode.isNull() ? null+ : (policyNode.isTextual() ? policyNode.asText() : policyNode.toString());+ service.putBackupVaultAccessPolicy(vaultName, region, policy);+ return Response.noContent().build();+ }+@GET+ @Path("/backup-vaults/{backupVaultName}/access-policy")+ public Response getBackupVaultAccessPolicy(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName) {+ String region = regionResolver.resolveRegion(headers);+ String policy = service.getBackupVaultAccessPolicy(vaultName, region);+ BackupVault vault = service.describeBackupVault(vaultName, region);+ ObjectNode out = objectMapper.createObjectNode();+ out.put("BackupVaultName", vault.getBackupVaultName());+ out.put("BackupVaultArn", vault.getBackupVaultArn());+ out.put("Policy", policy);+ return Response.ok(out).build();+ }++ @DELETE+ @Path("/backup-vaults/{backupVaultName}/access-policy")+ public Response deleteBackupVaultAccessPolicy(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName) {+ String region = regionResolver.resolveRegion(headers);+ service.deleteBackupVaultAccessPolicy(vaultName, region);+ return Response.noContent().build();+ }++ // ── Vault notifications ────────────────────────────────────────────────────++ @PUT@Path("/backup-vaults/{backupVaultName}/notification-configuration")- public Response getBackupVaultNotifications(@PathParam("backupVaultName") String vaultName) {- throw new AwsException("ResourceNotFoundException",- "No notification configuration found for backup vault: " + vaultName, 400);+ public Response putBackupVaultNotifications(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName,+ String body) throws IOException {+ String region = regionResolver.resolveRegion(headers);+ JsonNode req = objectMapper.readTree(body == null || body.isBlank() ? "{}" : body);+ // null, not an empty list, when the member is absent: the service answers a missing+ // parameter with MissingParameterValueException and an empty one with+ // InvalidParameterValueException, and readStringList cannot tell them apart.+ JsonNode eventsNode = req.path("BackupVaultEvents");+ List<String> events = eventsNode.isMissingNode() || eventsNode.isNull() ? null+ : readStringList(eventsNode);+ service.putBackupVaultNotifications(vaultName, region, stringOrNull(req, "SNSTopicArn"), events);+ return Response.noContent().build();}- // Access policy is an optional, never-configured aspect of a vault in the emulator. Per the- // AWS Backup API, GetBackupVaultAccessPolicy returns ResourceNotFoundException (HTTP 400)- // when no policy exists for the vault. We mirror that exact error contract so SDK clients- // see the documented "not configured" signal rather than an empty 200 or a generic 400.@GET- @Path("/backup-vaults/{backupVaultName}/access-policy")- public Response getBackupVaultAccessPolicy(@PathParam("backupVaultName") String vaultName) {- throw new AwsException("ResourceNotFoundException",- "No access policy found for backup vault: " + vaultName, 400);+ @Path("/backup-vaults/{backupVaultName}/notification-configuration")+ public Response getBackupVaultNotifications(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName) {+ String region = regionResolver.resolveRegion(headers);+ BackupVaultNotifications notifications = service.getBackupVaultNotifications(vaultName, region);+ BackupVault vault = service.describeBackupVault(vaultName, region);+ ObjectNode out = objectMapper.createObjectNode();+ out.put("BackupVaultName", vault.getBackupVaultName());+ out.put("BackupVaultArn", vault.getBackupVaultArn());+ out.put("SNSTopicArn", notifications.getSnsTopicArn());+ ArrayNode events = out.putArray("BackupVaultEvents");+ notifications.getBackupVaultEvents().forEach(events::add);+ return Response.ok(out).build();+ }++ @DELETE+ @Path("/backup-vaults/{backupVaultName}/notification-configuration")+ public Response deleteBackupVaultNotifications(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName) {+ String region = regionResolver.resolveRegion(headers);+ service.deleteBackupVaultNotifications(vaultName, region);+ return Response.noContent().build();+ }++ // ── Vault lock ─────────────────────────────────────────────────────────────++ @PUT+ @Path("/backup-vaults/{backupVaultName}/vault-lock")+ public Response putBackupVaultLockConfiguration(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName,+ String body) throws IOException {+ String region = regionResolver.resolveRegion(headers);+ JsonNode req = objectMapper.readTree(body == null || body.isBlank() ? "{}" : body);+ service.putBackupVaultLockConfiguration(vaultName, region,+ longOrNull(req, "MinRetentionDays"),+ longOrNull(req, "MaxRetentionDays"),+ longOrNull(req, "ChangeableForDays"));+ return Response.noContent().build();+ }++ @DELETE+ @Path("/backup-vaults/{backupVaultName}/vault-lock")+ public Response deleteBackupVaultLockConfiguration(@Context HttpHeaders headers,+ @PathParam("backupVaultName") String vaultName) {+ String region = regionResolver.resolveRegion(headers);+ service.deleteBackupVaultLockConfiguration(vaultName, region);+ return Response.noContent().build();}// ── Plan ───────────────────────────────────────────────────────────────────@@ -365,11 +461,66 @@ public class BackupController {// ── Helpers ────────────────────────────────────────────────────────────────+ // Absent and null both mean "not supplied", which for these members is meaningful:+ // omitting ChangeableForDays is what selects compliance mode.+ //+ // A present value must be an INTEGRAL NUMBER, and is rejected rather than coerced.+ // asLong() would silently accept anything: 1.5 truncates to 1, true becomes 1, and+ // the string "7" becomes 7 -- so a request AWS rejects with a serialization error+ // would instead succeed here against a value the caller never asked for, and a+ // retention floor could be set from a number that was never sent. Matches the+ // existing shape in KinesisJsonHandler#optionalMaxRecordSize and+ // TimestreamInfluxDbValidation, which reject on !isIntegralNumber() for the same+ // reason. Found by Greptile on the fork PR.+ private static Long longOrNull(JsonNode node, String field) {+ JsonNode n = node.path(field);+ if (n.isMissingNode() || n.isNull()) {+ return null;+ }+ // canConvertToLong as well as isIntegralNumber, because the first alone leaves+ // one coercion open: 18446744073709551623 IS an integral number, and+ // longValue() keeps its low 64 bits, wrapping it to 7, which then passes the+ // retention checks as if the caller had sent it. Kinesis guards the same way+ // with canConvertToInt (KinesisJsonHandler#optionalMaxRecordSize). Rejecting+ // a value we cannot represent is the whole point of not coercing.+ if (!n.isIntegralNumber() || !n.canConvertToLong()) {+ throw new AwsException("InvalidParameterValueException",+ field + " must be an integer", 400);+ }+ return n.longValue();+ }+private static String textOrNull(JsonNode node, String field) {JsonNode n = node.path(field);return n.isMissingNode() || n.isNull() ? null : n.asText();}+ /**+ * Like {@link #textOrNull} but refuses to invent a string out of something that is not one.+ *+ * <p>{@code asText()} coerces: a request carrying {@code "SNSTopicArn": 123} yields the+ * nonblank string {@code "123"}, which passes every present-and-nonblank check the service+ * makes and is stored as the topic. The configuration then reads back as valid while naming a+ * topic that cannot exist. This is the same coercion Greptile found in {@link #longOrNull}+ * above, in the other direction, and it gets the same answer: reject a value we would have to+ * fabricate rather than read.+ *+ * <p>Used for the fields where the fabricated value would survive validation. The advisory+ * ones -- CreatorRequestId and the like -- stay on textOrNull, because a coerced value there+ * is stored and echoed and misleads nobody.+ */+ private static String stringOrNull(JsonNode node, String field) {+ JsonNode n = node.path(field);+ if (n.isMissingNode() || n.isNull()) {+ return null;+ }+ if (!n.isTextual()) {+ throw new AwsException("InvalidParameterValueException",+ field + " must be a string", 400);+ }+ return n.asText();+ }+@SuppressWarnings("unchecked")private Map<String, String> readStringMap(JsonNode node, String field) {JsonNode mapNode = node.path(field);diff --git a/src/main/java/io/github/hectorvent/floci/services/backup/BackupService.java b/src/main/java/io/github/hectorvent/floci/services/backup/BackupService.javaindex eb34e29cc4..e80d6654d5 100644--- a/src/main/java/io/github/hectorvent/floci/services/backup/BackupService.java+++ b/src/main/java/io/github/hectorvent/floci/services/backup/BackupService.java@@ -1,6 +1,8 @@package io.github.hectorvent.floci.services.backup;+import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;@@ -14,8 +16,10 @@ import jakarta.inject.Inject;import org.jboss.logging.Logger;import java.time.Instant;+import java.time.temporal.ChronoUnit;import java.util.*;+import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;@@ -35,9 +39,21 @@ public class BackupService {private final StorageBackend<String, BackupSelection> selectionStore;private final StorageBackend<String, BackupJob> jobStore;private final StorageBackend<String, RecoveryPoint> recoveryStore;+ private final StorageBackend<String, String> accessPolicyStore;+ private final StorageBackend<String, BackupVaultNotifications> notificationStore;private final RegionResolver regionResolver;private final int jobCompletionDelaySeconds;+ private final ObjectMapper objectMapper;++ // One monitor per vault key, so the check-then-write in createBackupVault and the+ // multi-store cleanup in deleteBackupVault are atomic for a given name. Same shape as+ // SecretsManagerService#lockFor and KinesisService's append locks.+ private final ConcurrentHashMap<String, Object> vaultLocks = new ConcurrentHashMap<>();++ private Object lockFor(String vaultKey) {+ return vaultLocks.computeIfAbsent(vaultKey, k -> new Object());+ }private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(r -> {Thread t = new Thread(r, "backup-job-scheduler");@@ -46,13 +62,17 @@ public class BackupService {});@Inject- public BackupService(StorageFactory storageFactory, EmulatorConfig config, RegionResolver regionResolver) {+ public BackupService(StorageFactory storageFactory, EmulatorConfig config, RegionResolver regionResolver,+ ObjectMapper objectMapper) {this.vaultStore = storageFactory.create("backup", "backup-vaults.json", new TypeReference<>() {});this.planStore = storageFactory.create("backup", "backup-plans.json", new TypeReference<>() {});this.selectionStore = storageFactory.create("backup", "backup-selections.json", new TypeReference<>() {});this.jobStore = storageFactory.create("backup", "backup-jobs.json", new TypeReference<>() {});this.recoveryStore = storageFactory.create("backup", "backup-recovery-points.json", new TypeReference<>() {});+ this.accessPolicyStore = storageFactory.create("backup", "backup-vault-access-policies.json", new TypeReference<>() {});+ this.notificationStore = storageFactory.create("backup", "backup-vault-notifications.json", new TypeReference<>() {});this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;this.jobCompletionDelaySeconds = config.services().backup().jobCompletionDelaySeconds();}@@ -67,20 +87,34 @@ public class BackupService {String creatorRequestId, Map<String, String> tags,String region) {String key = vaultKey(region, vaultName);- if (vaultStore.get(key).isPresent()) {- throw new AwsException("AlreadyExistsException", "Backup vault already exists: " + vaultName, 400);- }- BackupVault vault = new BackupVault();- vault.setBackupVaultName(vaultName);- vault.setBackupVaultArn(regionResolver.buildArn("backup", region, "backup-vault:" + vaultName));- vault.setEncryptionKeyArn(encryptionKeyArn);- vault.setCreationDate(Instant.now().getEpochSecond());- vault.setCreatorRequestId(creatorRequestId);- vault.setNumberOfRecoveryPoints(0);- vault.setTags(tags);- vaultStore.put(key, vault);- LOG.infov("Created backup vault {0} in {1}", vaultName, region);- return vault;+ // Check and write under one monitor. Unsynchronised, two creates of the same name can+ // both find the name free and both write, so AlreadyExistsException never fires and the+ // two vaults share a sub-resource key -- the second could then read configuration+ // applied to the first. AWS's CreateBackupVault is atomic for a name; this is what+ // makes it atomic here. Same per-key monitor pattern as SecretsManagerService#lockFor.+ //+ // No sub-resource sweep in here, deliberately. An earlier revision swept the two stores+ // at this point and that traded one race for a worse one: with two creates in flight the+ // later sweep could delete a configuration already applied against the earlier vault,+ // while both creates reported success. Deleting a configuration a caller had just+ // successfully applied is worse than the stale record the sweep was there to prevent.+ // Sub-resources are keyed per vault incarnation instead, so there is nothing to sweep.+ synchronized (lockFor(key)) {+ if (vaultStore.get(key).isPresent()) {+ throw new AwsException("AlreadyExistsException", "Backup vault already exists: " + vaultName, 400);+ }+ BackupVault vault = new BackupVault();+ vault.setBackupVaultName(vaultName);+ vault.setBackupVaultArn(regionResolver.buildArn("backup", region, "backup-vault:" + vaultName));+ vault.setEncryptionKeyArn(encryptionKeyArn);+ vault.setCreationDate(Instant.now().getEpochSecond());+ vault.setCreatorRequestId(creatorRequestId);+ vault.setNumberOfRecoveryPoints(0);+ vault.setTags(tags);+ vaultStore.put(key, vault);+ LOG.infov("Created backup vault {0} in {1}", vaultName, region);+ return vault;+ }}public BackupVault describeBackupVault(String vaultName, String region) {@@ -89,11 +123,38 @@ public class BackupService {}public void deleteBackupVault(String vaultName, String region) {+ // Under the same monitor as createBackupVault: the three deletes below must not+ // interleave with a create of this name, or the name could be recreated mid-cleanup.+ synchronized (lockFor(vaultKey(region, vaultName))) {+ deleteBackupVaultLocked(vaultName, region);+ }+ }++ private void deleteBackupVaultLocked(String vaultName, String region) {BackupVault vault = describeBackupVault(vaultName, region);if (vault.getNumberOfRecoveryPoints() > 0) {throw new AwsException("InvalidRequestException","Non-empty backup vault cannot be deleted: " + vaultName, 400);}+ // No lock check here, deliberately. A lock protects the RECOVERY POINTS, not the+ // vault shell: AWS's guide says the vault "can be deleted if it is empty and does+ // not contain any recovery points", even under a compliance lock. The non-empty+ // check above is already the case AWS refuses, so an added lock check would only+ // ever fire where AWS succeeds -- and it would break CloudFormation stack teardown,+ // which deletes vaults through BackupVaultCfnProvisioner and tolerates only+ // not-found.+ // Drop the sub-resources with the vault. They are keyed by vault name, so+ // leaving them behind would silently graft an old policy or notification+ // configuration onto the next vault created with the same name.+ //+ // Dependents first, the vault record last. There is no transaction across three+ // stores, so whatever sits between the first delete and the last is observable, and+ // this order keeps the observable state a vault with no configuration rather than a+ // configuration with no vault. The sub-resource keys carry this vault's creation date,+ // so these two deletes cannot reach a configuration belonging to a later vault that+ // has taken the same name -- which is what made the previous order lose data.+ accessPolicyStore.delete(subResourceKey(region, vault));+ notificationStore.delete(subResourceKey(region, vault));vaultStore.delete(vaultKey(region, vaultName));}@@ -102,6 +163,329 @@ public class BackupService {return vaultStore.scan(k -> k.startsWith(prefix));}+ // ── Vault sub-resources: access policy, notifications, lock ────────────────+ //+ // Each of these first resolves the vault through describeBackupVault, so a call+ // naming a vault that does not exist reports that, rather than reporting the+ // sub-resource as merely unconfigured. The two are different answers to different+ // questions and AWS distinguishes them; collapsing them would tell a caller its+ // typo'd vault name was fine.++ /**+ * Every BackupVaultEvent value the PutBackupVaultNotifications reference lists,+ * including the ones AWS marks deprecated -- they are still accepted values, and+ * rejecting one would fail an apply AWS allows.+ *+ * <p>All 30 of them. An earlier revision carried 17, which is the failure mode this+ * whole validation has to avoid: a list that rejects is only as good as it is+ * complete, and a stale one turns a valid configuration into a 400.+ */+ /**+ * The ceiling the PutBackupVaultLockConfiguration reference documents for two of the three+ * day values: MaxRetentionDays, "The longest maximum retention period you can specify is+ * 36500 days", and ChangeableForDays, "The maximum value you can specify is 36,500 days".+ * MinRetentionDays has no documented maximum and is deliberately not bounded by it.+ */+ private static final long MAX_RETENTION_DAYS = 36500;++ private static final Set<String> BACKUP_VAULT_EVENTS = Set.of(+ "BACKUP_JOB_STARTED", "BACKUP_JOB_COMPLETED", "BACKUP_JOB_SUCCESSFUL",+ "BACKUP_JOB_FAILED", "BACKUP_JOB_EXPIRED",+ "RESTORE_JOB_STARTED", "RESTORE_JOB_COMPLETED", "RESTORE_JOB_SUCCESSFUL",+ "RESTORE_JOB_FAILED",+ "COPY_JOB_STARTED", "COPY_JOB_SUCCESSFUL", "COPY_JOB_FAILED",+ "RECOVERY_POINT_MODIFIED",+ "BACKUP_PLAN_CREATED", "BACKUP_PLAN_MODIFIED",+ "S3_BACKUP_OBJECT_FAILED", "S3_RESTORE_OBJECT_FAILED",+ "CONTINUOUS_BACKUP_INTERRUPTED",+ "RECOVERY_POINT_INDEX_COMPLETED", "RECOVERY_POINT_INDEX_DELETED",+ "RECOVERY_POINT_INDEXING_FAILED",+ "EKS_RESTORE_OBJECT_FAILED", "EKS_RESTORE_OBJECT_SKIPPED",+ "EKS_BACKUP_OBJECT_FAILED",+ "ACCESS_POINT_AVAILABLE", "ACCESS_POINT_CREATION_FAILED",+ "ACCESS_POINT_DELETED", "ACCESS_POINT_DELETION_FAILED",+ "ACCESS_POINT_EXPIRED", "ACCESS_POINT_DISASSOCIATED");++ /**+ * The reference documents {@code Policy} as "Required: No", so a request that omits it is+ * not an error and must not be refused here. What AWS stores in that case is not documented+ * and we have not measured it; clearing is the choice taken, because it leaves the vault+ * carrying exactly the policy the request carried rather than one the caller did not send,+ * and it keeps the end state readable through GetBackupVaultAccessPolicy. An empty string is+ * a different case: it is present and invalid, so it is still rejected.+ */+ public void putBackupVaultAccessPolicy(String vaultName, String region, String policy) {+ BackupVault vault = describeBackupVault(vaultName, region);+ if (policy == null) {+ accessPolicyStore.delete(subResourceKey(region, vault));+ return;+ }+ if (policy.isBlank()) {+ throw new AwsException("InvalidParameterValueException",+ "Policy must be a non-empty resource policy document", 400);+ }+ requireJsonObject(policy);+ accessPolicyStore.put(subResourceKey(region, vault), policy);+ }++ /**+ * A resource policy has to be a JSON object before anything else can be true of it.+ *+ * <p>Checking only for blankness accepted {@code not a policy}: PUT reported success and GET+ * returned the string back unchanged, so an unparseable policy looked applied. That is the+ * emulator being more permissive than AWS, which is the one direction that costs a user real+ * time -- the configuration passes locally and the deploy is where they find out.+ *+ * <p>Syntax only. Floci does not evaluate whether the document grants or denies anything, and+ * PutBackupVaultAccessPolicy does not list MalformedPolicyDocumentException among its errors,+ * so a bad document is reported as the invalid parameter value it is.+ */+ private void requireJsonObject(String policy) {+ try {+ if (!objectMapper.readTree(policy).isObject()) {+ throw new AwsException("InvalidParameterValueException",+ "Policy must be a JSON object", 400);+ }+ } catch (JsonProcessingException e) {+ throw new AwsException("InvalidParameterValueException",+ "Policy is not a valid JSON document: " + e.getOriginalMessage(), 400);+ }+ }++ public String getBackupVaultAccessPolicy(String vaultName, String region) {+ BackupVault vault = describeBackupVault(vaultName, region);+ return accessPolicyStore.get(subResourceKey(region, vault))+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "No access policy found for backup vault: " + vaultName, 400));+ }++ /**+ * Deleting an access policy that is not set is a no-op, so Terraform destroying a+ * configuration twice does not fail the second time. That is Floci's choice and not a+ * measured AWS behaviour: the reference lists ResourceNotFoundException among this+ * operation's errors and does not say whether an unset policy raises it.+ */+ public void deleteBackupVaultAccessPolicy(String vaultName, String region) {+ BackupVault vault = describeBackupVault(vaultName, region);+ accessPolicyStore.delete(subResourceKey(region, vault));+ }++ public void putBackupVaultNotifications(String vaultName, String region,+ String snsTopicArn, List<String> events) {+ BackupVault vault = describeBackupVault(vaultName, region);+ // Absent and present-but-empty are different faults. PutBackupVaultNotifications lists+ // MissingParameterValueException, "Indicates that a required parameter is missing", in+ // its Errors section, which names the absent case. The reference does not name the+ // present-but-unusable case, so it keeps InvalidParameterValueException.+ if (snsTopicArn == null) {+ throw new AwsException("MissingParameterValueException",+ "SNSTopicArn is required", 400);+ }+ if (snsTopicArn.isBlank()) {+ throw new AwsException("InvalidParameterValueException",+ "SNSTopicArn must not be empty", 400);+ }+ if (events == null) {+ throw new AwsException("MissingParameterValueException",+ "BackupVaultEvents is required", 400);+ }+ if (events.isEmpty()) {+ throw new AwsException("InvalidParameterValueException",+ "BackupVaultEvents must name at least one event", 400);+ }+ // Reject unknown events rather than storing them. An emulator that accepts a+ // misspelt event and reports it back unchanged lets a configuration that real+ // AWS refuses pass a local test, which is the failure mode this corpus exists+ // to catch.+ List<String> unknown = events.stream().filter(e -> !BACKUP_VAULT_EVENTS.contains(e)).toList();+ if (!unknown.isEmpty()) {+ throw new AwsException("InvalidParameterValueException",+ "Invalid backup vault event(s): " + String.join(", ", unknown), 400);+ }+ notificationStore.put(subResourceKey(region, vault),+ new BackupVaultNotifications(snsTopicArn, events));+ }++ public BackupVaultNotifications getBackupVaultNotifications(String vaultName, String region) {+ BackupVault vault = describeBackupVault(vaultName, region);+ return notificationStore.get(subResourceKey(region, vault))+ .orElseThrow(() -> new AwsException("ResourceNotFoundException",+ "No notification configuration found for backup vault: " + vaultName, 400));+ }++ /** Idempotent, for the same reason as {@link #deleteBackupVaultAccessPolicy}. */+ public void deleteBackupVaultNotifications(String vaultName, String region) {+ BackupVault vault = describeBackupVault(vaultName, region);+ notificationStore.delete(subResourceKey(region, vault));+ }++ /**+ * Apply a Vault Lock.+ *+ * <p>AWS has two modes and {@code ChangeableForDays} is what selects them, in the+ * direction that reads backwards at first glance:+ *+ * <ul>+ * <li><b>Absent → governance mode.</b> "If this parameter is not specified, you+ * can delete Vault Lock from the vault using DeleteBackupVaultLockConfiguration+ * or change the Vault Lock configuration using PutBackupVaultLockConfiguration+ * at any time." No lock date is set and the lock never becomes immutable.</li>+ * <li><b>Present → compliance mode.</b> The lock date is that many days out, and+ * "before the lock date, you can delete Vault Lock ... On and after the lock+ * date, the Vault Lock becomes immutable and cannot be changed or deleted."+ * AWS enforces a 72-hour cooling-off period, hence the floor of 3.</li>+ * </ul>+ *+ * <p>An earlier revision of this method had the two the wrong way round, which made+ * AWS's freely removable governance lock permanent. Both quotations above are from+ * the PutBackupVaultLockConfiguration reference; the Vault Lock guide states the+ * mapping the same way ("If you wish to create a vault lock in governance mode, do+ * not include ChangeableForDays").+ */+ public BackupVault putBackupVaultLockConfiguration(String vaultName, String region,+ Long minRetentionDays,+ Long maxRetentionDays,+ Long changeableForDays) {+ BackupVault vault = describeBackupVault(vaultName, region);+ if (vault.isLocked() && !lockIsStillChangeable(vault)) {+ throw new AwsException("InvalidRequestException",+ "Backup vault lock is immutable and cannot be changed: " + vaultName, 400);+ }+ // "The shortest minimum retention period you can specify is 1 day." The reference states+ // no maximum for this field, so it gets none here: inventing a bound risks refusing a+ // value real AWS accepts, which is the divergence this work exists to remove, not create.+ requireDayRange("MinRetentionDays", minRetentionDays, 1, null);+ requireDayRange("MaxRetentionDays", maxRetentionDays, 1, MAX_RETENTION_DAYS);+ if (minRetentionDays != null && maxRetentionDays != null && maxRetentionDays < minRetentionDays) {+ throw new AwsException("InvalidParameterValueException",+ "MaxRetentionDays must be greater than or equal to MinRetentionDays", 400);+ }+ // "You must set ChangeableForDays to 3 or greater": below it a governance lock would be+ // effectively immutable on creation, which is what compliance mode is for.+ requireDayRange("ChangeableForDays", changeableForDays, 3, MAX_RETENTION_DAYS);+ vault.setLocked(true);+ vault.setMinRetentionDays(minRetentionDays);+ vault.setMaxRetentionDays(maxRetentionDays);+ vault.setLockDate(changeableForDays == null ? null+ : Instant.now().plus(changeableForDays, ChronoUnit.DAYS).getEpochSecond());+ vaultStore.put(vaultKey(region, vaultName), vault);+ LOG.infov("Locked backup vault {0} in {1} ({2})", vaultName, region,+ changeableForDays == null+ ? "governance mode, changeable at any time"+ : "compliance mode, changeable for " + changeableForDays + " day(s)");+ return vault;+ }++ /**+ * Bound one Vault Lock day value. A null {@code ceiling} means the reference documents no+ * maximum for that field, and the value is only floored.+ *+ * <p>Where a ceiling is documented, two things go wrong without it, and the second is the+ * worse one. A value like 40,000 is accepted here and refused by AWS, which is the shape this+ * whole corpus exists to catch: a Terraform configuration that applies locally and fails for+ * real.+ *+ * <p>And {@code Long.MAX_VALUE} is a perfectly good long, so it survives the integral check in+ * the controller and reaches {@code Instant.plus}, which throws {@code ArithmeticException:+ * long overflow}. The only exception mapper in the tree handles {@link AwsException}, so that+ * escapes as an HTTP 500 rather than the documented 400. Bounding ChangeableForDays, the one+ * value that reaches {@code Instant.plus}, is what stops the overflow being reachable at all,+ * rather than catching it after the fact.+ */+ private static void requireDayRange(String field, Long value, long floor, Long ceiling) {+ if (value == null) {+ return;+ }+ if (value < floor || (ceiling != null && value > ceiling)) {+ throw new AwsException("InvalidParameterValueException",+ ceiling == null+ ? field + " must be " + floor + " or greater"+ : field + " must be between " + floor + " and " + ceiling, 400);+ }+ }++ public void deleteBackupVaultLockConfiguration(String vaultName, String region) {+ BackupVault vault = describeBackupVault(vaultName, region);+ if (vault.isLocked() && !lockIsStillChangeable(vault)) {+ throw new AwsException("InvalidRequestException",+ "Backup vault lock is immutable and cannot be deleted: " + vaultName, 400);+ }+ vault.setLocked(false);+ vault.setLockDate(null);+ vault.setMinRetentionDays(null);+ vault.setMaxRetentionDays(null);+ vaultStore.put(vaultKey(region, vaultName), vault);+ }++ /**+ * Refuse a backup whose retention the vault's lock does not permit.+ *+ * <p>This is the other half of what a Vault Lock does, and the half that acts at write time:+ * "Backup jobs will fail if the lifecycle policy of the backup plan is outside the vault lock's+ * retention period." MinRetentionDays and MaxRetentionDays bound {@code DeleteAfterDays}, so a+ * plan retaining for 7 days cannot write into a vault whose lock demands 30.+ *+ * <p>Until this existed, {@code getMaxRetentionDays} had no reader anywhere in the tree: the+ * ceiling was accepted, stored, and reported by DescribeBackupVault while bounding nothing. A+ * Terraform configuration pairing a lock with a shorter plan lifecycle therefore applied+ * cleanly here and failed its first backup on real AWS, which is precisely the divergence this+ * emulator exists to remove rather than introduce.+ *+ * <p><b>An absent lifecycle is checked against the MAXIMUM, not waved through.</b> The first+ * version of this returned early whenever DeleteAfterDays was missing, on the reasoning that+ * indefinite retention cannot exceed a maximum. That is backwards, and it left the ceiling+ * bypassable by simply omitting the member: retaining forever is the LARGEST retention there+ * is, so it exceeds every finite maximum, and the recovery point outlives the limit the lock+ * was created to impose. A minimum is the other way round -- indefinite satisfies any floor --+ * so an absent lifecycle is refused only when a maximum is set.+ *+ * <p>That last point is Floci's reading rather than a quotation. The reference states the+ * rule for a lifecycle that falls outside the window and does not spell out the absent case;+ * the reading is forced by what a maximum retention period means, and it errs toward refusing+ * a request rather than storing a recovery point the lock forbids.+ */+ private static void requireLifecycleWithinLock(BackupVault vault, Lifecycle lifecycle) {+ if (!vault.isLocked()) {+ return;+ }+ Long min = vault.getMinRetentionDays();+ Long max = vault.getMaxRetentionDays();+ Long deleteAfterDays = lifecycle == null ? null : lifecycle.getDeleteAfterDays();+ if (deleteAfterDays == null) {+ if (max != null) {+ throw new AwsException("InvalidParameterValueException",+ "Lifecycle DeleteAfterDays is required for a vault locked with a maximum "+ + "retention of " + max + " day(s): retaining indefinitely would "+ + "exceed it", 400);+ }+ return;+ }+ long deleteAfter = deleteAfterDays;+ if (min != null && deleteAfter < min) {+ throw new AwsException("InvalidParameterValueException",+ "Lifecycle DeleteAfterDays of " + deleteAfter + " is below the vault lock's "+ + "minimum retention of " + min + " day(s)", 400);+ }+ if (max != null && deleteAfter > max) {+ throw new AwsException("InvalidParameterValueException",+ "Lifecycle DeleteAfterDays of " + deleteAfter + " exceeds the vault lock's "+ + "maximum retention of " + max + " day(s)", 400);+ }+ }++ /**+ * True while a lock can still be changed or removed.+ *+ * <p>A governance lock carries no LockDate and is always changeable. A compliance+ * lock is changeable only before its LockDate. Absent means governance, so a null+ * LockDate must answer TRUE here -- the inverse of this is the defect that made a+ * governance lock permanent.+ */+ private static boolean lockIsStillChangeable(BackupVault vault) {+ Long lockDate = vault.getLockDate();+ return lockDate == null || Instant.now().getEpochSecond() < lockDate;+ }+// ── Plan ───────────────────────────────────────────────────────────────────public BackupPlan createBackupPlan(String planName, List<BackupRule> rules,@@ -197,6 +581,7 @@ public class BackupService {public BackupJob startBackupJob(String vaultName, String resourceArn, String iamRoleArn,Lifecycle lifecycle, String region) {BackupVault vault = describeBackupVault(vaultName, region);+ requireLifecycleWithinLock(vault, lifecycle);String jobId = UUID.randomUUID().toString();long now = Instant.now().getEpochSecond();@@ -267,8 +652,37 @@ public class BackupService {.toList();}+ /**+ * Delete a recovery point, unless a Vault Lock still protects it.+ *+ * <p>This is what the lock is FOR. "Vault Lock ... prevents the deletion of recovery points+ * before their retention periods expire", and the minimum retention period is the floor: a+ * recovery point younger than MinRetentionDays cannot be deleted while the vault is locked.+ * Without this check the lock was decorative -- it governed only its own mutation, so+ * PutBackupVaultLockConfiguration succeeded, DescribeBackupVault reported Locked, and every+ * recovery point the lock was supposed to protect deleted exactly as before. An empty vault+ * then deletes too, so the whole protection came apart from the one operation it names.+ *+ * <p>Both lock modes enforce retention. Governance mode differs on real AWS in that a+ * principal holding {@code backup:DisableGovernanceRetention} can override it; Floci does not+ * model that permission, so governance mode enforces here as compliance mode does. That is+ * stricter than AWS for an unusually-privileged caller and identical for every other one,+ * which is the safer direction: a local test that deletes a protected recovery point and+ * passes would be describing AWS behaviour that needs a specific permission to reproduce.+ */public void deleteRecoveryPoint(String vaultName, String recoveryPointArn, String region) {+ BackupVault vault = describeBackupVault(vaultName, region);RecoveryPoint rp = describeRecoveryPoint(vaultName, recoveryPointArn, region);+ if (vault.isLocked() && vault.getMinRetentionDays() != null) {+ long ageDays = ChronoUnit.DAYS.between(+ Instant.ofEpochSecond(rp.getCreationDate()), Instant.now());+ if (ageDays < vault.getMinRetentionDays()) {+ throw new AwsException("InvalidRequestException",+ "Recovery point is protected by a vault lock until its minimum retention of "+ + vault.getMinRetentionDays() + " day(s) has elapsed: " + recoveryPointArn,+ 400);+ }+ }recoveryStore.delete(recoveryPointArn);decrementVaultCount(vaultName, region);}@@ -444,6 +858,33 @@ public class BackupService {return region + ":" + vaultName;}+ /**+ * The key a vault's sub-resources are stored under: the vault key plus the vault's creation+ * date, so it identifies THIS vault rather than merely this NAME.+ *+ * <p>Keying by name alone is what made delete-and-recreate hazardous in both directions. A+ * record surviving a delete grafted an old policy onto the next vault to take the name, and+ * cleaning up by name could erase a live configuration belonging to a vault that had already+ * replaced the one being deleted. Sweeping stale records on create fixed the first and made+ * the second worse, because two creates racing the existence check would both sweep, and the+ * later sweep would delete a configuration applied against the earlier vault.+ *+ * <p>Including the creation date removes the shared key instead of policing it. A new vault+ * cannot read, and cleanup for an old vault cannot touch, a record belonging to a different+ * incarnation of the name -- no sweep, and no dependence on the order two stores are written+ * in. Deleting a vault still removes its own records, now because they are its own rather+ * than because nothing else has claimed them yet.+ *+ * <p>The creation date is only unique per name because {@code createBackupVault} holds a+ * per-name monitor across its check and its write, so two vaults of one name cannot exist+ * and cannot be created in the same second. Without that lock this key would still collide+ * and the two vaults could read each other's configuration. The delete path also removes its+ * own sub-resources, which covers a record surviving for any other reason.+ */+ private static String subResourceKey(String region, BackupVault vault) {+ return vaultKey(region, vault.getBackupVaultName()) + ":" + vault.getCreationDate();+ }+private static String vaultKey(BackupVault vault) {String region = AwsArnUtils.parse(vault.getBackupVaultArn()).region();return region + ":" + vault.getBackupVaultName();diff --git a/src/main/java/io/github/hectorvent/floci/services/backup/model/BackupVault.java b/src/main/java/io/github/hectorvent/floci/services/backup/model/BackupVault.javaindex 36f2b35330..83ac954f09 100644--- a/src/main/java/io/github/hectorvent/floci/services/backup/model/BackupVault.java+++ b/src/main/java/io/github/hectorvent/floci/services/backup/model/BackupVault.java@@ -34,6 +34,27 @@ public class BackupVault {@JsonProperty("Tags")private Map<String, String> tags = new HashMap<>();+ // Vault Lock. These four ARE part of the DescribeBackupVault response in AWS, unlike+ // the access policy and the notification configuration, which have their own Get+ // operations and are stored separately.+ //+ // `locked` is a primitive, so it serialises as `false` on an unlocked vault rather+ // than being dropped by @JsonInclude(NON_NULL). That matches AWS, which always+ // reports Locked, and it matters: a client that has to distinguish "not locked" from+ // "this emulator does not model locking" can only do so if the member is present.+ // The other three stay boxed, because AWS omits them until a lock exists.+ @JsonProperty("Locked")+ private boolean locked;++ @JsonProperty("LockDate")+ private Long lockDate;++ @JsonProperty("MinRetentionDays")+ private Long minRetentionDays;++ @JsonProperty("MaxRetentionDays")+ private Long maxRetentionDays;+public BackupVault() {}public String getBackupVaultName() { return backupVaultName; }@@ -56,4 +77,16 @@ public class BackupVault {public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags != null ? tags : new HashMap<>(); }++ public boolean isLocked() { return locked; }+ public void setLocked(boolean locked) { this.locked = locked; }++ public Long getLockDate() { return lockDate; }+ public void setLockDate(Long lockDate) { this.lockDate = lockDate; }++ public Long getMinRetentionDays() { return minRetentionDays; }+ public void setMinRetentionDays(Long minRetentionDays) { this.minRetentionDays = minRetentionDays; }++ public Long getMaxRetentionDays() { return maxRetentionDays; }+ public void setMaxRetentionDays(Long maxRetentionDays) { this.maxRetentionDays = maxRetentionDays; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/backup/model/BackupVaultNotifications.java b/src/main/java/io/github/hectorvent/floci/services/backup/model/BackupVaultNotifications.javanew file mode 100644index 0000000000..077ed315bc--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/backup/model/BackupVaultNotifications.java@@ -0,0 +1,46 @@+package io.github.hectorvent.floci.services.backup.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.List;++/**+ * The notification configuration attached to a backup vault.+ *+ * <p>Held in its own store rather than as a field on {@link BackupVault} because+ * {@code DescribeBackupVault} serialises the vault POJO directly, and AWS does not+ * return the notification configuration there -- it is reachable only through+ * {@code GetBackupVaultNotifications}. Keeping it separate is what stops the vault+ * description growing members real AWS does not send.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+@JsonInclude(JsonInclude.Include.NON_NULL)+public class BackupVaultNotifications {++ @JsonProperty("SNSTopicArn")+ private String snsTopicArn;++ @JsonProperty("BackupVaultEvents")+ private List<String> backupVaultEvents = new ArrayList<>();++ public BackupVaultNotifications() {}++ public BackupVaultNotifications(String snsTopicArn, List<String> backupVaultEvents) {+ this.snsTopicArn = snsTopicArn;+ setBackupVaultEvents(backupVaultEvents);+ }++ public String getSnsTopicArn() { return snsTopicArn; }+ public void setSnsTopicArn(String snsTopicArn) { this.snsTopicArn = snsTopicArn; }++ public List<String> getBackupVaultEvents() { return backupVaultEvents; }++ public void setBackupVaultEvents(List<String> backupVaultEvents) {+ this.backupVaultEvents = backupVaultEvents != null ? backupVaultEvents : new ArrayList<>();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/BackupVaultCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/BackupVaultCfnProvisioner.javaindex 08aca2e6c6..a23b81ac2e 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/BackupVaultCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/BackupVaultCfnProvisioner.java@@ -24,8 +24,13 @@ import java.util.UUID;** <p>The name is the physical id and createOnly, so an unnamed vault keeps its generated name across* updates instead of getting a second vault, and a rename is refused as a replacement. EncryptionKeyArn- * is createOnly too. BackupVaultTags update in place. AccessPolicy, Notifications and- * LockConfiguration have no counterpart in the emulated vault and are accepted without effect.+ * is createOnly too. BackupVaultTags update in place.+ *+ * <p>AccessPolicy, Notifications and LockConfiguration are still accepted without effect here,+ * but they are no longer without a counterpart: the API now implements all three, so a template+ * declaring one reports CREATE_COMPLETE with nothing attached, and a later Get of that+ * sub-resource answers as though it was never configured. Wiring them through is tracked+ * separately; until then this is a gap in the provisioner, not in the service.*/@ApplicationScopedpublic class BackupVaultCfnProvisioner implements CfnResourceProvisioner {diff --git a/src/test/java/io/github/hectorvent/floci/services/backup/BackupIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/backup/BackupIntegrationTest.javaindex 2f14c7593c..5698191832 100644--- a/src/test/java/io/github/hectorvent/floci/services/backup/BackupIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/backup/BackupIntegrationTest.java@@ -6,7 +6,11 @@ import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;+import java.time.Duration;+import java.util.Map;+import static io.restassured.RestAssured.given;+import static org.awaitility.Awaitility.await;import static org.hamcrest.Matchers.*;/**@@ -26,6 +30,30 @@ class BackupIntegrationTest {private static String jobId;private static String recoveryPointArn;+ /**+ * Blocks until a backup job reports {@code COMPLETED}.+ *+ * <p>A job finishes asynchronously, so the recovery point it produces is not readable the+ * instant PutBackupJob returns. Polling the state rather than sleeping a fixed span is what+ * keeps this honest on a slow runner: a sleep sized for this machine only means the job is+ * still RUNNING on a slower one, and the assertion that follows fails for a reason that has+ * nothing to do with the behaviour under test.+ */+ private static void awaitJobCompleted(String backupJobId) {+ await().atMost(Duration.ofSeconds(10))+ .pollInterval(Duration.ofMillis(25))+ .until(() -> {+ String state = given()+ .header("Authorization", AUTH)+ .when()+ .get("/backup-jobs/" + backupJobId)+ .then()+ .statusCode(200)+ .extract().path("State");+ return "COMPLETED".equals(state);+ });+ }+// ── Vault ──────────────────────────────────────────────────────────────────@Test@@ -300,8 +328,8 @@ class BackupIntegrationTest {@Test@Order(42)- void describeBackupJobCompleted() throws InterruptedException {- Thread.sleep(2000); // job-completion-delay-seconds=1 in test config+ void describeBackupJobCompleted() {+ awaitJobCompleted(jobId);given().header("Authorization", AUTH).when()@@ -552,4 +580,770 @@ class BackupIntegrationTest {.then().statusCode(404);}++ // ── Vault sub-resources: access policy, notifications, lock ────────────────+ //+ // These run on their own vault, at orders above every existing test, so that+ // configuring a policy here cannot change what the Order(14)/Order(15) tests above+ // observe. Those two assert the unconfigured case, which is still the right answer+ // for a vault nobody has configured -- the gap this section covers was that there+ // was no way to configure one.++ private static final String SUB_VAULT = "sub-resource-vault";+ private static final String POLICY =+ "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"AllowDescribe\","+ + "\"Effect\":\"Allow\",\"Principal\":{\"AWS\":\"*\"},"+ + "\"Action\":\"backup:DescribeBackupVault\",\"Resource\":\"*\"}]}";+ private static final String TOPIC = "arn:aws:sns:us-east-1:000000000000:backup-events";++ @Test+ @Order(100)+ void createSubResourceVault() {+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200).body("BackupVaultName", equalTo(SUB_VAULT));+ }++ @Test+ @Order(101)+ void anUnlockedVaultReportsLockedFalse() {+ // Locked is always present on a vault in AWS. A client cannot tell "not locked"+ // from "this emulator does not model locking" unless the member is there.+ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200)+ .body("Locked", equalTo(false))+ .body("$", not(hasKey("LockDate")));+ }++ @Test+ @Order(110)+ void putAccessPolicyThenReadItBack() {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"Policy\":\"" + POLICY.replace("\"", "\\\"") + "\"}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(200)+ .body("BackupVaultName", equalTo(SUB_VAULT))+ .body("BackupVaultArn", containsString("backup-vault:" + SUB_VAULT))+ .body("Policy", containsString("AllowDescribe"));+ }++ @Test+ @Order(111)+ void putAccessPolicyWithoutADocumentClearsTheStoredOne() {+ // Policy is documented "Required: No", so refusing a request that omits it fails a call+ // real AWS accepts. Order(110) put a policy on this vault, so the read-back below is+ // what proves the omission cleared it rather than simply finding nothing there.+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(400).body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(112)+ void accessPolicyOnAVaultThatDoesNotExistSaysSo() {+ // The distinction that matters: "no such vault" is a different answer from+ // "that vault has no policy", and a caller with a typo needs the first.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"Policy\":\"{}\"}")+ .when().put("/backup-vaults/no-such-vault/access-policy")+ .then().statusCode(404).body("message", containsString("no-such-vault"));+ }++ @Test+ @Order(113)+ void deleteAccessPolicyLeavesItUnconfigured() {+ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(400).body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(114)+ void deleteAccessPolicyIsIdempotent() {+ // Terraform destroys a configuration it has already destroyed on a re-run.+ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(204);+ }++ @Test+ @Order(115)+ void putAccessPolicyStillRejectsAnEmptyDocument() {+ // Present and empty is not the same as absent: an empty string is not a policy document,+ // so it stays an InvalidParameterValueException.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"Policy\":\"\"}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(400).body("__type", equalTo("InvalidParameterValueException"));+ }++ @Test+ @Order(120)+ void putNotificationsThenReadThemBack() {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\","+ + "\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\",\"RESTORE_JOB_FAILED\"]}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(200)+ .body("BackupVaultName", equalTo(SUB_VAULT))+ .body("SNSTopicArn", equalTo(TOPIC))+ .body("BackupVaultEvents", hasItems("BACKUP_JOB_COMPLETED", "RESTORE_JOB_FAILED"));+ }++ @Test+ @Order(121)+ void notificationsRejectAnEventAwsDoesNotDefine() {+ // Accepting a misspelt event and echoing it back would let a configuration real+ // AWS refuses pass against the emulator.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\","+ + "\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\",\"NOT_AN_EVENT\"]}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("NOT_AN_EVENT"));+ }++ @Test+ @Order(122)+ void notificationsRequireATopicAndAtLeastOneEvent() {+ // A missing required parameter is MissingParameterValueException, which the operation+ // lists in its Errors section; present-but-empty is InvalidParameterValueException. An+ // SDK maps __type to a typed exception, so collapsing the two hands the caller an error+ // other than the one the reference names for a missing parameter.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\"]}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(400)+ .body("__type", equalTo("MissingParameterValueException"))+ .body("message", containsString("SNSTopicArn"));++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\"}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(400)+ .body("__type", equalTo("MissingParameterValueException"))+ .body("message", containsString("BackupVaultEvents"));++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"\",\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\"]}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("SNSTopicArn"));++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\",\"BackupVaultEvents\":[]}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("BackupVaultEvents"));+ }++ @Test+ @Order(123)+ void deleteNotificationsLeavesThemUnconfigured() {+ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(400).body("__type", equalTo("ResourceNotFoundException"));+ }++ // ── Vault Lock ─────────────────────────────────────────────────────────────+ //+ // ChangeableForDays selects the mode, in the direction that reads backwards:+ // PRESENT means compliance (immutable on and after LockDate), ABSENT means+ // governance (no LockDate, removable at any time). An earlier revision of this+ // branch had them the wrong way round and these tests asserted the inversion, so+ // the suite could not catch it. Both directions are now pinned separately.++ @Test+ @Order(130)+ void aComplianceLockCarriesALockDateAndIsVisibleOnTheVault() {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":7,\"MaxRetentionDays\":30,\"ChangeableForDays\":3}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200)+ .body("Locked", equalTo(true))+ .body("MinRetentionDays", equalTo(7))+ .body("MaxRetentionDays", equalTo(30))+ .body("LockDate", notNullValue());+ }++ @Test+ @Order(131)+ void aComplianceLockCanBeRemovedBeforeItsLockDate() {+ // "Before the lock date, you can delete Vault Lock from the vault using+ // DeleteBackupVaultLockConfiguration." The vault above was locked seconds ago+ // with a three-day cooling-off period, so it is inside that window.+ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200)+ .body("Locked", equalTo(false))+ .body("$", not(hasKey("LockDate")))+ .body("$", not(hasKey("MinRetentionDays")));+ }++ @Test+ @Order(132)+ void aGovernanceLockHasNoLockDateAndIsAlwaysRemovable() {+ // No ChangeableForDays: "If this parameter is not specified, you can delete+ // Vault Lock from the vault ... at any time."+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":7,\"MaxRetentionDays\":30}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200)+ .body("Locked", equalTo(true))+ .body("$", not(hasKey("LockDate")));++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200).body("Locked", equalTo(false));+ }++ @Test+ @Order(133)+ void aGovernanceLockCanBeReconfiguredInPlace() {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":7}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock").then().statusCode(204);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":14,\"MaxRetentionDays\":100}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200)+ .body("MinRetentionDays", equalTo(14))+ .body("MaxRetentionDays", equalTo(100));++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/vault-lock").then().statusCode(204);+ }++ @Test+ @Order(134)+ void lockRejectsAMaximumBelowTheMinimum() {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":30,\"MaxRetentionDays\":7,\"ChangeableForDays\":3}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(400).body("__type", equalTo("InvalidParameterValueException"));+ }++ @Test+ @Order(135)+ void lockRejectsACoolingOffPeriodBelowThreeDays() {+ // "AWS Backup enforces a 72-hour cooling-off period ... you must set+ // ChangeableForDays to 3 or greater."+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":7,\"ChangeableForDays\":2}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("ChangeableForDays"));+ }++ @Test+ @Order(136)+ void lockRejectsRetentionPeriodsBelowOneDay() {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":0}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(400).body("__type", equalTo("InvalidParameterValueException"));++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MaxRetentionDays\":0}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(400).body("__type", equalTo("InvalidParameterValueException"));+ }++ @Test+ @Order(140)+ void lockRejectsANonIntegralRetention() {+ // asLong() would have coerced each of these instead of refusing: 1.5 truncates+ // to 1, true becomes 1, "7" parses to 7. AWS rejects a non-integral value for a+ // long-typed member, so a coercing emulator lets a request AWS refuses succeed+ // against a number the caller never sent.+ // 18446744073709551623 is 2^64 + 7, the case isIntegralNumber() alone lets through:+ // longValue() keeps the low 64 bits, so it wraps to 7, a value the retention checks+ // are happy with. Only canConvertToLong() refuses it, and only a value that lands+ // INSIDE the valid range tests that guard: an out-of-range truncation is caught by+ // the range check instead, leaving the guard free to be deleted unnoticed.+ for (String bad : new String[] {"1.5", "true", "\"7\"", "18446744073709551623"}) {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":" + bad + "}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("MinRetentionDays"));+ }+ }++ @Test+ @Order(137)+ void anEmptyVaultCanBeDeletedWhileLocked() {+ // A lock protects the recovery points, not the vault shell: AWS deletes an empty+ // vault even under a lock. An earlier revision refused this, which would also+ // have broken CloudFormation stack teardown.+ String vault = "locked-but-empty";+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":7,\"ChangeableForDays\":3}")+ .when().put("/backup-vaults/" + vault + "/vault-lock").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + vault).then().statusCode(204);+ }++ @Test+ @Order(138)+ void accessPolicyAcceptsAnObjectBodyAsWellAsAString() {+ // Terraform and the console send Policy as a JSON string; an object is accepted+ // and re-serialised rather than refused, since refusing would be stricter than+ // AWS for no benefit.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"Policy\":{\"Version\":\"2012-10-17\",\"Statement\":[]}}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(200).body("Policy", containsString("2012-10-17"));++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/access-policy").then().statusCode(204);+ }++ @Test+ @Order(139)+ void notificationsAreDroppedWithTheVaultToo() {+ // The policy case is covered at Order(141); this is the other sub-resource+ // store, which has its own delete call and could be forgotten independently.+ String vault = "recycled-notify";+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\","+ + "\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\"]}")+ .when().put("/backup-vaults/" + vault + "/notification-configuration")+ .then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + vault).then().statusCode(204);++ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + vault + "/notification-configuration")+ .then().statusCode(400).body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(141)+ void subResourcesDoNotOutliveTheirVault() {+ // A fresh vault, configured, deleted and recreated under the same name must not+ // inherit the old policy: the sub-resource stores are keyed by vault name.+ String vault = "recycled-vault";+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"Policy\":\"{}\"}")+ .when().put("/backup-vaults/" + vault + "/access-policy").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + vault).then().statusCode(204);++ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + vault + "/access-policy")+ .then().statusCode(400).body("__type", equalTo("ResourceNotFoundException"));+ }+ @Test+ @Order(142)+ void lockRejectsADayValueAboveTheDocumentedCeiling() {+ // The ceiling is documented per field, not once for all three: MaxRetentionDays, "The+ // longest maximum retention period you can specify is 36500 days", and ChangeableForDays,+ // "The maximum value you can specify is 36,500 days". Without it a Terraform+ // configuration with changeable_for_days = 40000 applies here and fails on real AWS,+ // which is the exact divergence this corpus exists to find.+ for (String field : new String[] {"MaxRetentionDays", "ChangeableForDays"}) {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"" + field + "\":40000}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString(field));+ }++ // MinRetentionDays is the exception: the reference gives it a floor, "The shortest+ // minimum retention period you can specify is 1 day", and no maximum at all. Refusing+ // 40000 here would be stricter than the reference, which risks the same divergence+ // pointing the other way.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":40000}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + SUB_VAULT)+ .then().statusCode(200).body("MinRetentionDays", equalTo(40000));++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + SUB_VAULT + "/vault-lock").then().statusCode(204);+ }++ @Test+ @Order(143)+ void lockRejectsLongMaxDaysWithA400RatherThanOverflowingTo500() {+ // Long.MAX_VALUE is a perfectly good long, so it survives the integral check and used to+ // reach Instant.plus, which throws ArithmeticException: long overflow. The only exception+ // mapper handles AwsException, so that escaped as a 500. The ceiling makes the overflow+ // unreachable rather than catching it afterwards; this pins the status code, because a+ // 500 here would be indistinguishable from the emulator simply falling over.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"ChangeableForDays\":9223372036854775807}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/vault-lock")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("ChangeableForDays"));+ }++ // ── What the lock enforces, and the validation that stops a bad value looking good ──+ //+ // Every test below covers a finding Greptile raised on the fork PR that our own review+ // had not: four of its six findings were one shape, state written that nothing consumed.+ // A round-trip test cannot see that shape -- the write works and the read works -- so+ // these assert on the BEHAVIOUR the stored value is supposed to change, which is the only+ // place the difference shows.++ private static final String LOCK_VAULT = "lock-enforcement-vault";++ @Test+ @Order(150)+ void aLockedVaultRefusesToDeleteARecoveryPointInsideMinRetention() {+ // The finding: PutBackupVaultLockConfiguration succeeded, DescribeBackupVault+ // reported Locked, and every recovery point the lock was supposed to protect deleted+ // exactly as before, because deleteRecoveryPoint read no lock field. The lock was+ // decorative. Note the shape of the old test suite: it could lock a vault and read the+ // lock back, and both passed, while this was true.+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + LOCK_VAULT).then().statusCode(200);++ String jid = given().header("Authorization", AUTH).contentType("application/json")+ .body("""+ {+ "BackupVaultName": "%s",+ "ResourceArn": "%s",+ "IamRoleArn": "%s"+ }+ """.formatted(LOCK_VAULT, RESOURCE_ARN, IAM_ROLE))+ .when().put("/backup-jobs").then().statusCode(200).extract().path("BackupJobId");++ awaitJobCompleted(jid);+ String rpArn = given().header("Authorization", AUTH)+ .when().get("/backup-jobs/" + jid).then().statusCode(200)+ .body("State", equalTo("COMPLETED"))+ .extract().path("RecoveryPointArn");++ // Governance mode: no ChangeableForDays. It still enforces retention here, because+ // Floci does not model backup:DisableGovernanceRetention and so cannot grant the+ // override that would let a privileged caller through on real AWS.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":30,\"MaxRetentionDays\":365}")+ .when().put("/backup-vaults/" + LOCK_VAULT + "/vault-lock").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + LOCK_VAULT + "/recovery-points/" + rpArn)+ .then().statusCode(400)+ .body("__type", equalTo("InvalidRequestException"))+ .body("message", containsString("30"));++ // And the vault is still non-empty, so the refusal really did refuse rather than+ // reporting an error after deleting. A 400 with the row gone would be worse than+ // no check at all.+ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + LOCK_VAULT)+ .then().statusCode(200).body("NumberOfRecoveryPoints", equalTo(1));+ }++ @Test+ @Order(151)+ void aLockWithNoMinimumRetentionDoesNotBlockDeletion() {+ // The other direction, and the one that makes the test above worth trusting. A guard+ // measured only where it fires is indistinguishable from one that refuses everything,+ // and a lock that blocked every deletion would fail a Terraform destroy outright.+ // MinRetentionDays is optional, so a lock carrying none protects nothing by retention.+ String vault = "lock-no-minimum";+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ String jid = given().header("Authorization", AUTH).contentType("application/json")+ .body("""+ {+ "BackupVaultName": "%s",+ "ResourceArn": "%s",+ "IamRoleArn": "%s"+ }+ """.formatted(vault, RESOURCE_ARN, IAM_ROLE))+ .when().put("/backup-jobs").then().statusCode(200).extract().path("BackupJobId");++ awaitJobCompleted(jid);+ String rpArn = given().header("Authorization", AUTH)+ .when().get("/backup-jobs/" + jid).then().extract().path("RecoveryPointArn");++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MaxRetentionDays\":365}")+ .when().put("/backup-vaults/" + vault + "/vault-lock").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + vault + "/recovery-points/" + rpArn)+ .then().statusCode(204);+ }++ @Test+ @Order(152)+ void aBackupJobIsRefusedWhenItsLifecycleFallsOutsideTheLock() {+ // "Backup jobs will fail if the lifecycle policy of the backup plan is outside the+ // vault lock's retention period." Until this existed, getMaxRetentionDays had ZERO+ // readers anywhere in the tree: the ceiling was accepted, stored, and reported by+ // DescribeBackupVault while bounding nothing. A Terraform configuration pairing a lock+ // with a shorter plan lifecycle applied cleanly here and failed its first real backup.+ // LOCK_VAULT is locked at [30, 365] by the test above.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("""+ {+ "BackupVaultName": "%s",+ "ResourceArn": "%s",+ "IamRoleArn": "%s",+ "Lifecycle": {"DeleteAfterDays": 7}+ }+ """.formatted(LOCK_VAULT, RESOURCE_ARN, IAM_ROLE))+ .when().put("/backup-jobs")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("minimum retention"));++ given().header("Authorization", AUTH).contentType("application/json")+ .body("""+ {+ "BackupVaultName": "%s",+ "ResourceArn": "%s",+ "IamRoleArn": "%s",+ "Lifecycle": {"DeleteAfterDays": 4000}+ }+ """.formatted(LOCK_VAULT, RESOURCE_ARN, IAM_ROLE))+ .when().put("/backup-jobs")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("maximum retention"));++ // Omitting the lifecycle entirely is refused too, and this one is worth spelling out+ // because the first version of the fix got it backwards and waved it through, on the+ // reasoning that indefinite retention cannot exceed a maximum. Retaining forever is the+ // LARGEST retention there is, so it exceeds every finite maximum: omitting the member+ // was a one-line bypass of the ceiling the lock exists to impose.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("""+ {+ "BackupVaultName": "%s",+ "ResourceArn": "%s",+ "IamRoleArn": "%s"+ }+ """.formatted(LOCK_VAULT, RESOURCE_ARN, IAM_ROLE))+ .when().put("/backup-jobs")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("DeleteAfterDays is required"));++ // Inside the window: accepted. The guard has to let a valid job through, or a locked+ // vault could never be backed up at all.+ given().header("Authorization", AUTH).contentType("application/json")+ .body("""+ {+ "BackupVaultName": "%s",+ "ResourceArn": "%s",+ "IamRoleArn": "%s",+ "Lifecycle": {"DeleteAfterDays": 90}+ }+ """.formatted(LOCK_VAULT, RESOURCE_ARN, IAM_ROLE))+ .when().put("/backup-jobs").then().statusCode(200);+ }++ @Test+ @Order(156)+ void aLockWithOnlyAMinimumStillAcceptsAJobWithNoLifecycle() {+ // The other side of the rule above, and the reason it is scoped to a MAXIMUM. A floor is+ // satisfied by indefinite retention, so refusing an absent lifecycle here would refuse a+ // request AWS accepts -- the divergence this emulator exists to remove. lock-no-minimum+ // carries MaxRetentionDays only, so this needs its own vault with the inverse.+ String vault = "lock-only-minimum";+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"MinRetentionDays\":30}")+ .when().put("/backup-vaults/" + vault + "/vault-lock").then().statusCode(204);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("""+ {+ "BackupVaultName": "%s",+ "ResourceArn": "%s",+ "IamRoleArn": "%s"+ }+ """.formatted(vault, RESOURCE_ARN, IAM_ROLE))+ .when().put("/backup-jobs").then().statusCode(200);+ }++ @Test+ @Order(157)+ void subResourcesAreKeyedPerVaultIncarnationRatherThanPerName() {+ // Why the keying matters rather than what it does: the stores used to be keyed by vault+ // name, which made one key shared between every vault that ever held the name. A record+ // surviving a delete grafted an old policy onto the next vault, and cleanup for a deleted+ // vault could erase a live configuration belonging to the vault that had replaced it.+ //+ // Honest about what this test can and cannot show: it pins the sequential behaviour, and+ // the sequential behaviour was already correct once deleteBackupVault removed the+ // sub-resources. The races the keying removes need two requests interleaved and are not+ // reachable from a single-threaded HTTP test. What is reachable, and is asserted here, is+ // that a vault carries only the configuration applied to IT.+ String vault = "incarnation-keyed-vault";+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\",\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\"]}")+ .when().put("/backup-vaults/" + vault + "/notification-configuration").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + vault + "/notification-configuration")+ .then().statusCode(200).body("SNSTopicArn", equalTo(TOPIC));++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + vault).then().statusCode(204);++ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + vault + "/notification-configuration")+ .then().statusCode(400).body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ @Order(153)+ void anUnparseablePolicyIsRefusedRatherThanStored() {+ // The finding: the blank check accepted any other string, so `not a policy` was stored,+ // PUT reported success and GET returned it unchanged. An invalid policy looked applied.+ // That is the emulator being MORE permissive than AWS, the one direction that costs a+ // user real time: the configuration passes locally and the deploy is where they learn.+ for (String bad : new String[] {"not a policy", "{\"Version\":", "[]", "42", "\"a string\""}) {+ given().header("Authorization", AUTH).contentType("application/json")+ .body(Map.of("Policy", bad))+ .when().put("/backup-vaults/" + SUB_VAULT + "/access-policy")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"));+ }+ // A real document still works, so the check refuses only what it should.+ given().header("Authorization", AUTH).contentType("application/json")+ .body(Map.of("Policy", POLICY))+ .when().put("/backup-vaults/" + SUB_VAULT + "/access-policy").then().statusCode(204);+ }++ @Test+ @Order(154)+ void aNonStringTopicArnIsRefusedRatherThanCoerced() {+ // asText() turns the JSON number 123 into the nonblank string "123", which passed every+ // present-and-nonblank check and was stored as the topic: an unusable configuration+ // that reads back as valid. Same coercion Greptile found in longOrNull, other direction.+ for (String bad : new String[] {"123", "true", "{}", "[]"}) {+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":" + bad + ",\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\"]}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(400)+ .body("__type", equalTo("InvalidParameterValueException"))+ .body("message", containsString("SNSTopicArn"));+ }+ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\",\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\"]}")+ .when().put("/backup-vaults/" + SUB_VAULT + "/notification-configuration")+ .then().statusCode(204);+ }++ @Test+ @Order(155)+ void aRecreatedVaultDoesNotInheritTheDeletedVaultsConfiguration() {+ // The stores are keyed by vault name and there is no transaction across the three, so+ // a leftover record grafts an old policy onto a new vault of the same name.+ //+ // Measured, and stated because the measurement is unflattering: this test still PASSES+ // with the create-side sweep removed, because the sequential path is already covered by+ // the deletes in deleteBackupVault. What it pins is the sequential guarantee, not the+ // fix. The concurrent interleaving the fix exists for -- a Put landing between the+ // sub-resource deletes and the vault delete -- is not reachable from a single-threaded+ // HTTP test, so no test here pins the sweep. Keeping it is a judgement that the race is+ // real rather than a claim that it is covered.+ String vault = "recycled-vault-name";+ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH).contentType("application/json")+ .body("{\"SNSTopicArn\":\"" + TOPIC + "\",\"BackupVaultEvents\":[\"BACKUP_JOB_COMPLETED\"]}")+ .when().put("/backup-vaults/" + vault + "/notification-configuration").then().statusCode(204);++ given().header("Authorization", AUTH)+ .when().delete("/backup-vaults/" + vault).then().statusCode(204);++ given().header("Authorization", AUTH).contentType("application/json").body("{}")+ .when().put("/backup-vaults/" + vault).then().statusCode(200);++ given().header("Authorization", AUTH)+ .when().get("/backup-vaults/" + vault + "/notification-configuration")+ .then().statusCode(400).body("__type", equalTo("ResourceNotFoundException"));+ }+}