Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(rds): report the default managed secret key (#5420)

David Phillips23e6fce6ef3a
diff --git a/pom.xml b/pom.xml
index ab3ee05c58..1eb1d9472b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -20,6 +20,7 @@
<apicurio.version>2.6.13.Final</apicurio.version>
<everit.json.schema.version>1.14.6</everit.json.schema.version>
<wire.version>6.4.7</wire.version>
+ <aws.sdk.version>2.55.11</aws.sdk.version>
</properties>
<dependencyManagement>
@@ -328,7 +329,7 @@
<dependency>
<groupId>software.amazon.awssdk</groupId>
<artifactId>elasticache</artifactId>
- <version>2.55.11</version>
+ <version>${aws.sdk.version}</version>
<scope>test</scope>
</dependency>
<dependency>
@@ -346,6 +347,18 @@
<artifactId>rest-assured</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>software.amazon.awssdk</groupId>
+ <artifactId>rds</artifactId>
+ <version>${aws.sdk.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>software.amazon.awssdk</groupId>
+ <artifactId>url-connection-client</artifactId>
+ <version>${aws.sdk.version}</version>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.awaitility</groupId>
<artifactId>awaitility</artifactId>
diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java
index c69241a7fe..2eedccc686 100644
--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java
@@ -11,6 +11,7 @@ import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.common.AwsRegions;
import io.github.hectorvent.floci.core.common.BackupWindows;
import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.common.RequestScopes;
import io.github.hectorvent.floci.core.common.Resettable;
import io.github.hectorvent.floci.core.common.docker.ContainerLiveness;
import io.github.hectorvent.floci.core.common.docker.ContainerStorageHelper;
@@ -724,6 +725,8 @@ public class RdsService implements Resettable, ResourceProvider {
if (manageMasterUserPassword && (masterPassword == null || masterPassword.isBlank())) {
masterPassword = generatedMasterPassword();
}
+ String effectiveSecretKmsKeyId = manageMasterUserPassword
+ ? resolveManagedSecretKmsKeyId(masterUserSecretKmsKeyId, effectiveRegion) : null;
// Always reserve a unique port (even in mock) so endpoints stay distinct and usedPorts
// is consistent; mock mode only skips starting the container and auth proxy.
int proxyPort = reserveProxyPort(requestedPort);
@@ -826,7 +829,7 @@ public class RdsService implements Resettable, ResourceProvider {
instance.setDbiResourceId(dbiResourceId);
instance.setDbInstanceArn(dbInstanceArn);
if (manageMasterUserPassword) {
- attachManagedMasterUserSecret(instance, effectiveRegion, masterUserSecretKmsKeyId);
+ attachManagedMasterUserSecret(instance, effectiveRegion, masterUserSecretKmsKeyId, effectiveSecretKmsKeyId);
}
String accountId = accountIdFromArn(instance.getDbInstanceArn());
@@ -2470,6 +2473,7 @@ public class RdsService implements Resettable, ResourceProvider {
// The secret's ARN names its own account and region, neither of which a
// startup backfill has a request context to infer.
secretsManagerService.markOwnedByService(secretArn, MANAGED_SECRET_OWNING_SERVICE);
+ backfillManagedSecretKey(instance, regionFromArn(instance.getDbInstanceArn()));
} catch (RuntimeException e) {
LOG.debugv(e, "Could not mark master user secret {0} as service-managed", secretArn);
}
@@ -2481,6 +2485,7 @@ public class RdsService implements Resettable, ResourceProvider {
}
try {
secretsManagerService.markOwnedByService(secretArn, MANAGED_SECRET_OWNING_SERVICE);
+ backfillManagedSecretKey(cluster, regionFromArn(cluster.getDbClusterArn()));
} catch (RuntimeException e) {
LOG.debugv(e, "Could not mark master user secret {0} as service-managed", secretArn);
}
@@ -2531,7 +2536,55 @@ public class RdsService implements Resettable, ResourceProvider {
}
}
- private void attachManagedMasterUserSecret(DbInstance instance, String region, String kmsKeyId) {
+ private void backfillManagedSecretKey(DbInstance instance, String region) {
+ if (instance.getMasterUserSecretArn() != null && instance.getMasterUserSecretKmsKeyId() == null) {
+ String keyId = recoverManagedSecretKey(instance.getMasterUserSecretArn(), region);
+ if (keyId != null) {
+ instance.setMasterUserSecretKmsKeyId(keyId);
+ putInstanceForScope(accountIdFromArn(instance.getDbInstanceArn()), region,
+ instance.getDbInstanceIdentifier(), instance);
+ }
+ }
+ }
+
+ private void backfillManagedSecretKey(DbCluster cluster, String region) {
+ if (cluster.getMasterUserSecretArn() != null && cluster.getMasterUserSecretKmsKeyId() == null) {
+ String keyId = recoverManagedSecretKey(cluster.getMasterUserSecretArn(), region);
+ if (keyId != null) {
+ cluster.setMasterUserSecretKmsKeyId(keyId);
+ putClusterForScope(accountIdFromArn(cluster.getDbClusterArn()), region,
+ cluster.getDbClusterIdentifier(), cluster);
+ }
+ }
+ }
+
+ private String recoverManagedSecretKey(String secretArn, String region) {
+ if (secretsManagerService == null || kmsService == null) {
+ return null;
+ }
+ try {
+ Secret secret = secretsManagerService.describeSecret(secretArn, region);
+ String keyId = secret.getKmsKeyId();
+ return keyId != null ? keyId : RequestScopes.callAs(accountIdFromArn(secretArn), region,
+ () -> kmsService.describeKey("alias/aws/secretsmanager", region).getArn());
+ } catch (RuntimeException e) {
+ // Old metadata remains readable if its secret or key is temporarily unavailable.
+ LOG.debugv(e, "Could not recover the managed key for secret {0}", secretArn);
+ return null;
+ }
+ }
+
+ private String resolveManagedSecretKmsKeyId(String kmsKeyId, String region) {
+ if (secretsManagerService == null) {
+ throw new AwsException("InvalidParameterCombination",
+ "ManageMasterUserPassword requires Secrets Manager support.", 400);
+ }
+ return kmsKeyId != null ? kmsKeyId
+ : kmsService.describeKey("alias/aws/secretsmanager", region).getArn();
+ }
+
+ private void attachManagedMasterUserSecret(DbInstance instance, String region, String kmsKeyId,
+ String effectiveKmsKeyId) {
if (secretsManagerService == null) {
throw new AwsException("InvalidParameterCombination",
"ManageMasterUserPassword requires Secrets Manager support.", 400);
@@ -2553,7 +2606,7 @@ public class RdsService implements Resettable, ResourceProvider {
region);
instance.setMasterUserSecretArn(secret.getArn());
instance.setMasterUserSecretStatus("active");
- instance.setMasterUserSecretKmsKeyId(kmsKeyId);
+ instance.setMasterUserSecretKmsKeyId(effectiveKmsKeyId);
}
private static String managedMasterSecretString(DbInstance instance) {
@@ -2573,7 +2626,8 @@ public class RdsService implements Resettable, ResourceProvider {
}
}
- private void attachManagedMasterUserSecret(DbCluster cluster, String region, String kmsKeyId) {
+ private void attachManagedMasterUserSecret(DbCluster cluster, String region, String kmsKeyId,
+ String effectiveKmsKeyId) {
if (secretsManagerService == null) {
throw new AwsException("InvalidParameterCombination",
"ManageMasterUserPassword requires Secrets Manager support.", 400);
@@ -2595,7 +2649,7 @@ public class RdsService implements Resettable, ResourceProvider {
region);
cluster.setMasterUserSecretArn(secret.getArn());
cluster.setMasterUserSecretStatus("active");
- cluster.setMasterUserSecretKmsKeyId(kmsKeyId);
+ cluster.setMasterUserSecretKmsKeyId(effectiveKmsKeyId);
}
/**
@@ -2666,7 +2720,8 @@ public class RdsService implements Resettable, ResourceProvider {
public DbInstance getDbInstance(String id, String region) {
String effectiveRegion = effectiveRegion(region);
return Optional.ofNullable(findInstanceForScope(
- currentAccountId(), effectiveRegion, id)).orElseThrow(() ->
+ currentAccountId(), effectiveRegion, id))
+ .orElseThrow(() ->
new AwsException("DBInstanceNotFound",
"DB instance " + id + " not found.", 404));
}
@@ -3972,6 +4027,8 @@ public class RdsService implements Resettable, ResourceProvider {
PlacementResolution placement = resolvePlacement(dbSubnetGroupName, availabilityZone, multiAz, effectiveRegion);
boolean mock = config.services().rds().mock();
+ String effectiveSecretKmsKeyId = manageMasterUserPassword
+ ? resolveManagedSecretKmsKeyId(masterUserSecretKmsKeyId, effectiveRegion) : null;
// Always reserve a unique port (even in mock) so endpoints stay distinct and usedPorts
// is consistent; mock mode only skips starting the container and auth proxy.
int proxyPort = reserveProxyPort(requestedPort);
@@ -4017,7 +4074,7 @@ public class RdsService implements Resettable, ResourceProvider {
cluster.setDbClusterArn(clusterArn);
if (manageMasterUserPassword) {
- attachManagedMasterUserSecret(cluster, effectiveRegion, masterUserSecretKmsKeyId);
+ attachManagedMasterUserSecret(cluster, effectiveRegion, masterUserSecretKmsKeyId, effectiveSecretKmsKeyId);
}
try {
@@ -4324,7 +4381,8 @@ public class RdsService implements Resettable, ResourceProvider {
public DbCluster getDbCluster(String id, String region) {
String effectiveRegion = effectiveRegion(region);
return Optional.ofNullable(findClusterForScope(
- currentAccountId(), effectiveRegion, id)).orElseThrow(() ->
+ currentAccountId(), effectiveRegion, id))
+ .orElseThrow(() ->
new AwsException("DBClusterNotFoundFault",
"DB cluster " + id + " not found.", 404));
}
@@ -4412,6 +4470,9 @@ public class RdsService implements Resettable, ResourceProvider {
effectiveAutoPauseSeconds = validateServerlessV2ScalingConfiguration(
effectiveMinCapacity, effectiveMaxCapacity, requestedOrExistingAutoPause);
}
+ String effectiveSecretKmsKeyId = Boolean.TRUE.equals(manageMasterUserPassword)
+ && cluster.getMasterUserSecretArn() == null
+ ? resolveManagedSecretKmsKeyId(masterUserSecretKmsKeyId, effectiveRegion) : null;
boolean passwordRotated = false;
if (newPassword != null && !newPassword.isBlank()) {
String oldPassword = cluster.getMasterPassword();
@@ -4435,7 +4496,7 @@ public class RdsService implements Resettable, ResourceProvider {
if (cluster.getMasterPassword() == null || cluster.getMasterPassword().isBlank()) {
cluster.setMasterPassword(generatedMasterPassword());
}
- attachManagedMasterUserSecret(cluster, effectiveRegion, masterUserSecretKmsKeyId);
+ attachManagedMasterUserSecret(cluster, effectiveRegion, masterUserSecretKmsKeyId, effectiveSecretKmsKeyId);
} else if (Boolean.FALSE.equals(manageMasterUserPassword) && cluster.getMasterUserSecretArn() != null) {
detachManagedMasterUserSecret(cluster, effectiveRegion);
} else if (cluster.getMasterUserSecretArn() != null
diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsManagedSecretIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsManagedSecretIntegrationTest.java
new file mode 100644
index 0000000000..769cbeaa3c
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsManagedSecretIntegrationTest.java
@@ -0,0 +1,86 @@
+package io.github.hectorvent.floci.services.rds;
+
+import io.github.hectorvent.floci.core.common.RequestScopes;
+import io.github.hectorvent.floci.services.kms.KmsService;
+import io.github.hectorvent.floci.testing.RdsMockProfile;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.TestProfile;
+import io.restassured.RestAssured;
+import jakarta.inject.Inject;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.http.urlconnection.UrlConnectionHttpClient;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.rds.RdsClient;
+import software.amazon.awssdk.services.rds.model.DBCluster;
+import software.amazon.awssdk.services.rds.model.DBInstance;
+
+import java.net.URI;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@QuarkusTest
+@TestProfile(RdsMockProfile.class)
+class RdsManagedSecretIntegrationTest {
+
+ @Inject
+ KmsService kmsService;
+
+ @Inject
+ RdsService rdsService;
+
+ @ParameterizedTest
+ @CsvSource({"us-east-1,000000000000", "cn-north-1,000000000000",
+ "us-east-1,222222222222", "cn-north-1,222222222222"})
+ void sdkReportsTheActualDefaultManagedKeyForInstancesAndClusters(String region, String account) {
+ String id = "managed-key-" + UUID.randomUUID().toString().substring(0, 8);
+ try (RdsClient rds = RdsClient.builder()
+ .endpointOverride(URI.create("http://localhost:" + RestAssured.port))
+ .httpClientBuilder(UrlConnectionHttpClient.builder())
+ .region(Region.of(region))
+ .credentialsProvider(StaticCredentialsProvider.create(
+ AwsBasicCredentials.create(account, "test-secret-key")))
+ .build()) {
+ DBInstance instance = rds.createDBInstance(request -> request
+ .dbInstanceIdentifier(id)
+ .dbInstanceClass("db.t4g.small")
+ .engine("postgres")
+ .engineVersion("16.14")
+ .masterUsername("admin")
+ .allocatedStorage(20)
+ .manageMasterUserPassword(true)).dbInstance();
+ try {
+ String keyArn = RequestScopes.callAs(account, region,
+ () -> kmsService.describeKey("alias/aws/secretsmanager", region).getArn());
+ assertEquals(keyArn, instance.masterUserSecret().kmsKeyId());
+ RequestScopes.runAs(account, region,
+ () -> rdsService.getDbInstance(id, region).setMasterUserSecretKmsKeyId(null));
+ rdsService.backfillManagedSecretOwnership();
+ assertEquals(keyArn, rds.describeDBInstances(request -> request.dbInstanceIdentifier(id))
+ .dbInstances().getFirst().masterUserSecret().kmsKeyId());
+
+ DBCluster cluster = rds.createDBCluster(request -> request
+ .dbClusterIdentifier(id)
+ .engine("aurora-postgresql")
+ .engineVersion("16.4")
+ .masterUsername("admin")
+ .manageMasterUserPassword(true)).dbCluster();
+ try {
+ assertEquals(keyArn, cluster.masterUserSecret().kmsKeyId());
+ RequestScopes.runAs(account, region,
+ () -> rdsService.getDbCluster(id, region).setMasterUserSecretKmsKeyId(null));
+ rdsService.backfillManagedSecretOwnership();
+ assertEquals(keyArn, rds.describeDBClusters(request -> request.dbClusterIdentifier(id))
+ .dbClusters().getFirst().masterUserSecret().kmsKeyId());
+ } finally {
+ rds.deleteDBCluster(request -> request.dbClusterIdentifier(id).skipFinalSnapshot(true));
+ }
+ } finally {
+ rds.deleteDBInstance(request -> request.dbInstanceIdentifier(id).skipFinalSnapshot(true));
+ }
+ }
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java
index ddaeb38dc3..0c8061b754 100644
--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java
@@ -147,6 +147,11 @@ class RdsServiceTest {
kmsService = mock(KmsService.class);
when(kmsService.describeKey(any(), any())).thenThrow(
new AwsException("NotFoundException", "Key not found", 404));
+ doAnswer(invocation -> {
+ KmsKey key = new KmsKey();
+ key.setArn("arn:aws:kms:" + invocation.getArgument(1) + ":123456789012:key/secrets-manager");
+ return key;
+ }).when(kmsService).describeKey(eq("alias/aws/secretsmanager"), any());
config = mock(EmulatorConfig.class);
EmulatorConfig.ServicesConfig servicesConfig = mock(EmulatorConfig.ServicesConfig.class);
rdsConfig = mock(EmulatorConfig.RdsServiceConfig.class);
@@ -1208,6 +1213,166 @@ class RdsServiceTest {
assertEquals(0, service.listDbInstances(null).size());
}
+ @ParameterizedTest
+ @CsvSource({"false,false", "false,true", "true,false", "true,true"})
+ void defaultManagedKeyFailureLeavesCreateRetryable(boolean cluster, boolean mock) {
+ when(config.services().rds().mock()).thenReturn(mock);
+ when(rdsConfig.proxyMaxPort()).thenReturn(7000);
+ doThrow(new AwsException("NotFoundException", "Key not found", 404))
+ .when(kmsService).describeKey("alias/aws/secretsmanager", "us-east-1");
+ SecretsManagerService secretsManager = mock(SecretsManagerService.class);
+ RdsService service = newService(containerManager, proxyManager,
+ new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), new InMemoryStorage<>(), secretsManager);
+ Runnable create = () -> {
+ if (cluster) {
+ service.createDbCluster("mydb", "aurora-postgresql", "16.3",
+ "admin", null, "dbname", false, null, null, null, false, "us-east-1",
+ null, null, null, true, null);
+ } else {
+ service.createDbInstance("mydb", "postgres", "13", "admin", null,
+ "dbname", "db.t3.micro", 20, true, null, null, null, true, null);
+ }
+ };
+ assertEquals("NotFoundException", assertThrows(AwsException.class, create::run).getErrorCode());
+ verifyNoInteractions(secretsManager, containerManager, proxyManager);
+ assertTrue(service.listDbInstances(null).isEmpty());
+ assertTrue(service.listDbClusters(null).isEmpty());
+
+ KmsKey key = new KmsKey();
+ key.setArn("arn:aws:kms:us-east-1:123456789012:key/secrets-manager");
+ doReturn(key).when(kmsService).describeKey("alias/aws/secretsmanager", "us-east-1");
+ Secret secret = new Secret();
+ secret.setArn("arn:aws:secretsmanager:us-east-1:123456789012:secret:rds!retry");
+ when(secretsManager.createSecret(any(), any(), eq(null), any(), eq(null), any(), eq("rds"), eq("us-east-1")))
+ .thenReturn(secret);
+ create.run();
+ assertEquals(7000, cluster ? service.getDbCluster("mydb").getProxyPort()
+ : service.getDbInstance("mydb").getProxyPort());
+ }
+
+ @Test
+ void defaultManagedKeyFailureDoesNotModifyCluster() {
+ rdsService = newService(containerManager, proxyManager,
+ new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), new InMemoryStorage<>(), mock(SecretsManagerService.class));
+ DbCluster cluster = rdsService.createDbCluster("cluster1", "postgres", "13",
+ "admin", "original-password", "dbname", false, null);
+ clearInvocations(containerManager, proxyManager);
+ doThrow(new AwsException("NotFoundException", "Key not found", 404))
+ .when(kmsService).describeKey("alias/aws/secretsmanager", "us-east-1");
+
+ assertEquals("NotFoundException", assertThrows(AwsException.class, () ->
+ rdsService.modifyDbCluster("cluster1", "changed-password", true,
+ null, null, null, true, null, "us-east-1")).getErrorCode());
+
+ assertEquals("original-password", cluster.getMasterPassword());
+ assertFalse(cluster.isIamDatabaseAuthenticationEnabled());
+ assertNull(cluster.getMasterUserSecretArn());
+ verifyNoInteractions(containerManager, proxyManager);
+ }
+
+ @ParameterizedTest
+ @CsvSource({"false,false,false", "false,true,false", "true,false,false", "true,true,false",
+ "false,false,true", "false,true,true", "true,false,true", "true,true,true"})
+ void startupRecoversLegacyManagedKeyMetadata(boolean cluster, boolean list, boolean customKey) {
+ regionResolver = new RegionResolver("cn-north-1", "222222222222");
+ when(config.services().rds().mock()).thenReturn(true);
+ SecretsManagerService secretsManager = mock(SecretsManagerService.class);
+ Secret secret = new Secret();
+ secret.setArn("arn:aws-cn:secretsmanager:cn-north-1:222222222222:secret:rds!legacy");
+ String expectedKey = "arn:aws-cn:kms:cn-north-1:222222222222:key/"
+ + (customKey ? "customer" : "secrets-manager");
+ secret.setKmsKeyId(customKey ? expectedKey : null);
+ KmsKey key = new KmsKey();
+ key.setArn(expectedKey);
+ doReturn(key).when(kmsService).describeKey("alias/aws/secretsmanager", "cn-north-1");
+ when(secretsManager.createSecret(any(), any(), eq(null), any(), eq("stored-key"), any(), eq("rds"), any()))
+ .thenReturn(secret);
+ RdsService service = newService(containerManager, proxyManager,
+ new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), new InMemoryStorage<>(), secretsManager);
+ DbInstance instance = null;
+ DbCluster databaseCluster = null;
+ if (cluster) {
+ databaseCluster = service.createDbCluster("legacy", "aurora-postgresql", "16.3",
+ "admin", null, "dbname", false, null, null, null, false, "cn-north-1",
+ null, null, null, true, "stored-key");
+ } else {
+ instance = service.createDbInstance("legacy", "postgres", "13", "admin", null,
+ "dbname", "db.t3.micro", 20, true, null, null, null, true, "stored-key");
+ }
+ clearInvocations(secretsManager, kmsService);
+ service.backfillManagedSecretOwnership();
+ clearInvocations(secretsManager);
+ assertEquals("stored-key", readManagedSecretKey(service, cluster, list));
+ verifyNoInteractions(secretsManager, kmsService);
+ if (cluster) {
+ databaseCluster.setMasterUserSecretKmsKeyId(null);
+ } else {
+ instance.setMasterUserSecretKmsKeyId(null);
+ }
+ doThrow(new AwsException("ResourceNotFoundException", "Temporarily unavailable", 400))
+ .when(secretsManager).describeSecret(secret.getArn(), "cn-north-1");
+ service.backfillManagedSecretOwnership();
+ assertNull(readManagedSecretKey(service, cluster, list));
+ assertNull(cluster ? databaseCluster.getMasterUserSecretKmsKeyId() : instance.getMasterUserSecretKmsKeyId());
+ doReturn(secret).when(secretsManager).describeSecret(secret.getArn(), "cn-north-1");
+ clearInvocations(secretsManager, kmsService);
+
+ service.backfillManagedSecretOwnership();
+ assertEquals(expectedKey, readManagedSecretKey(service, cluster, list));
+ assertEquals(expectedKey, readManagedSecretKey(service, cluster, !list));
+ assertEquals(secret.getArn(), cluster ? databaseCluster.getMasterUserSecretArn() : instance.getMasterUserSecretArn());
+ verify(secretsManager).describeSecret(secret.getArn(), "cn-north-1");
+ if (customKey) {
+ verifyNoInteractions(kmsService);
+ } else {
+ verify(kmsService).describeKey("alias/aws/secretsmanager", "cn-north-1");
+ }
+ }
+
+ @ParameterizedTest
+ @CsvSource({"false,false", "false,true", "true,false", "true,true"})
+ void managedSecretReadsDoNotWaitForProvisioning(boolean cluster, boolean list) throws Exception {
+ when(config.services().rds().mock()).thenReturn(true);
+ SecretsManagerService secretsManager = mock(SecretsManagerService.class);
+ Secret secret = new Secret();
+ secret.setArn("arn:aws:secretsmanager:us-east-1:123456789012:secret:rds!legacy");
+ when(secretsManager.createSecret(any(), any(), eq(null), any(), eq("stored-key"), any(), eq("rds"), any()))
+ .thenReturn(secret);
+ RdsService service = newService(containerManager, proxyManager,
+ AccountAwareStorageBackend.inMemory("123456789012"),
+ AccountAwareStorageBackend.inMemory("123456789012"),
+ new InMemoryStorage<>(), new InMemoryStorage<>(), secretsManager);
+ if (cluster) {
+ service.createDbCluster("legacy", "aurora-postgresql", "16.3",
+ "admin", null, "dbname", false, null, null, null, false, "us-east-1",
+ null, null, null, true, "stored-key").setMasterUserSecretKmsKeyId(null);
+ } else {
+ service.createDbInstance("legacy", "postgres", "13", "admin", null,
+ "dbname", "db.t3.micro", 20, true, null, null, null, true, "stored-key")
+ .setMasterUserSecretKmsKeyId(null);
+ }
+ clearInvocations(secretsManager, kmsService);
+ try (ExecutorService executor = Executors.newSingleThreadExecutor()) {
+ synchronized (service) {
+ Future<String> read = executor.submit(() -> readManagedSecretKey(service, cluster, list));
+ assertNull(read.get(5, TimeUnit.SECONDS));
+ }
+ }
+ verifyNoInteractions(secretsManager, kmsService);
+ }
+
+ private String readManagedSecretKey(RdsService service, boolean cluster, boolean list) {
+ if (cluster) {
+ return (list ? service.listDbClusters(null).iterator().next() : service.getDbCluster("legacy"))
+ .getMasterUserSecretKmsKeyId();
+ }
+ return (list ? service.listDbInstances(null).iterator().next() : service.getDbInstance("legacy"))
+ .getMasterUserSecretKmsKeyId();
+ }
+
@Test
void createDbClusterWithManagedMasterPasswordCreatesSecret() {
when(config.services().rds().mock()).thenReturn(true);
@@ -1405,12 +1570,21 @@ class RdsServiceTest {
new InMemoryStorage<>(), new InMemoryStorage<>(),
secretsManager);
- service.createDbInstance("mydb", "postgres", "13",
+ DbInstance instance = service.createDbInstance("mydb", "postgres", "13",
"admin", null, "dbname", "db.t3.micro",
20, true, null, null, null, true, null);
+ instance.setMasterUserSecretKmsKeyId(null);
+ KmsKey key = new KmsKey();
+ key.setArn("arn:aws:kms:us-east-1:123456789012:key/restored-default");
+ when(secretsManager.describeSecret(restoredArn, "us-east-1")).thenReturn(restored);
+ when(kmsService.describeKey("alias/aws/secretsmanager", "us-east-1"))
+ .thenReturn(key);
+
service.restorePersistedRuntime();
+ assertEquals(key.getArn(), service.getDbInstance("mydb").getMasterUserSecretKmsKeyId());
+
verify(secretsManager).markOwnedByService(restoredArn, "rds");
}