Light, fluffy, and always free - The AWS Local Emulator alternative
refactor(cloudformation): move the SecretsManager types into per-service provisioners (#3530)
Hector Venturad90cb23c239a
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.javaindex c66e93224c..655b962f1c 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java@@ -29,7 +29,6 @@ import io.github.hectorvent.floci.services.dynamodb.model.GlobalSecondaryIndex;import io.github.hectorvent.floci.services.dynamodb.model.KeySchemaElement;import io.github.hectorvent.floci.services.dynamodb.model.LocalSecondaryIndex;import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;-import io.github.hectorvent.floci.services.docdb.DocDbService;import io.github.hectorvent.floci.services.ecr.EcrService;import io.github.hectorvent.floci.services.ecr.model.Repository;import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;@@ -53,13 +52,6 @@ import io.github.hectorvent.floci.services.ec2.model.Tag;import io.github.hectorvent.floci.services.ec2.model.UserIdGroupPair;import io.github.hectorvent.floci.services.firehose.FirehoseService;import io.github.hectorvent.floci.services.firehose.model.DeliveryStreamDescription;-import io.github.hectorvent.floci.services.rds.RdsService;-import io.github.hectorvent.floci.services.rds.model.DbCluster;-import io.github.hectorvent.floci.services.rds.model.DbClusterParameterGroup;-import io.github.hectorvent.floci.services.rds.model.DbInstance;-import io.github.hectorvent.floci.services.rds.model.DbParameterGroup;-import io.github.hectorvent.floci.services.rds.model.DbProxyAuth;-import io.github.hectorvent.floci.services.rds.model.DbSubnetGroup;import io.github.hectorvent.floci.services.eks.EksService;import io.github.hectorvent.floci.services.eks.model.CreateClusterRequest;import io.github.hectorvent.floci.services.eks.model.Nodegroup;@@ -74,7 +66,6 @@ import io.github.hectorvent.floci.services.lambda.model.LambdaLayerVersion;import io.github.hectorvent.floci.services.pipes.PipesService;import io.github.hectorvent.floci.services.pipes.model.DesiredState;import io.github.hectorvent.floci.services.s3.S3Service;-import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;import io.github.hectorvent.floci.services.sns.SnsService;import io.github.hectorvent.floci.services.sqs.SqsService;import io.github.hectorvent.floci.services.ssm.SsmService;@@ -134,13 +125,9 @@ public class CloudFormationResourceProvisioner {private static final String NAME_MODE_GENERATED = "generated";private static final int GENERATED_NAME_SUFFIX_LENGTH = 12;private static final int STEP_FUNCTIONS_NAME_MAX_LENGTH = 80;- private static final String SECRET_TARGET_MANAGED_KEYS_ATTR = "__FlociSecretTargetManagedKeys";- private static final String SECRET_TARGET_OWNER_ATTR = "__FlociSecretTargetOwner";private static final String DDB_REPLICA_TABLE_NAME_ATTR = "TableName";private static final String DDB_REPLICA_REGION_ATTR = "__FlociDynamoDbReplicaRegion";private static final String DDB_REPLICA_SKIP_DELETION_ATTR = "__FlociDynamoDbReplicaSkipDeletion";- private static final List<String> SECRET_TARGET_CONNECTION_KEYS = List.of(- "engine", "host", "port", "dbname", "dbInstanceIdentifier", "dbClusterIdentifier");private static final int LAMBDA_DEFAULT_TIMEOUT_SECONDS = 3;private static final int LAMBDA_DEFAULT_MEMORY_MB = 128;private static final int LAMBDA_DEFAULT_EPHEMERAL_STORAGE_MB = 512;@@ -176,7 +163,6 @@ public class CloudFormationResourceProvisioner {"AWS::EKS::Nodegroup","AWS::IAM::ManagedPolicy","AWS::IAM::Policy",- "AWS::SecretsManager::SecretTargetAttachment","Custom::DynamoDBReplica");static final Set<String> LEGACY_SWITCH_TYPES = Set.of(@@ -209,8 +195,6 @@ public class CloudFormationResourceProvisioner {"AWS::Lambda::Function","AWS::Lambda::LayerVersion","AWS::Route53::RecordSet",- "AWS::SecretsManager::Secret",- "AWS::SecretsManager::SecretTargetAttachment","AWS::StepFunctions::StateMachine","Custom::DynamoDBReplica");@@ -228,7 +212,6 @@ public class CloudFormationResourceProvisioner {private final DynamoDbService dynamoDbService;private final LambdaService lambdaService;private final IamService iamService;- private final SecretsManagerService secretsManagerService;private final ApiGatewayService apiGatewayService;private final ApiGatewayV2Service apiGatewayV2Service;private final LambdaLayerService lambdaLayerService;@@ -237,10 +220,8 @@ public class CloudFormationResourceProvisioner {private final ContainerReachableEndpoint reachableEndpoint;private final StepFunctionsService stepFunctionsService;private final Ec2Service ec2Service;- private final RdsService rdsService;private final EksService eksService;private final AutoScalingService autoScalingService;- private final DocDbService docDbService;private final CloudFrontService cloudFrontService;// Item 15 decomposition: extracted per-service provisioners are consulted before the switch// below. As types migrate, their switch cases and provisionXxx methods are removed here; the@@ -254,7 +235,6 @@ public class CloudFormationResourceProvisioner {SnsService snsService, DynamoDbService dynamoDbService,LambdaService lambdaService, IamService iamService,SsmService ssmService, KmsService kmsService,- SecretsManagerService secretsManagerService,ApiGatewayService apiGatewayService,ApiGatewayV2Service apiGatewayV2Service,EcrService ecrService,@@ -265,14 +245,12 @@ public class CloudFormationResourceProvisioner {ContainerReachableEndpoint reachableEndpoint,StepFunctionsService stepFunctionsService,Ec2Service ec2Service,- RdsService rdsService,EksService eksService,CloudWatchLogsService logsService,KinesisService kinesisService,CloudWatchMetricsService cloudWatchMetricsService,AutoScalingService autoScalingService,FirehoseService firehoseService,- DocDbService docDbService,CloudFrontService cloudFrontService,CloudFormationResourceRegistry resourceRegistry,CfnDynamicReferences dynamicReferences,@@ -282,7 +260,6 @@ public class CloudFormationResourceProvisioner {this.dynamoDbService = dynamoDbService;this.lambdaService = lambdaService;this.iamService = iamService;- this.secretsManagerService = secretsManagerService;this.apiGatewayService = apiGatewayService;this.apiGatewayV2Service = apiGatewayV2Service;this.lambdaLayerService = lambdaLayerService;@@ -291,10 +268,8 @@ public class CloudFormationResourceProvisioner {this.reachableEndpoint = reachableEndpoint;this.stepFunctionsService = stepFunctionsService;this.ec2Service = ec2Service;- this.rdsService = rdsService;this.eksService = eksService;this.autoScalingService = autoScalingService;- this.docDbService = docDbService;this.cloudFrontService = cloudFrontService;this.resourceRegistry = resourceRegistry;this.dynamicReferences = dynamicReferences;@@ -351,9 +326,6 @@ public class CloudFormationResourceProvisioner {case "AWS::IAM::ManagedPolicy" ->provisionIamManagedPolicy(resource, properties, engine, accountId, stackName);case "AWS::IAM::InstanceProfile" -> provisionInstanceProfile(resource, properties, engine, accountId, stackName);- case "AWS::SecretsManager::Secret" -> provisionSecret(resource, properties, engine, region, accountId, stackName);- case "AWS::SecretsManager::SecretTargetAttachment" ->- provisionSecretTargetAttachment(resource, properties, engine, region, stackName);case "AWS::Route53::RecordSet" -> provisionRoute53RecordSet(resource, properties, engine);case "AWS::ApiGateway::RestApi" -> provisionApiGatewayRestApi(resource, properties, engine, region, accountId, stackName);case "AWS::ApiGateway::Resource" -> provisionApiGatewayResource(resource, properties, engine, region);@@ -539,10 +511,6 @@ public class CloudFormationResourceProvisioner {deleteCustomResource(resource, region);return;}- if ("AWS::SecretsManager::SecretTargetAttachment".equals(resourceType)) {- deleteSecretTargetAttachment(resource, region);- return;- }// Nodegroup deletion needs both the cluster name (from a Fn::GetAtt attribute) and the// nodegroup name (the physical id), which the type/physicalId delete path can't provide.if ("AWS::EKS::Nodegroup".equals(resourceType)) {@@ -611,11 +579,6 @@ public class CloudFormationResourceProvisioner {case "AWS::IAM::Policy" -> { }case "AWS::IAM::ManagedPolicy" -> deletePolicySafe(physicalId);case "AWS::IAM::InstanceProfile" -> iamService.deleteInstanceProfile(physicalId);- case "AWS::SecretsManager::Secret" -> deleteSecretSafe(physicalId, region);- case "AWS::SecretsManager::SecretTargetAttachment" -> throw new AwsException(- "ValidationError",- "SecretTargetAttachment deletion requires the StackResource metadata that records its managed fields.",- 400);// No bus context on the type/physicalId path (e.g. CREATE-rollback); targets the default bus.case "AWS::ApiGateway::RestApi" -> apiGatewayService.deleteRestApi(region, physicalId);case "AWS::ApiGatewayV2::Api" -> apiGatewayV2Service.deleteApi(region, physicalId);@@ -2484,433 +2447,6 @@ public class CloudFormationResourceProvisioner {// ── KMS ───────────────────────────────────────────────────────────────────- // ── Secrets Manager ───────────────────────────────────────────────────────-- private void provisionSecret(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,- String region, String accountId, String stackName) {- String name = resolveOptional(props, "Name", engine);- if (name == null || name.isBlank()) {- name = generatePhysicalName(stackName, r.getLogicalId(), 512, false);- }- String description = resolveOptional(props, "Description", engine);- String value = resolveSecretValue(props, engine);- var secret = secretsManagerService.createSecret(name, value, null, description, null, List.of(), region);- r.setPhysicalId(secret.getArn());- r.getAttributes().put("Arn", secret.getArn());- r.getAttributes().put("Name", name);- }-- /** Provisions an AWS-compatible Secrets Manager database target attachment. */- private void provisionSecretTargetAttachment(StackResource r, JsonNode props,- CloudFormationTemplateEngine engine, String region,- String stackName) {- String secretId = requireSecretTargetProperty(props, "SecretId", engine);- String targetId = requireSecretTargetProperty(props, "TargetId", engine);- String targetType = requireSecretTargetProperty(props, "TargetType", engine);- validateSecretTargetType(targetType);- SecretTargetConnection connection = resolveSecretTargetConnection(targetType, targetId);-- String previousSecretId = r.getPhysicalId();- String previousManagedKeys = r.getAttributes().get(SECRET_TARGET_MANAGED_KEYS_ATTR);- String attachmentOwner = r.getAttributes().getOrDefault(- SECRET_TARGET_OWNER_ATTR, stackName + "/" + r.getLogicalId());- String secretArn = secretsManagerService.describeSecret(secretId, region).getArn();- String previousSecretArn = canonicalExistingSecretArn(previousSecretId, secretArn, region);- boolean replacingSecret = previousSecretArn != null && !previousSecretArn.equals(secretArn);- boolean claimCreated = false;- boolean wroteNewSecret = false;- boolean detachedPreviousSecret = false;- ObjectNode currentSecretJson = null;- SecretTargetMutation previousDetach = null;-- try {- claimCreated = secretsManagerService.claimTargetAttachment(- secretArn, attachmentOwner, region);-- currentSecretJson = readSecretJsonObject(secretArn, region);- ObjectNode desiredSecretJson = currentSecretJson.deepCopy();- SECRET_TARGET_CONNECTION_KEYS.forEach(desiredSecretJson::remove);-- List<String> managedKeys = new ArrayList<>();- addSecretTargetConnection(desiredSecretJson, managedKeys, connection);-- if (replacingSecret) {- previousDetach = prepareSecretTargetDetach(previousSecretArn, previousManagedKeys, region);- }- if (!desiredSecretJson.equals(currentSecretJson)) {- secretsManagerService.putSecretValue(- secretArn, desiredSecretJson.toString(), null, null, region, null);- wroteNewSecret = true;- }- if (previousDetach != null) {- putSecretTargetMutation(previousDetach, region);- detachedPreviousSecret = true;- }- if (replacingSecret) {- secretsManagerService.releaseTargetAttachment(- previousSecretArn, attachmentOwner, region);- }-- r.setPhysicalId(secretArn);- r.getAttributes().remove("Arn");- r.getAttributes().put("Id", secretArn);- r.getAttributes().put(SECRET_TARGET_OWNER_ATTR, attachmentOwner);- r.getAttributes().put(SECRET_TARGET_MANAGED_KEYS_ATTR, String.join(",", managedKeys));- } catch (RuntimeException failure) {- if (detachedPreviousSecret && previousDetach != null) {- ObjectNode previousValue = previousDetach.originalValue();- attemptSecretTargetCleanup(failure, "restore previous secret " + previousSecretArn,- () -> secretsManagerService.putSecretValue(- previousSecretArn, previousValue.toString(),- null, null, region, null));- }- if (wroteNewSecret && currentSecretJson != null) {- ObjectNode originalValue = currentSecretJson;- attemptSecretTargetCleanup(failure, "restore new secret " + secretArn,- () -> secretsManagerService.putSecretValue(- secretArn, originalValue.toString(),- null, null, region, null));- }- if (claimCreated) {- attemptSecretTargetCleanup(failure, "release target attachment claim for " + secretArn,- () -> secretsManagerService.releaseTargetAttachment(- secretArn, attachmentOwner, region));- }- throw failure;- }- }-- private static void validateSecretTargetType(String targetType) {- if (!Set.of(- "AWS::RDS::DBInstance",- "AWS::RDS::DBCluster",- "AWS::DocDB::DBInstance",- "AWS::DocDB::DBCluster").contains(targetType)) {- throw new AwsException("ValidationError",- "SecretTargetAttachment TargetType " + targetType- + " is not supported by Floci; supported values are AWS::RDS::DBInstance,"- + " AWS::RDS::DBCluster, AWS::DocDB::DBInstance,"- + " and AWS::DocDB::DBCluster.", 400);- }- }-- private String canonicalExistingSecretArn(String secretId, String newSecretArn, String region) {- if (secretId == null || secretId.isBlank() || secretId.equals(newSecretArn)) {- return secretId;- }- try {- return secretsManagerService.describeSecret(secretId, region).getArn();- } catch (AwsException e) {- if ("ResourceNotFoundException".equals(e.getErrorCode())) {- return null;- }- throw e;- }- }-- private String requireSecretTargetProperty(JsonNode props, String name,- CloudFormationTemplateEngine engine) {- String value = resolveOptional(props, name, engine);- if (value == null || value.isBlank()) {- throw new AwsException("ValidationError",- "AWS::SecretsManager::SecretTargetAttachment requires " + name + ".", 400);- }- return value;- }-- private ObjectNode readSecretJsonObject(String secretId, String region) {- return tryReadSecretJsonObject(secretId, region)- .orElseThrow(CloudFormationResourceProvisioner::invalidSecretTargetValue);- }-- private Optional<ObjectNode> tryReadSecretJsonObject(String secretId, String region) {- String secretString = secretsManagerService- .getSecretValue(secretId, null, null, region)- .getSecretString();- if (secretString == null) {- return Optional.empty();- }- try {- JsonNode parsed = objectMapper.readTree(secretString);- if (parsed == null || !parsed.isObject()) {- return Optional.empty();- }- return Optional.of(((ObjectNode) parsed).deepCopy());- } catch (JsonProcessingException e) {- return Optional.empty();- }- }-- private static AwsException invalidSecretTargetValue() {- return new AwsException("ValidationError",- "SecretString for AWS::SecretsManager::SecretTargetAttachment must be a JSON object.", 400);- }-- private SecretTargetConnection resolveSecretTargetConnection(String targetType, String targetId) {- return switch (targetType) {- case "AWS::RDS::DBInstance" -> dbInstanceConnection(targetId);- case "AWS::RDS::DBCluster" -> dbClusterConnection(targetId);- case "AWS::DocDB::DBInstance" -> docDbInstanceConnection(targetId);- case "AWS::DocDB::DBCluster" -> docDbClusterConnection(targetId);- default -> throw new IllegalStateException("Validated target type was not handled: " + targetType);- };- }-- private SecretTargetConnection dbInstanceConnection(String targetId) {- var instance = rdsService.getDbInstance(targetId);- if (instance == null || instance.getEngine() == null || instance.getEndpoint() == null- || instance.getEndpoint().address() == null- || instance.getEndpoint().address().isBlank()- || instance.getEndpoint().port() <= 0- || instance.getDbInstanceIdentifier() == null- || instance.getDbInstanceIdentifier().isBlank()) {- throw incompleteSecretTarget(targetId);- }- return new SecretTargetConnection(- instance.getEngine().name().toLowerCase(Locale.ROOT),- instance.getEndpoint().address(),- instance.getEndpoint().port(),- instance.getDbName(),- "dbInstanceIdentifier",- instance.getDbInstanceIdentifier());- }-- private SecretTargetConnection dbClusterConnection(String targetId) {- var cluster = rdsService.getDbCluster(targetId);- if (cluster == null || cluster.getEngine() == null || cluster.getEndpoint() == null- || cluster.getEndpoint().address() == null- || cluster.getEndpoint().address().isBlank()- || cluster.getEndpoint().port() <= 0- || cluster.getDbClusterIdentifier() == null- || cluster.getDbClusterIdentifier().isBlank()) {- throw incompleteSecretTarget(targetId);- }- return new SecretTargetConnection(- cluster.getEngine().name().toLowerCase(Locale.ROOT),- cluster.getEndpoint().address(),- cluster.getEndpoint().port(),- cluster.getDatabaseName(),- "dbClusterIdentifier",- cluster.getDbClusterIdentifier());- }-- private SecretTargetConnection docDbInstanceConnection(String targetId) {- var instance = docDbService.getDbInstance(targetId);- if (instance == null || instance.getEndpoint() == null- || instance.getEndpoint().isBlank()- || instance.getPort() <= 0- || instance.getDbInstanceIdentifier() == null- || instance.getDbInstanceIdentifier().isBlank()) {- throw incompleteSecretTarget(targetId);- }- return new SecretTargetConnection(- "mongo",- instance.getEndpoint(),- instance.getPort(),- null,- "dbInstanceIdentifier",- instance.getDbInstanceIdentifier());- }-- private SecretTargetConnection docDbClusterConnection(String targetId) {- var cluster = docDbService.getDbCluster(targetId);- if (cluster == null || cluster.getEndpoint() == null- || cluster.getEndpoint().isBlank()- || cluster.getPort() <= 0- || cluster.getDbClusterIdentifier() == null- || cluster.getDbClusterIdentifier().isBlank()) {- throw incompleteSecretTarget(targetId);- }- return new SecretTargetConnection(- "mongo",- cluster.getEndpoint(),- cluster.getPort(),- null,- "dbClusterIdentifier",- cluster.getDbClusterIdentifier());- }-- private static void addSecretTargetConnection(ObjectNode secretJson, List<String> managedKeys,- SecretTargetConnection connection) {- putSecretTargetField(secretJson, managedKeys, "engine", connection.engine());- putSecretTargetField(secretJson, managedKeys, "host", connection.host());- putSecretTargetField(secretJson, managedKeys, "port", connection.port());- putOptionalSecretTargetField(secretJson, managedKeys, "dbname", connection.dbname());- putSecretTargetField(secretJson, managedKeys,- connection.identifierKey(), connection.identifier());- }-- private static AwsException incompleteSecretTarget(String targetId) {- return new AwsException("ValidationError",- "SecretTargetAttachment target " + targetId + " has incomplete connection information.", 400);- }-- private record SecretTargetConnection(String engine, String host, int port, String dbname,- String identifierKey, String identifier) {- }-- private record SecretTargetMutation(String secretId, ObjectNode originalValue, ObjectNode value) {- }-- private static void putSecretTargetField(ObjectNode secretJson, List<String> managedKeys,- String name, String value) {- secretJson.put(name, value);- managedKeys.add(name);- }-- private static void putSecretTargetField(ObjectNode secretJson, List<String> managedKeys,- String name, int value) {- secretJson.put(name, value);- managedKeys.add(name);- }-- private static void putOptionalSecretTargetField(ObjectNode secretJson, List<String> managedKeys,- String name, String value) {- if (value != null && !value.isBlank()) {- putSecretTargetField(secretJson, managedKeys, name, value);- }- }-- private void deleteSecretTargetAttachment(StackResource resource, String region) {- String attachmentOwner = resource.getAttributes().get(SECRET_TARGET_OWNER_ATTR);- if (!secretsManagerService.canManageTargetAttachment(- resource.getPhysicalId(), attachmentOwner, region)) {- LOG.warnv("Skipping SecretTargetAttachment detach because secret {0}"- + " is owned by a different attachment",- resource.getPhysicalId());- return;- }- detachSecretTarget(resource.getPhysicalId(),- resource.getAttributes().get(SECRET_TARGET_MANAGED_KEYS_ATTR), region);- secretsManagerService.releaseTargetAttachment(- resource.getPhysicalId(), attachmentOwner, region);- }-- private void detachSecretTarget(String secretId, String managedKeysAttribute, String region) {- SecretTargetMutation mutation = prepareSecretTargetDetach(secretId, managedKeysAttribute, region);- if (mutation != null) {- putSecretTargetMutation(mutation, region);- }- }-- private SecretTargetMutation prepareSecretTargetDetach(String secretId,- String managedKeysAttribute,- String region) {- try {- Optional<ObjectNode> parsedSecret = tryReadSecretJsonObject(secretId, region);- if (parsedSecret.isEmpty()) {- LOG.debugv("SecretTargetAttachment current secret value is no longer a JSON object;"- + " treating as already detached: {0}", secretId);- return null;- }- ObjectNode currentSecretJson = parsedSecret.get();- ObjectNode detachedSecretJson = currentSecretJson.deepCopy();- List<String> managedKeys = managedSecretTargetKeys(managedKeysAttribute);- managedKeys.forEach(detachedSecretJson::remove);- return detachedSecretJson.equals(currentSecretJson)- ? null- : new SecretTargetMutation(secretId, currentSecretJson, detachedSecretJson);- } catch (AwsException e) {- if (!"ResourceNotFoundException".equals(e.getErrorCode())) {- throw e;- }- LOG.debugv("SecretTargetAttachment secret already gone, treating as detached: {0}", secretId);- return null;- }- }-- private void putSecretTargetMutation(SecretTargetMutation mutation, String region) {- secretsManagerService.putSecretValue(- mutation.secretId(), mutation.value().toString(), null, null, region, null);- }-- private void attemptSecretTargetCleanup(RuntimeException primaryFailure,- String description,- Runnable cleanup) {- try {- cleanup.run();- } catch (RuntimeException cleanupFailure) {- primaryFailure.addSuppressed(cleanupFailure);- LOG.warnv("SecretTargetAttachment rollback cleanup failed while attempting to {0}: {1}",- description, cleanupFailure.getMessage());- }- }-- private static List<String> managedSecretTargetKeys(String attribute) {- if (attribute == null || attribute.isBlank()) {- return SECRET_TARGET_CONNECTION_KEYS;- }- List<String> keys = Arrays.stream(attribute.split(","))- .filter(SECRET_TARGET_CONNECTION_KEYS::contains)- .toList();- return keys.isEmpty() ? SECRET_TARGET_CONNECTION_KEYS : keys;- }-- /**- * Resolves the secret value from CloudFormation properties.- * SecretString and GenerateSecretString are mutually exclusive per AWS spec.- * If GenerateSecretString is present, a random password is generated.- * If SecretStringTemplate and GenerateStringKey are specified inside- * GenerateSecretString, the generated password is embedded in the template JSON.- */- private String resolveSecretValue(JsonNode props, CloudFormationTemplateEngine engine) {- if (props == null) {- return "{}";- }-- // SecretString takes precedence when explicitly set- String secretString = resolveOptional(props, "SecretString", engine);- JsonNode genNode = props.get("GenerateSecretString");-- if (secretString != null && genNode != null && !genNode.isNull()) {- throw new AwsException("ValidationError",- "You can't specify both SecretString and GenerateSecretString", 400);- }-- if (secretString != null) {- return secretString;- }-- if (genNode != null && !genNode.isNull()) {- return generateSecretString(genNode);- }-- return "{}";- }-- private String generateSecretString(JsonNode genNode) {- String password = io.github.hectorvent.floci.services.secretsmanager- .RandomPasswordGenerator.generate(genNode);-- String template = null;- String key = null;- JsonNode templateNode = genNode.get("SecretStringTemplate");- JsonNode keyNode = genNode.get("GenerateStringKey");-- if (templateNode != null && !templateNode.isNull()) {- template = templateNode.asText();- }- if (keyNode != null && !keyNode.isNull()) {- key = keyNode.asText();- }-- if (template != null && key != null) {- // Insert the generated password into the template JSON- try {- var mapper = new com.fasterxml.jackson.databind.ObjectMapper();- var tree = (com.fasterxml.jackson.databind.node.ObjectNode) mapper.readTree(template);- tree.put(key, password);- return mapper.writeValueAsString(tree);- } catch (Exception e) {- // If the template is not valid JSON, fall back to raw password- LOG.warnv("Failed to parse SecretStringTemplate: {0}", e.getMessage());- return password;- }- }-- return password;- }-private void putResolvedText(ObjectNode req, String target, JsonNode props, String source,CloudFormationTemplateEngine engine) {@@ -5419,16 +4955,6 @@ public class CloudFormationResourceProvisioner {resource.getAttributes().remove(INLINE_CLEANUP_GROUP_TARGETS_ATTR);}- private void deleteSecretSafe(String secretId, String region) {- try {- secretsManagerService.deleteSecret(secretId, null, true, region);- } catch (AwsException e) {- if (!"ResourceNotFoundException".equals(e.getErrorCode())) {- throw e;- }- LOG.debugv("Secret already gone, treating as deleted: {0}", secretId);- }- }/*** Generate an AWS-like physical name: {stackName}-{logicalId}-{randomSuffix}.diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SecretTargetAttachmentCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SecretTargetAttachmentCfnProvisioner.javanew file mode 100644index 0000000000..67a2e91c03--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SecretTargetAttachmentCfnProvisioner.java@@ -0,0 +1,448 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.docdb.DocDbService;+import io.github.hectorvent.floci.services.docdb.model.DocDbCluster;+import io.github.hectorvent.floci.services.docdb.model.DocDbInstance;+import io.github.hectorvent.floci.services.rds.RdsService;+import io.github.hectorvent.floci.services.rds.model.DbCluster;+import io.github.hectorvent.floci.services.rds.model.DbInstance;+import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.ArrayList;+import java.util.Arrays;+import java.util.List;+import java.util.Locale;+import java.util.Optional;+import java.util.Set;++/**+ * Provisions {@code AWS::SecretsManager::SecretTargetAttachment}.+ *+ * <p>Extracted from {@code CloudFormationResourceProvisioner}. Unlike most provisioners this one+ * wraps three services rather than one: an attachment reads the endpoint of the RDS or DocumentDB+ * instance or cluster it points at, so it can write the connection detail (engine, host, port,+ * dbname, identifier) into the target secret. That dependency is inherent to the type, and it is+ * the reason {@code RdsService} stayed in the monolith when the RDS types moved out.+ *+ * <p>This type deletes with the stored {@link StackResource}, not the physical id alone, so it+ * overrides {@code delete(StackResource, String)}. The delete needs two create-time attributes+ * that no physical id carries: which secret fields this attachment managed, so only those are+ * stripped, and which attachment owns the secret, so a second attachment's fields are left alone.+ * Registering that here is what lets the type leave the engine's+ * {@code DELETE_NEEDS_STACK_RESOURCE} set; the two must change together or+ * {@code CfnDeletePrecedenceTest} fails with both claiming it.+ */+@ApplicationScoped+public class SecretTargetAttachmentCfnProvisioner implements CfnResourceProvisioner {++ private static final String TYPE = "AWS::SecretsManager::SecretTargetAttachment";++ private static final Logger LOG = Logger.getLogger(SecretTargetAttachmentCfnProvisioner.class);++ private static final String SECRET_TARGET_MANAGED_KEYS_ATTR = "__FlociSecretTargetManagedKeys";+ private static final String SECRET_TARGET_OWNER_ATTR = "__FlociSecretTargetOwner";+ private static final List<String> SECRET_TARGET_CONNECTION_KEYS = List.of(+ "engine", "host", "port", "dbname", "dbInstanceIdentifier", "dbClusterIdentifier");++ private final SecretsManagerService secretsManagerService;+ private final RdsService rdsService;+ private final DocDbService docDbService;+ private final ObjectMapper objectMapper;++ @Inject+ public SecretTargetAttachmentCfnProvisioner(SecretsManagerService secretsManagerService,+ RdsService rdsService,+ DocDbService docDbService,+ ObjectMapper objectMapper) {+ this.secretsManagerService = secretsManagerService;+ this.rdsService = rdsService;+ this.docDbService = docDbService;+ this.objectMapper = objectMapper;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of(TYPE);+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ requireSupported(r.getResourceType());+ provisionSecretTargetAttachment(r, props, ctx);+ }++ @Override+ public void delete(StackResource resource, String region) {+ requireSupported(resource.getResourceType());+ deleteSecretTargetAttachment(resource, region);+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ requireSupported(resourceType);+ throw new AwsException("ValidationError",+ "SecretTargetAttachment deletion requires the StackResource metadata that records "+ + "its managed fields.", 400);+ }++ private static void requireSupported(String resourceType) {+ if (!TYPE.equals(resourceType)) {+ throw new IllegalStateException(+ "SecretTargetAttachmentCfnProvisioner received an unsupported type: " + resourceType);+ }+ }++ /** Provisions an AWS-compatible Secrets Manager database target attachment. */+ private void provisionSecretTargetAttachment(StackResource r, JsonNode props, ProvisionContext ctx) {+ String region = ctx.region();+ String stackName = ctx.stackName();+ String secretId = requireSecretTargetProperty(props, "SecretId", ctx);+ String targetId = requireSecretTargetProperty(props, "TargetId", ctx);+ String targetType = requireSecretTargetProperty(props, "TargetType", ctx);+ validateSecretTargetType(targetType);+ SecretTargetConnection connection = resolveSecretTargetConnection(targetType, targetId);++ String previousSecretId = r.getPhysicalId();+ String previousManagedKeys = r.getAttributes().get(SECRET_TARGET_MANAGED_KEYS_ATTR);+ String attachmentOwner = r.getAttributes().getOrDefault(+ SECRET_TARGET_OWNER_ATTR, stackName + "/" + r.getLogicalId());+ String secretArn = secretsManagerService.describeSecret(secretId, region).getArn();+ String previousSecretArn = canonicalExistingSecretArn(previousSecretId, secretArn, region);+ boolean replacingSecret = previousSecretArn != null && !previousSecretArn.equals(secretArn);+ boolean claimCreated = false;+ boolean wroteNewSecret = false;+ boolean detachedPreviousSecret = false;+ ObjectNode currentSecretJson = null;+ SecretTargetMutation previousDetach = null;++ try {+ claimCreated = secretsManagerService.claimTargetAttachment(+ secretArn, attachmentOwner, region);++ currentSecretJson = readSecretJsonObject(secretArn, region);+ ObjectNode desiredSecretJson = currentSecretJson.deepCopy();+ SECRET_TARGET_CONNECTION_KEYS.forEach(desiredSecretJson::remove);++ List<String> managedKeys = new ArrayList<>();+ addSecretTargetConnection(desiredSecretJson, managedKeys, connection);++ if (replacingSecret) {+ previousDetach = prepareSecretTargetDetach(previousSecretArn, previousManagedKeys, region);+ }+ if (!desiredSecretJson.equals(currentSecretJson)) {+ secretsManagerService.putSecretValue(+ secretArn, desiredSecretJson.toString(), null, null, region, null);+ wroteNewSecret = true;+ }+ if (previousDetach != null) {+ putSecretTargetMutation(previousDetach, region);+ detachedPreviousSecret = true;+ }+ if (replacingSecret) {+ secretsManagerService.releaseTargetAttachment(+ previousSecretArn, attachmentOwner, region);+ }++ r.setPhysicalId(secretArn);+ r.getAttributes().remove("Arn");+ r.getAttributes().put("Id", secretArn);+ r.getAttributes().put(SECRET_TARGET_OWNER_ATTR, attachmentOwner);+ r.getAttributes().put(SECRET_TARGET_MANAGED_KEYS_ATTR, String.join(",", managedKeys));+ } catch (RuntimeException failure) {+ if (detachedPreviousSecret && previousDetach != null) {+ ObjectNode previousValue = previousDetach.originalValue();+ attemptSecretTargetCleanup(failure, "restore previous secret " + previousSecretArn,+ () -> secretsManagerService.putSecretValue(+ previousSecretArn, previousValue.toString(),+ null, null, region, null));+ }+ if (wroteNewSecret && currentSecretJson != null) {+ ObjectNode originalValue = currentSecretJson;+ attemptSecretTargetCleanup(failure, "restore new secret " + secretArn,+ () -> secretsManagerService.putSecretValue(+ secretArn, originalValue.toString(),+ null, null, region, null));+ }+ if (claimCreated) {+ attemptSecretTargetCleanup(failure, "release target attachment claim for " + secretArn,+ () -> secretsManagerService.releaseTargetAttachment(+ secretArn, attachmentOwner, region));+ }+ throw failure;+ }+ }++ private static void validateSecretTargetType(String targetType) {+ if (!Set.of(+ "AWS::RDS::DBInstance",+ "AWS::RDS::DBCluster",+ "AWS::DocDB::DBInstance",+ "AWS::DocDB::DBCluster").contains(targetType)) {+ throw new AwsException("ValidationError",+ "SecretTargetAttachment TargetType " + targetType+ + " is not supported by Floci; supported values are AWS::RDS::DBInstance,"+ + " AWS::RDS::DBCluster, AWS::DocDB::DBInstance,"+ + " and AWS::DocDB::DBCluster.", 400);+ }+ }++ private String canonicalExistingSecretArn(String secretId, String newSecretArn, String region) {+ if (secretId == null || secretId.isBlank() || secretId.equals(newSecretArn)) {+ return secretId;+ }+ try {+ return secretsManagerService.describeSecret(secretId, region).getArn();+ } catch (AwsException e) {+ if ("ResourceNotFoundException".equals(e.getErrorCode())) {+ return null;+ }+ throw e;+ }+ }++ private String requireSecretTargetProperty(JsonNode props, String name, ProvisionContext ctx) {+ String value = ctx.resolveOptional(props, name);+ if (value == null || value.isBlank()) {+ throw new AwsException("ValidationError",+ "AWS::SecretsManager::SecretTargetAttachment requires " + name + ".", 400);+ }+ return value;+ }++ private ObjectNode readSecretJsonObject(String secretId, String region) {+ return tryReadSecretJsonObject(secretId, region)+ .orElseThrow(SecretTargetAttachmentCfnProvisioner::invalidSecretTargetValue);+ }++ private Optional<ObjectNode> tryReadSecretJsonObject(String secretId, String region) {+ String secretString = secretsManagerService+ .getSecretValue(secretId, null, null, region)+ .getSecretString();+ if (secretString == null) {+ return Optional.empty();+ }+ try {+ JsonNode parsed = objectMapper.readTree(secretString);+ if (parsed == null || !parsed.isObject()) {+ return Optional.empty();+ }+ return Optional.of(((ObjectNode) parsed).deepCopy());+ } catch (JsonProcessingException e) {+ return Optional.empty();+ }+ }++ private static AwsException invalidSecretTargetValue() {+ return new AwsException("ValidationError",+ "SecretString for AWS::SecretsManager::SecretTargetAttachment must be a JSON object.", 400);+ }++ private SecretTargetConnection resolveSecretTargetConnection(String targetType, String targetId) {+ return switch (targetType) {+ case "AWS::RDS::DBInstance" -> dbInstanceConnection(targetId);+ case "AWS::RDS::DBCluster" -> dbClusterConnection(targetId);+ case "AWS::DocDB::DBInstance" -> docDbInstanceConnection(targetId);+ case "AWS::DocDB::DBCluster" -> docDbClusterConnection(targetId);+ default -> throw new IllegalStateException("Validated target type was not handled: " + targetType);+ };+ }++ private SecretTargetConnection dbInstanceConnection(String targetId) {+ DbInstance instance = rdsService.getDbInstance(targetId);+ if (instance == null || instance.getEngine() == null || instance.getEndpoint() == null+ || instance.getEndpoint().address() == null+ || instance.getEndpoint().address().isBlank()+ || instance.getEndpoint().port() <= 0+ || instance.getDbInstanceIdentifier() == null+ || instance.getDbInstanceIdentifier().isBlank()) {+ throw incompleteSecretTarget(targetId);+ }+ return new SecretTargetConnection(+ instance.getEngine().name().toLowerCase(Locale.ROOT),+ instance.getEndpoint().address(),+ instance.getEndpoint().port(),+ instance.getDbName(),+ "dbInstanceIdentifier",+ instance.getDbInstanceIdentifier());+ }++ private SecretTargetConnection dbClusterConnection(String targetId) {+ DbCluster cluster = rdsService.getDbCluster(targetId);+ if (cluster == null || cluster.getEngine() == null || cluster.getEndpoint() == null+ || cluster.getEndpoint().address() == null+ || cluster.getEndpoint().address().isBlank()+ || cluster.getEndpoint().port() <= 0+ || cluster.getDbClusterIdentifier() == null+ || cluster.getDbClusterIdentifier().isBlank()) {+ throw incompleteSecretTarget(targetId);+ }+ return new SecretTargetConnection(+ cluster.getEngine().name().toLowerCase(Locale.ROOT),+ cluster.getEndpoint().address(),+ cluster.getEndpoint().port(),+ cluster.getDatabaseName(),+ "dbClusterIdentifier",+ cluster.getDbClusterIdentifier());+ }++ private SecretTargetConnection docDbInstanceConnection(String targetId) {+ DocDbInstance instance = docDbService.getDbInstance(targetId);+ if (instance == null || instance.getEndpoint() == null+ || instance.getEndpoint().isBlank()+ || instance.getPort() <= 0+ || instance.getDbInstanceIdentifier() == null+ || instance.getDbInstanceIdentifier().isBlank()) {+ throw incompleteSecretTarget(targetId);+ }+ return new SecretTargetConnection(+ "mongo",+ instance.getEndpoint(),+ instance.getPort(),+ null,+ "dbInstanceIdentifier",+ instance.getDbInstanceIdentifier());+ }++ private SecretTargetConnection docDbClusterConnection(String targetId) {+ DocDbCluster cluster = docDbService.getDbCluster(targetId);+ if (cluster == null || cluster.getEndpoint() == null+ || cluster.getEndpoint().isBlank()+ || cluster.getPort() <= 0+ || cluster.getDbClusterIdentifier() == null+ || cluster.getDbClusterIdentifier().isBlank()) {+ throw incompleteSecretTarget(targetId);+ }+ return new SecretTargetConnection(+ "mongo",+ cluster.getEndpoint(),+ cluster.getPort(),+ null,+ "dbClusterIdentifier",+ cluster.getDbClusterIdentifier());+ }++ private static void addSecretTargetConnection(ObjectNode secretJson, List<String> managedKeys,+ SecretTargetConnection connection) {+ putSecretTargetField(secretJson, managedKeys, "engine", connection.engine());+ putSecretTargetField(secretJson, managedKeys, "host", connection.host());+ putSecretTargetField(secretJson, managedKeys, "port", connection.port());+ putOptionalSecretTargetField(secretJson, managedKeys, "dbname", connection.dbname());+ putSecretTargetField(secretJson, managedKeys,+ connection.identifierKey(), connection.identifier());+ }++ private static AwsException incompleteSecretTarget(String targetId) {+ return new AwsException("ValidationError",+ "SecretTargetAttachment target " + targetId + " has incomplete connection information.", 400);+ }++ private record SecretTargetConnection(String engine, String host, int port, String dbname,+ String identifierKey, String identifier) {+ }++ private record SecretTargetMutation(String secretId, ObjectNode originalValue, ObjectNode value) {+ }++ private static void putSecretTargetField(ObjectNode secretJson, List<String> managedKeys,+ String name, String value) {+ secretJson.put(name, value);+ managedKeys.add(name);+ }++ private static void putSecretTargetField(ObjectNode secretJson, List<String> managedKeys,+ String name, int value) {+ secretJson.put(name, value);+ managedKeys.add(name);+ }++ private static void putOptionalSecretTargetField(ObjectNode secretJson, List<String> managedKeys,+ String name, String value) {+ if (value != null && !value.isBlank()) {+ putSecretTargetField(secretJson, managedKeys, name, value);+ }+ }++ private void deleteSecretTargetAttachment(StackResource resource, String region) {+ String attachmentOwner = resource.getAttributes().get(SECRET_TARGET_OWNER_ATTR);+ if (!secretsManagerService.canManageTargetAttachment(+ resource.getPhysicalId(), attachmentOwner, region)) {+ LOG.warnv("Skipping SecretTargetAttachment detach because secret {0}"+ + " is owned by a different attachment",+ resource.getPhysicalId());+ return;+ }+ detachSecretTarget(resource.getPhysicalId(),+ resource.getAttributes().get(SECRET_TARGET_MANAGED_KEYS_ATTR), region);+ secretsManagerService.releaseTargetAttachment(+ resource.getPhysicalId(), attachmentOwner, region);+ }++ private void detachSecretTarget(String secretId, String managedKeysAttribute, String region) {+ SecretTargetMutation mutation = prepareSecretTargetDetach(secretId, managedKeysAttribute, region);+ if (mutation != null) {+ putSecretTargetMutation(mutation, region);+ }+ }++ private SecretTargetMutation prepareSecretTargetDetach(String secretId,+ String managedKeysAttribute,+ String region) {+ try {+ Optional<ObjectNode> parsedSecret = tryReadSecretJsonObject(secretId, region);+ if (parsedSecret.isEmpty()) {+ LOG.debugv("SecretTargetAttachment current secret value is no longer a JSON object;"+ + " treating as already detached: {0}", secretId);+ return null;+ }+ ObjectNode currentSecretJson = parsedSecret.get();+ ObjectNode detachedSecretJson = currentSecretJson.deepCopy();+ List<String> managedKeys = managedSecretTargetKeys(managedKeysAttribute);+ managedKeys.forEach(detachedSecretJson::remove);+ return detachedSecretJson.equals(currentSecretJson)+ ? null+ : new SecretTargetMutation(secretId, currentSecretJson, detachedSecretJson);+ } catch (AwsException e) {+ if (!"ResourceNotFoundException".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("SecretTargetAttachment secret already gone, treating as detached: {0}", secretId);+ return null;+ }+ }++ private void putSecretTargetMutation(SecretTargetMutation mutation, String region) {+ secretsManagerService.putSecretValue(+ mutation.secretId(), mutation.value().toString(), null, null, region, null);+ }++ private void attemptSecretTargetCleanup(RuntimeException primaryFailure,+ String description,+ Runnable cleanup) {+ try {+ cleanup.run();+ } catch (RuntimeException cleanupFailure) {+ primaryFailure.addSuppressed(cleanupFailure);+ LOG.warnv("SecretTargetAttachment rollback cleanup failed while attempting to {0}: {1}",+ description, cleanupFailure.getMessage());+ }+ }++ private static List<String> managedSecretTargetKeys(String attribute) {+ if (attribute == null || attribute.isBlank()) {+ return SECRET_TARGET_CONNECTION_KEYS;+ }+ List<String> keys = Arrays.stream(attribute.split(","))+ .filter(SECRET_TARGET_CONNECTION_KEYS::contains)+ .toList();+ return keys.isEmpty() ? SECRET_TARGET_CONNECTION_KEYS : keys;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SecretsManagerCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SecretsManagerCfnProvisioner.javanew file mode 100644index 0000000000..05966efb18--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/SecretsManagerCfnProvisioner.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.secretsmanager.RandomPasswordGenerator;+import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerService;+import io.github.hectorvent.floci.services.secretsmanager.model.Secret;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.List;+import java.util.Set;++/**+ * Provisions {@code AWS::SecretsManager::Secret}.+ *+ * <p>Extracted from {@code CloudFormationResourceProvisioner}. The sibling type+ * {@code AWS::SecretsManager::SecretTargetAttachment} lives in+ * {@link SecretTargetAttachmentCfnProvisioner} instead of here, because it has to read an RDS or+ * DocumentDB endpoint to build the connection detail it writes into the secret, so it needs three+ * services where this one needs only its own.+ *+ * <p>The secret deletes by physical id alone, so the id-only delete override serves it and it is+ * not in the engine's {@code DELETE_NEEDS_STACK_RESOURCE} set.+ */+@ApplicationScoped+public class SecretsManagerCfnProvisioner implements CfnResourceProvisioner {++ private static final String TYPE = "AWS::SecretsManager::Secret";++ private static final Logger LOG = Logger.getLogger(SecretsManagerCfnProvisioner.class);++ private final SecretsManagerService secretsManagerService;++ @Inject+ public SecretsManagerCfnProvisioner(SecretsManagerService secretsManagerService) {+ this.secretsManagerService = secretsManagerService;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of(TYPE);+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ if (!TYPE.equals(r.getResourceType())) {+ throw new IllegalStateException(+ "SecretsManagerCfnProvisioner received an unsupported type: " + r.getResourceType());+ }+ provisionSecret(r, props, ctx);+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ if (!TYPE.equals(resourceType)) {+ throw new IllegalStateException(+ "SecretsManagerCfnProvisioner received an unsupported type: " + resourceType);+ }+ deleteSecretSafe(physicalId, region);+ }++ private void provisionSecret(StackResource r, JsonNode props, ProvisionContext ctx) {+ String region = ctx.region();+ String name = ctx.resolveOptional(props, "Name");+ if (name == null || name.isBlank()) {+ name = ctx.generatePhysicalName(r.getLogicalId(), 512, false);+ }+ String description = ctx.resolveOptional(props, "Description");+ String value = resolveSecretValue(props, ctx);+ Secret secret = secretsManagerService.createSecret(name, value, null, description, null,+ List.of(), region);+ r.setPhysicalId(secret.getArn());+ r.getAttributes().put("Arn", secret.getArn());+ r.getAttributes().put("Name", name);+ }++ private void deleteSecretSafe(String secretId, String region) {+ try {+ secretsManagerService.deleteSecret(secretId, null, true, region);+ } catch (AwsException e) {+ if (!"ResourceNotFoundException".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("Secret already gone, treating as deleted: {0}", secretId);+ }+ }++ /**+ * Resolves the secret value from CloudFormation properties.+ * SecretString and GenerateSecretString are mutually exclusive per AWS spec.+ * If GenerateSecretString is present, a random password is generated.+ * If SecretStringTemplate and GenerateStringKey are specified inside+ * GenerateSecretString, the generated password is embedded in the template JSON.+ */+ private String resolveSecretValue(JsonNode props, ProvisionContext ctx) {+ if (props == null) {+ return "{}";+ }++ // SecretString takes precedence when explicitly set+ String secretString = ctx.resolveOptional(props, "SecretString");+ JsonNode genNode = props.get("GenerateSecretString");++ if (secretString != null && genNode != null && !genNode.isNull()) {+ throw new AwsException("ValidationError",+ "You can't specify both SecretString and GenerateSecretString", 400);+ }++ if (secretString != null) {+ return secretString;+ }++ if (genNode != null && !genNode.isNull()) {+ return generateSecretString(genNode);+ }++ return "{}";+ }++ private String generateSecretString(JsonNode genNode) {+ String password = RandomPasswordGenerator.generate(genNode);++ String template = null;+ String key = null;+ JsonNode templateNode = genNode.get("SecretStringTemplate");+ JsonNode keyNode = genNode.get("GenerateStringKey");++ if (templateNode != null && !templateNode.isNull()) {+ template = templateNode.asText();+ }+ if (keyNode != null && !keyNode.isNull()) {+ key = keyNode.asText();+ }++ if (template != null && key != null) {+ // Insert the generated password into the template JSON+ try {+ ObjectMapper mapper = new ObjectMapper();+ ObjectNode tree = (ObjectNode) mapper.readTree(template);+ tree.put(key, password);+ return mapper.writeValueAsString(tree);+ } catch (Exception e) {+ // If the template is not valid JSON, fall back to raw password+ LOG.warnv("Failed to parse SecretStringTemplate: {0}", e.getMessage());+ return password;+ }+ }++ return password;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.javaindex dd0057c384..33c9dee042 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java@@ -66,6 +66,8 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.RdsCfnProimport io.github.hectorvent.floci.services.cloudformation.provisioners.Route53CfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.S3CfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.SchedulerScheduleGroupCfnProvisioner;+import io.github.hectorvent.floci.services.cloudformation.provisioners.SecretTargetAttachmentCfnProvisioner;+import io.github.hectorvent.floci.services.cloudformation.provisioners.SecretsManagerCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.SnsCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.SsmCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnResourceProvisioner;@@ -321,6 +323,11 @@ final class CfnProvisionerFixture {if (rdsService != null) {discovered.add(new RdsCfnProvisioner(rdsService, dynamicReferences));}+ if (secretsManagerService != null) {+ discovered.add(new SecretsManagerCfnProvisioner(secretsManagerService));+ discovered.add(new SecretTargetAttachmentCfnProvisioner(+ secretsManagerService, rdsService, docDbService, objectMapper));+ }if (wafV2Service != null) {discovered.add(new WafV2CfnProvisioner(wafV2Service));}@@ -626,7 +633,6 @@ final class CfnProvisionerFixture {iamService,ssmService,kmsService,- secretsManagerService,apiGatewayService,apiGatewayV2Service,ecrService,@@ -637,14 +643,12 @@ final class CfnProvisionerFixture {reachableEndpoint,stepFunctionsService,ec2Service,- rdsService,eksService,logsService,kinesisService,cloudWatchMetricsService,autoScalingService,firehoseService,- docDbService,cloudFrontService,resourceRegistry,dynamicReferences,diff --git a/src/test/resources/cloudformation/getatt-attribute-gaps.tsv b/src/test/resources/cloudformation/getatt-attribute-gaps.tsvindex 9de34c48db..d73b485ed7 100644--- a/src/test/resources/cloudformation/getatt-attribute-gaps.tsv+++ b/src/test/resources/cloudformation/getatt-attribute-gaps.tsv@@ -44,3 +44,4 @@ AWS::RDS::DBInstance ResumeFullAutomationModeTime RDS Custom automation mode isAWS::RDS::DBInstance SecondaryAvailabilityZone multi-AZ secondary placement is not emulatedAWS::RDS::DBInstance StatusInfos read-replica status detail is not emulatedAWS::SQS::QueuePolicy Id schema gives no description; the policy has no backing entity to take an id from+AWS::SecretsManager::Secret Id Fn::GetAtt Id on a secret is its ARN, which the provisioner already sets as the physical id and as Arn; closable, deferred to a follow-up PR to keep this one a pure movediff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex 9d43b527bf..c000f283ed 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -127,8 +127,8 @@ AWS::SQS::Queue SqsCfnProvisionerAWS::SQS::QueuePolicy SqsCfnProvisionerAWS::SSM::Parameter SsmCfnProvisionerAWS::Scheduler::ScheduleGroup SchedulerScheduleGroupCfnProvisioner-AWS::SecretsManager::Secret LEGACY_SWITCH-AWS::SecretsManager::SecretTargetAttachment LEGACY_SWITCH+AWS::SecretsManager::Secret SecretsManagerCfnProvisioner+AWS::SecretsManager::SecretTargetAttachment SecretTargetAttachmentCfnProvisionerAWS::StepFunctions::StateMachine LEGACY_SWITCHAWS::WAFv2::WebACL WafV2CfnProvisionerCustom::DynamoDBReplica LEGACY_SWITCH