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.xmlindex 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.javaindex 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() != nulldiff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsManagedSecretIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsManagedSecretIntegrationTest.javanew file mode 100644index 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.javaindex 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();+ }+@Testvoid 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");}