Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(stepfunctions): add UpdateStateMachine and update in place on stack updates (#1867)

Alex Banna97ac3cabb513
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationStepFunctionsUpdateTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationStepFunctionsUpdateTest.java
new file mode 100644
index 0000000000..705daea521
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudFormationStepFunctionsUpdateTest.java
@@ -0,0 +1,162 @@
+package com.floci.test;
+
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.cloudformation.CloudFormationClient;
+import software.amazon.awssdk.services.cloudformation.model.DescribeStackResourcesRequest;
+import software.amazon.awssdk.services.cloudformation.model.DescribeStacksRequest;
+import software.amazon.awssdk.services.cloudformation.model.Stack;
+import software.amazon.awssdk.services.cloudformation.model.StackResource;
+import software.amazon.awssdk.services.sfn.SfnClient;
+import software.amazon.awssdk.services.sfn.model.DescribeStateMachineResponse;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("CloudFormation Step Functions update")
+class CloudFormationStepFunctionsUpdateTest {
+
+ private static final Logger LOGGER =
+ Logger.getLogger(CloudFormationStepFunctionsUpdateTest.class.getName());
+ private static final String ROLE_ARN =
+ "arn:aws:iam::000000000000:role/cfn-step-functions-update-role";
+
+ private static CloudFormationClient cloudFormation;
+ private static SfnClient stepFunctions;
+ private static String stackName;
+
+ @BeforeAll
+ static void setup() {
+ cloudFormation = TestFixtures.cloudFormationClient();
+ stepFunctions = TestFixtures.sfnClient();
+ stackName = TestFixtures.uniqueName("cfn-sfn-update");
+ }
+
+ @AfterAll
+ static void cleanup() {
+ if (cloudFormation != null) {
+ if (stackName != null) {
+ try {
+ cloudFormation.deleteStack(request -> request.stackName(stackName));
+ } catch (Exception e) {
+ LOGGER.log(Level.WARNING, "Failed to clean up CloudFormation update test", e);
+ }
+ }
+ cloudFormation.close();
+ }
+ if (stepFunctions != null) {
+ stepFunctions.close();
+ }
+ }
+
+ @Test
+ void sdkUpdatesStateMachineInPlace() throws InterruptedException {
+ String stateMachineName = TestFixtures.uniqueName("cfn-managed-sfn");
+ String initialDefinition =
+ "{\"StartAt\":\"Initial\",\"States\":{\"Initial\":"
+ + "{\"Type\":\"Pass\",\"End\":true}}}";
+ String updatedDefinition =
+ "{\"StartAt\":\"Updated\",\"States\":{\"Updated\":"
+ + "{\"Type\":\"Pass\",\"End\":true}}}";
+
+ cloudFormation.createStack(request -> request
+ .stackName(stackName)
+ .templateBody(template(
+ stateMachineName, initialDefinition, "initial")));
+ assertThat(waitForTerminalStatus(stackName, 30))
+ .isEqualTo("CREATE_COMPLETE");
+
+ StackResource initialResource = stateMachineResource(stackName);
+ String stateMachineArn = initialResource.physicalResourceId();
+ DescribeStateMachineResponse initial =
+ stepFunctions.describeStateMachine(
+ request -> request.stateMachineArn(stateMachineArn));
+
+ cloudFormation.updateStack(request -> request
+ .stackName(stackName)
+ .templateBody(template(
+ stateMachineName, updatedDefinition, "updated")));
+ assertThat(waitForTerminalStatus(stackName, 30))
+ .isEqualTo("UPDATE_COMPLETE");
+
+ StackResource updatedResource = stateMachineResource(stackName);
+ assertThat(updatedResource.physicalResourceId())
+ .isEqualTo(stateMachineArn);
+ assertThat(updatedResource.resourceStatusAsString())
+ .isEqualTo("UPDATE_COMPLETE");
+
+ DescribeStateMachineResponse updated =
+ stepFunctions.describeStateMachine(
+ request -> request.stateMachineArn(stateMachineArn));
+ assertThat(updated.definition()).isEqualTo(updatedDefinition);
+ assertThat(updated.revisionId()).isNotEqualTo(initial.revisionId());
+ }
+
+ private static StackResource stateMachineResource(String name) {
+ List<StackResource> resources = cloudFormation.describeStackResources(
+ DescribeStackResourcesRequest.builder()
+ .stackName(name)
+ .build()).stackResources();
+ return resources.stream()
+ .filter(resource -> "AWS::StepFunctions::StateMachine"
+ .equals(resource.resourceType()))
+ .findFirst()
+ .orElseThrow();
+ }
+
+ private static String waitForTerminalStatus(
+ String name, int maxSeconds) throws InterruptedException {
+ long deadline = System.currentTimeMillis() + maxSeconds * 1000L;
+ while (System.currentTimeMillis() < deadline) {
+ List<Stack> stacks = cloudFormation.describeStacks(
+ DescribeStacksRequest.builder()
+ .stackName(name)
+ .build()).stacks();
+ if (!stacks.isEmpty()) {
+ String status = stacks.get(0).stackStatusAsString();
+ if (!status.endsWith("_IN_PROGRESS")) {
+ return status;
+ }
+ }
+ Thread.sleep(250);
+ }
+ throw new AssertionError(
+ "Stack " + name
+ + " did not reach a terminal state within "
+ + maxSeconds + " seconds");
+ }
+
+ private static String template(
+ String stateMachineName,
+ String definition,
+ String marker) {
+ String escapedDefinition = definition.replace("\\", "\\\\")
+ .replace("\"", "\\\"");
+ return """
+ {
+ "Resources": {
+ "StateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "%s",
+ "DefinitionString": "%s"
+ }
+ }
+ },
+ "Outputs": {
+ "Marker": {"Value": "%s"}
+ }
+ }
+ """.formatted(
+ stateMachineName,
+ ROLE_ARN,
+ escapedDefinition,
+ marker);
+ }
+}
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/StepFunctionsUpdateStateMachineTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/StepFunctionsUpdateStateMachineTest.java
new file mode 100644
index 0000000000..8415a11d3e
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/StepFunctionsUpdateStateMachineTest.java
@@ -0,0 +1,92 @@
+package com.floci.test;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.sfn.SfnClient;
+import software.amazon.awssdk.services.sfn.model.DescribeStateMachineResponse;
+import software.amazon.awssdk.services.sfn.model.IncludedData;
+import software.amazon.awssdk.services.sfn.model.LogLevel;
+import software.amazon.awssdk.services.sfn.model.UpdateStateMachineResponse;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("SFN UpdateStateMachine")
+class StepFunctionsUpdateStateMachineTest {
+
+ private static final Logger LOGGER = Logger.getLogger(StepFunctionsUpdateStateMachineTest.class.getName());
+ private static final String ROLE_ARN = "arn:aws:iam::000000000000:role/service-role/test-role";
+ private static final String INITIAL_DEFINITION = """
+ {"StartAt":"Initial","States":{"Initial":{"Type":"Pass","End":true}}}
+ """.strip();
+ private static final String UPDATED_DEFINITION = """
+ {"StartAt":"Updated","States":{"Updated":{"Type":"Pass","End":true}}}
+ """.strip();
+
+ private static SfnClient sfn;
+ private static String stateMachineArn;
+
+ @BeforeAll
+ static void setup() {
+ sfn = TestFixtures.sfnClient();
+ stateMachineArn = sfn.createStateMachine(b -> b
+ .name(TestFixtures.uniqueName("update-sm"))
+ .definition(INITIAL_DEFINITION)
+ .roleArn(ROLE_ARN))
+ .stateMachineArn();
+ }
+
+ @AfterAll
+ static void cleanup() {
+ if (sfn != null) {
+ if (stateMachineArn != null) {
+ try {
+ sfn.deleteStateMachine(b -> b.stateMachineArn(stateMachineArn));
+ } catch (Exception e) {
+ LOGGER.log(Level.WARNING, "Failed to clean up Step Functions update compatibility test", e);
+ }
+ }
+ sfn.close();
+ }
+ }
+
+ @Test
+ void sdkUpdatesAndDescribesStateMachine() {
+ UpdateStateMachineResponse update = sfn.updateStateMachine(b -> b
+ .stateMachineArn(stateMachineArn)
+ .definition(UPDATED_DEFINITION)
+ .roleArn(ROLE_ARN)
+ .loggingConfiguration(logging -> logging
+ .level(LogLevel.OFF)
+ .includeExecutionData(false))
+ .tracingConfiguration(tracing -> tracing.enabled(true))
+ .publish(true)
+ .versionDescription("compatibility snapshot"));
+
+ assertThat(update.updateDate()).isNotNull();
+ assertThat(update.revisionId()).isNotBlank();
+
+ DescribeStateMachineResponse describe = sfn.describeStateMachine(b -> b
+ .stateMachineArn(stateMachineArn));
+ assertThat(describe.definition()).isEqualTo(UPDATED_DEFINITION);
+ assertThat(describe.roleArn()).isEqualTo(ROLE_ARN);
+ assertThat(describe.revisionId()).isEqualTo(update.revisionId());
+ assertThat(describe.loggingConfiguration().level()).isEqualTo(LogLevel.OFF);
+ assertThat(describe.tracingConfiguration().enabled()).isTrue();
+
+ DescribeStateMachineResponse version = sfn.describeStateMachine(b -> b
+ .stateMachineArn(update.stateMachineVersionArn()));
+ assertThat(version.stateMachineArn()).isEqualTo(update.stateMachineVersionArn());
+ assertThat(version.definition()).isEqualTo(UPDATED_DEFINITION);
+ assertThat(version.description()).isEqualTo("compatibility snapshot");
+
+ DescribeStateMachineResponse metadata = sfn.describeStateMachine(b -> b
+ .stateMachineArn(update.stateMachineVersionArn())
+ .includedData(IncludedData.METADATA_ONLY));
+ assertThat(metadata.definition()).isEqualTo("{}");
+ }
+}
diff --git a/docs/services/step-functions.md b/docs/services/step-functions.md
index 456448d61b..7f4842758f 100644
--- a/docs/services/step-functions.md
+++ b/docs/services/step-functions.md
@@ -1,6 +1,6 @@
# Step Functions
-**Protocol:** JSON 1.1 (`X-Amz-Target: AmazonStatesService.*`)
+**Protocol:** AWS JSON 1.0 (`X-Amz-Target: AWSStepFunctions.*`)
**Endpoint:** `POST http://localhost:4566/`
## Supported Actions
@@ -9,6 +9,7 @@
| Action | Description |
| --- | --- |
| `CreateStateMachine` | Create a state machine (Standard or Express) |
+| `UpdateStateMachine` | Update definition, role, logging, tracing, or encryption settings and optionally publish a version |
| `DescribeStateMachine` | Get state machine definition and metadata |
| `ListStateMachines` | List all state machines |
| `DeleteStateMachine` | Delete a state machine |
@@ -35,6 +36,10 @@
| `UntagResource` | - |
<!-- floci:actions:end -->
+`UpdateStateMachine` returns the new revision ID and update timestamp. CloudFormation updates
+definition, role, logging, tracing, encryption, and tags without replacing the state machine;
+changes to `StateMachineName` or `StateMachineType` use replacement semantics.
+
## Map concurrency
Map states honor `MaxConcurrency` and, for JSONPath state machines, `MaxConcurrencyPath`.
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.java
index 24e25edf75..e46011c7bb 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
@@ -130,6 +130,8 @@ public class CloudFormationResourceProvisioner {
private static final String INLINE_CLEANUP_ROLE_TARGETS_ATTR = "__FlociInlineCleanupRoleTargets";
private static final String INLINE_CLEANUP_USER_TARGETS_ATTR = "__FlociInlineCleanupUserTargets";
private static final String INLINE_CLEANUP_GROUP_TARGETS_ATTR = "__FlociInlineCleanupGroupTargets";
+ private static final String SFN_NAME_MODE_ATTR = "FlociStepFunctionsNameMode";
+ static final String SFN_UPDATE_SNAPSHOT_ATTR = "__FlociStepFunctionsUpdateSnapshot";
private static final String EVENT_BUS_CREATED_TIME_ATTR = "FlociEventBusCreatedTime";
private static final String EVENT_BUS_MANAGED_TAG_KEYS_ATTR = "FlociEventBusManagedTagKeys";
private static final String EVENT_BUS_MANAGED_POLICY_ATTR = "FlociEventBusManagedPolicy";
@@ -139,6 +141,8 @@ public class CloudFormationResourceProvisioner {
Pattern.compile("[\\p{L}\\p{N}\\p{Z}_.:/=+\\-@]*");
private static final String NAME_MODE_EXPLICIT = "explicit";
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 LOG_GROUP_NAME_MODE_ATTR = "FlociLogGroupNameMode";
private static final String SECRET_TARGET_MANAGED_KEYS_ATTR = "__FlociSecretTargetManagedKeys";
private static final String SECRET_TARGET_OWNER_ATTR = "__FlociSecretTargetOwner";
@@ -345,7 +349,13 @@ public class CloudFormationResourceProvisioner {
case "AWS::ApiGatewayV2::Deployment" -> provisionApiGatewayV2Deployment(resource, properties, engine, region);
case "AWS::Pipes::Pipe" -> provisionPipe(resource, properties, engine, region, stackName);
case "AWS::StepFunctions::StateMachine" ->
- provisionStepFunctionsStateMachine(resource, properties, engine, region, stackName);
+ provisionStepFunctionsStateMachine(
+ resource,
+ properties,
+ engine,
+ region,
+ accountId,
+ stackName);
case "AWS::Lambda::EventSourceMapping" ->
provisionLambdaEventSourceMapping(resource, properties, engine, region);
case "AWS::Cognito::UserPool" ->
@@ -842,9 +852,18 @@ public class CloudFormationResourceProvisioner {
if (priorPhysicalId != null && priorPhysicalId.equals(name) && logsService.logGroupExists(name, region)) {
reconcileLogGroup(name, retentionInDays, tags, region);
} else {
- logsService.createLogGroup(name, retentionInDays, tags, region);
- if (priorPhysicalId != null && !priorPhysicalId.equals(name)
- && logsService.logGroupExists(priorPhysicalId, region)) {
+ boolean preservedPriorGroup = priorPhysicalId != null
+ && !priorPhysicalId.equals(name)
+ && logsService.logGroupExists(priorPhysicalId, region);
+ try {
+ logsService.createLogGroup(name, retentionInDays, tags, region);
+ } catch (RuntimeException failure) {
+ if (preservedPriorGroup) {
+ r.getAttributes().put(UPDATE_ROLLBACK_RESTORED_ATTR, "true");
+ }
+ throw failure;
+ }
+ if (preservedPriorGroup) {
logsService.deleteLogGroup(priorPhysicalId, region);
}
}
@@ -3606,51 +3625,603 @@ public class CloudFormationResourceProvisioner {
private void provisionStepFunctionsStateMachine(StackResource r, JsonNode props,
CloudFormationTemplateEngine engine,
- String region, String stackName) {
- String name = resolveOptional(props, "StateMachineName", engine);
- if (name == null || name.isBlank()) {
- name = generatePhysicalName(stackName, r.getLogicalId(), 80, false);
- }
-
+ String region, String accountId,
+ String stackName) {
+ String explicitName = resolveOptional(props, "StateMachineName", engine);
+ boolean hasExplicitName = explicitName != null && !explicitName.isBlank();
String roleArn = resolveOptional(props, "RoleArn", engine);
- String type = resolveOptional(props, "StateMachineType", engine);
+ if (roleArn == null || roleArn.isBlank()) {
+ throw new AwsException("ValidationError", "RoleArn is required for a state machine", 400);
+ }
+ String type = resolveOrDefault(props, "StateMachineType", engine, "STANDARD");
Map<String, String> tags = parseCfnTags(props != null ? props.get("Tags") : null, engine);
-
String definition = resolveStateMachineDefinition(props, engine);
+ JsonNode loggingConfiguration = resolveStateMachineLoggingConfiguration(props, engine);
+ JsonNode tracingConfiguration = resolveStateMachineTracingConfiguration(props, engine);
+ JsonNode encryptionConfiguration = resolveStateMachineEncryptionConfiguration(props, engine);
+
+ StateMachine existing = findStateMachine(r.getPhysicalId());
+ String desiredNameMode = hasExplicitName ? NAME_MODE_EXPLICIT : NAME_MODE_GENERATED;
+ String previousNameMode = r.getAttributes().get(SFN_NAME_MODE_ATTR);
+ if (existing != null && previousNameMode == null) {
+ previousNameMode = inferStepFunctionsNameMode(existing, stackName, r.getLogicalId());
+ }
+ boolean nameModeReplacement = existing != null
+ && !Objects.equals(previousNameMode, desiredNameMode);
+ boolean typeReplacement = existing != null && !Objects.equals(existing.getType(), type);
- StateMachine sm = stepFunctionsService.createStateMachine(name, definition, roleArn, type, region, tags);
+ String name;
+ if (hasExplicitName) {
+ name = explicitName;
+ } else if (existing != null && !nameModeReplacement && !typeReplacement) {
+ name = existing.getName();
+ } else {
+ name = generatePhysicalName(
+ stackName, r.getLogicalId(), STEP_FUNCTIONS_NAME_MAX_LENGTH, false);
+ }
+ String desiredArn = AwsArnUtils.Arn.of(
+ "states", region, accountId, "stateMachine:" + name).toString();
+
+ boolean nameReplacement = existing != null && !Objects.equals(existing.getName(), name);
+ boolean replacement = nameReplacement || nameModeReplacement || typeReplacement;
+ if (replacement && Objects.equals(existing.getName(), name)) {
+ throw new AwsException("ValidationError",
+ "Cannot replace state machine " + existing.getName()
+ + " without a new StateMachineName", 400);
+ }
+
+ boolean configurationChanged = existing != null
+ && !stateMachineConfigurationMatches(
+ existing,
+ definition,
+ roleArn,
+ loggingConfiguration,
+ tracingConfiguration,
+ encryptionConfiguration);
+ boolean tagsChanged = existing != null && !Objects.equals(existing.getTags(), tags);
+
+ StateMachine sm;
+ if (existing == null) {
+ sm = stepFunctionsService.createStateMachine(
+ name, definition, roleArn, type, region, tags,
+ loggingConfiguration, tracingConfiguration, encryptionConfiguration);
+ } else if (!replacement && !configurationChanged && !tagsChanged) {
+ sm = existing;
+ } else {
+ String replacementRevisionId = replacement
+ ? UUID.randomUUID().toString()
+ : null;
+ beginStepFunctionsUpdate(
+ r,
+ existing,
+ replacement,
+ replacement ? desiredArn : null,
+ replacementRevisionId);
+ if (replacement) {
+ sm = stepFunctionsService.createStateMachineWithRevisionId(
+ name, definition, roleArn, type, region, tags,
+ loggingConfiguration,
+ tracingConfiguration,
+ encryptionConfiguration,
+ replacementRevisionId);
+ markStepFunctionsReplacementCreated(r, sm);
+ } else {
+ sm = existing;
+ if (configurationChanged) {
+ sm = stepFunctionsService.updateStateMachine(
+ existing.getStateMachineArn(),
+ new StepFunctionsService.UpdateStateMachineRequest(
+ definition,
+ roleArn,
+ loggingConfiguration, true,
+ tracingConfiguration, true,
+ encryptionConfiguration, true,
+ false,
+ null)).stateMachine();
+ }
+ if (tagsChanged) {
+ stepFunctionsService.replaceStateMachineTags(sm.getStateMachineArn(), tags);
+ sm = stepFunctionsService.describeStateMachine(sm.getStateMachineArn());
+ }
+ }
+ }
r.setPhysicalId(sm.getStateMachineArn());
r.getAttributes().put("Arn", sm.getStateMachineArn());
r.getAttributes().put("Name", sm.getName());
+ r.getAttributes().put("StateMachineRevisionId", sm.getRevisionId());
+ r.getAttributes().put(SFN_NAME_MODE_ATTR, desiredNameMode);
}
- private String resolveStateMachineDefinition(JsonNode props, CloudFormationTemplateEngine engine) {
- if (props == null) {
+ private StateMachine findStateMachine(String stateMachineArn) {
+ if (stateMachineArn == null || stateMachineArn.isBlank()) {
return null;
}
+ try {
+ return stepFunctionsService.describeStateMachine(stateMachineArn);
+ } catch (AwsException e) {
+ if ("StateMachineDoesNotExist".equals(e.getErrorCode())) {
+ return null;
+ }
+ throw e;
+ }
+ }
- String definition = resolveOptional(props, "DefinitionString", engine);
- if (definition == null && props.has("Definition") && !props.get("Definition").isNull()) {
- definition = engine.resolveNode(props.get("Definition")).toString();
+ private String inferStepFunctionsNameMode(
+ StateMachine existing, String stackName, String logicalId) {
+ String base = stackName + "-" + logicalId;
+ int keep = STEP_FUNCTIONS_NAME_MAX_LENGTH - GENERATED_NAME_SUFFIX_LENGTH - 1;
+ String prefix = base.substring(0, Math.min(base.length(), keep));
+ while (prefix.endsWith("-")) {
+ prefix = prefix.substring(0, prefix.length() - 1);
+ }
+ String generatedPrefix = prefix.isEmpty() ? "" : prefix + "-";
+ String name = existing.getName();
+ if (name == null || !name.startsWith(generatedPrefix)) {
+ return NAME_MODE_EXPLICIT;
+ }
+ String suffix = name.substring(generatedPrefix.length());
+ boolean generatedSuffix = suffix.length() == GENERATED_NAME_SUFFIX_LENGTH
+ && suffix.chars().allMatch(c -> c >= '0' && c <= '9' || c >= 'a' && c <= 'f');
+ return generatedSuffix
+ ? NAME_MODE_GENERATED
+ : NAME_MODE_EXPLICIT;
+ }
+
+ private boolean stateMachineConfigurationMatches(
+ StateMachine existing,
+ String definition,
+ String roleArn,
+ JsonNode loggingConfiguration,
+ JsonNode tracingConfiguration,
+ JsonNode encryptionConfiguration) {
+ return Objects.equals(existing.getDefinition(), definition)
+ && Objects.equals(existing.getRoleArn(), roleArn)
+ && Objects.equals(
+ effectiveLoggingConfiguration(existing.getLoggingConfiguration()),
+ loggingConfiguration)
+ && Objects.equals(
+ effectiveTracingConfiguration(existing.getTracingConfiguration()),
+ tracingConfiguration)
+ && Objects.equals(
+ effectiveEncryptionConfiguration(existing.getEncryptionConfiguration()),
+ encryptionConfiguration);
+ }
+
+ private JsonNode effectiveLoggingConfiguration(JsonNode configuration) {
+ return configuration != null ? configuration : defaultStateMachineLoggingConfiguration();
+ }
+
+ private JsonNode effectiveTracingConfiguration(JsonNode configuration) {
+ return configuration != null ? configuration : defaultStateMachineTracingConfiguration();
+ }
+
+ private JsonNode effectiveEncryptionConfiguration(JsonNode configuration) {
+ return configuration != null ? configuration : defaultStateMachineEncryptionConfiguration();
+ }
+
+ private JsonNode resolveStateMachineLoggingConfiguration(
+ JsonNode props, CloudFormationTemplateEngine engine) {
+ if (props == null || !props.has("LoggingConfiguration")
+ || props.get("LoggingConfiguration").isNull()) {
+ return defaultStateMachineLoggingConfiguration();
+ }
+ JsonNode source = engine.resolveNode(props.get("LoggingConfiguration"));
+ if (!source.isObject()) {
+ throw new AwsException("ValidationError",
+ "LoggingConfiguration must be an object", 400);
+ }
+
+ ObjectNode result = objectMapper.createObjectNode();
+ JsonNode level = source.get("Level");
+ if (level != null && !level.isTextual()) {
+ throw new AwsException("ValidationError",
+ "LoggingConfiguration.Level must be a string", 400);
+ }
+ result.put("level", level != null ? level.asText() : "OFF");
+
+ JsonNode includeExecutionData = source.get("IncludeExecutionData");
+ if (includeExecutionData != null && !includeExecutionData.isBoolean()) {
+ throw new AwsException("ValidationError",
+ "LoggingConfiguration.IncludeExecutionData must be a boolean", 400);
+ }
+ result.put("includeExecutionData",
+ includeExecutionData != null && includeExecutionData.asBoolean());
+
+ ArrayNode destinations = result.putArray("destinations");
+ JsonNode sourceDestinations = source.get("Destinations");
+ if (sourceDestinations != null) {
+ if (!sourceDestinations.isArray()) {
+ throw new AwsException("ValidationError",
+ "LoggingConfiguration.Destinations must be an array", 400);
+ }
+ for (JsonNode destination : sourceDestinations) {
+ JsonNode logGroupArn = destination.path("CloudWatchLogsLogGroup").get("LogGroupArn");
+ if (logGroupArn == null || !logGroupArn.isTextual()) {
+ throw new AwsException("ValidationError",
+ "LoggingConfiguration destination LogGroupArn must be a string", 400);
+ }
+ destinations.addObject()
+ .putObject("cloudWatchLogsLogGroup")
+ .put("logGroupArn", logGroupArn.asText());
+ }
+ }
+ return result;
+ }
+
+ private ObjectNode defaultStateMachineLoggingConfiguration() {
+ ObjectNode result = objectMapper.createObjectNode();
+ result.put("level", "OFF");
+ result.put("includeExecutionData", false);
+ result.putArray("destinations");
+ return result;
+ }
+
+ private JsonNode resolveStateMachineTracingConfiguration(
+ JsonNode props, CloudFormationTemplateEngine engine) {
+ if (props == null || !props.has("TracingConfiguration")
+ || props.get("TracingConfiguration").isNull()) {
+ return defaultStateMachineTracingConfiguration();
+ }
+ JsonNode source = engine.resolveNode(props.get("TracingConfiguration"));
+ if (!source.isObject()) {
+ throw new AwsException("ValidationError",
+ "TracingConfiguration must be an object", 400);
+ }
+ JsonNode enabled = source.get("Enabled");
+ if (enabled != null && !enabled.isBoolean()) {
+ throw new AwsException("ValidationError",
+ "TracingConfiguration.Enabled must be a boolean", 400);
+ }
+ return objectMapper.createObjectNode()
+ .put("enabled", enabled != null && enabled.asBoolean());
+ }
+
+ private ObjectNode defaultStateMachineTracingConfiguration() {
+ return objectMapper.createObjectNode().put("enabled", false);
+ }
+
+ private JsonNode resolveStateMachineEncryptionConfiguration(
+ JsonNode props, CloudFormationTemplateEngine engine) {
+ if (props == null || !props.has("EncryptionConfiguration")
+ || props.get("EncryptionConfiguration").isNull()) {
+ return defaultStateMachineEncryptionConfiguration();
+ }
+ JsonNode source = engine.resolveNode(props.get("EncryptionConfiguration"));
+ if (!source.isObject()) {
+ throw new AwsException("ValidationError",
+ "EncryptionConfiguration must be an object", 400);
+ }
+
+ JsonNode type = source.get("Type");
+ if (type == null || !type.isTextual() || type.asText().isBlank()) {
+ throw new AwsException("ValidationError",
+ "EncryptionConfiguration.Type is required and must be a string", 400);
+ }
+ ObjectNode result = objectMapper.createObjectNode().put("type", type.asText());
+
+ JsonNode keyId = source.get("KmsKeyId");
+ if (keyId != null) {
+ if (!keyId.isTextual()) {
+ throw new AwsException("ValidationError",
+ "EncryptionConfiguration.KmsKeyId must be a string", 400);
+ }
+ result.put("kmsKeyId", keyId.asText());
+ }
+
+ JsonNode reusePeriod = source.get("KmsDataKeyReusePeriodSeconds");
+ if (reusePeriod != null) {
+ if (!reusePeriod.isIntegralNumber()) {
+ throw new AwsException("ValidationError",
+ "EncryptionConfiguration.KmsDataKeyReusePeriodSeconds must be an integer", 400);
+ }
+ result.put("kmsDataKeyReusePeriodSeconds", reusePeriod.intValue());
+ }
+ return result;
+ }
+
+ private ObjectNode defaultStateMachineEncryptionConfiguration() {
+ return objectMapper.createObjectNode().put("type", "AWS_OWNED_KEY");
+ }
+
+ private void beginStepFunctionsUpdate(
+ StackResource resource,
+ StateMachine existing,
+ boolean replacement,
+ String replacementArn,
+ String replacementRevisionId) {
+ if (resource.getAttributes().containsKey(SFN_UPDATE_SNAPSHOT_ATTR)) {
+ return;
+ }
+ ObjectNode snapshot = objectMapper.createObjectNode();
+ snapshot.put("physicalId", resource.getPhysicalId());
+ snapshot.put("replacement", replacement);
+ if (replacementArn != null) {
+ snapshot.put("replacementArn", replacementArn);
+ }
+ if (replacementRevisionId != null) {
+ snapshot.put("replacementRevisionId", replacementRevisionId);
+ }
+ snapshot.put("replacementCreated", false);
+ snapshot.put("cleanupAttempts", 0);
+ snapshot.set("stateMachine", objectMapper.valueToTree(existing));
+ ObjectNode attributes = snapshot.putObject("attributes");
+ resource.getAttributes().forEach(attributes::put);
+ resource.getAttributes().put(SFN_UPDATE_SNAPSHOT_ATTR, snapshot.toString());
+ }
+
+ private void markStepFunctionsReplacementCreated(
+ StackResource resource, StateMachine replacement) {
+ String rawSnapshot = resource.getAttributes().get(SFN_UPDATE_SNAPSHOT_ATTR);
+ if (rawSnapshot == null) {
+ throw new IllegalStateException(
+ "Step Functions replacement metadata is missing for "
+ + resource.getLogicalId());
+ }
+ try {
+ ObjectNode snapshot = (ObjectNode) objectMapper.readTree(rawSnapshot);
+ snapshot.put("replacementCreated", true);
+ snapshot.put("replacementArn", replacement.getStateMachineArn());
+ snapshot.put("replacementRevisionId", replacement.getRevisionId());
+ resource.getAttributes().put(
+ SFN_UPDATE_SNAPSHOT_ATTR, snapshot.toString());
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ "Could not record Step Functions replacement ownership for "
+ + resource.getLogicalId(), e);
+ }
+ }
+
+ UpdateCleanupResult completeUpdate(StackResource resource) {
+ String rawSnapshot = resource.getAttributes().get(SFN_UPDATE_SNAPSHOT_ATTR);
+ if (rawSnapshot == null) {
+ return new UpdateCleanupResult(false, true, null, 0, null);
+ }
+ try {
+ JsonNode snapshot = objectMapper.readTree(rawSnapshot);
+ String previousArn = snapshot.path("physicalId").asText(null);
+ if (!snapshot.path("replacement").asBoolean(false)
+ || previousArn == null
+ || Objects.equals(previousArn, resource.getPhysicalId())) {
+ return new UpdateCleanupResult(true, true, previousArn, 0, null);
+ }
+ if ("Retain".equals(resource.getUpdateReplacePolicy())) {
+ return new UpdateCleanupResult(true, true, previousArn, 0, null);
+ }
+
+ int attempts = snapshot.path("cleanupAttempts").asInt(0);
+ String failureReason = snapshot.path("cleanupFailureReason").asText(null);
+ if (attempts >= 3) {
+ return new UpdateCleanupResult(
+ true, false, previousArn, attempts, failureReason);
+ }
+
+ try {
+ String previousRevisionId = snapshot.path("stateMachine")
+ .path("revisionId")
+ .asText(null);
+ StateMachine cleanupTarget = findStateMachine(previousArn);
+ if (cleanupTarget != null
+ && !stepFunctionsService.deleteStateMachineIfRevisionMatches(
+ previousArn, previousRevisionId)) {
+ throw new IllegalStateException(
+ "The old state machine no longer matches the replacement snapshot");
+ }
+ return new UpdateCleanupResult(
+ true, true, previousArn, attempts, null);
+ } catch (Exception e) {
+ attempts++;
+ ((ObjectNode) snapshot).put("cleanupAttempts", attempts);
+ ((ObjectNode) snapshot).put("cleanupFailureReason", e.getMessage());
+ resource.getAttributes().put(
+ SFN_UPDATE_SNAPSHOT_ATTR, snapshot.toString());
+ return new UpdateCleanupResult(
+ true, false, previousArn, attempts, e.getMessage());
+ }
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ "Could not finalize Step Functions state machine "
+ + resource.getLogicalId(), e);
}
- if (definition == null) {
+ }
+
+ String updateCleanupPhysicalId(StackResource resource) {
+ if ("Retain".equals(resource.getUpdateReplacePolicy())) {
return null;
}
+ String rawSnapshot = resource.getAttributes().get(SFN_UPDATE_SNAPSHOT_ATTR);
+ if (rawSnapshot == null) {
+ return null;
+ }
+ try {
+ JsonNode snapshot = objectMapper.readTree(rawSnapshot);
+ if (!snapshot.path("replacement").asBoolean(false)) {
+ return null;
+ }
+ return snapshot.path("physicalId").asText(null);
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ "Could not read Step Functions cleanup metadata for "
+ + resource.getLogicalId(), e);
+ }
+ }
+
+ boolean hasReplacementUpdate(StackResource resource) {
+ String rawSnapshot = resource.getAttributes().get(SFN_UPDATE_SNAPSHOT_ATTR);
+ if (rawSnapshot == null) {
+ return false;
+ }
+ try {
+ return objectMapper.readTree(rawSnapshot).path("replacement").asBoolean(false);
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ "Could not read Step Functions update metadata for "
+ + resource.getLogicalId(), e);
+ }
+ }
+
+ void clearUpdate(StackResource resource) {
+ resource.getAttributes().remove(SFN_UPDATE_SNAPSHOT_ATTR);
+ }
+
+ boolean rollbackUpdate(StackResource resource) {
+ String rawSnapshot = resource.getAttributes().get(SFN_UPDATE_SNAPSHOT_ATTR);
+ if (rawSnapshot == null) {
+ return false;
+ }
+ try {
+ JsonNode snapshot = objectMapper.readTree(rawSnapshot);
+ String previousArn = snapshot.path("physicalId").asText(null);
+ String replacementArn = snapshot.path("replacementArn").asText(
+ resource.getPhysicalId());
+ String replacementRevisionId = snapshot.path("replacementRevisionId")
+ .asText(null);
+ if (snapshot.path("replacement").asBoolean(false)
+ && replacementArn != null
+ && !Objects.equals(previousArn, replacementArn)) {
+ stepFunctionsService.deleteStateMachineIfRevisionMatches(
+ replacementArn, replacementRevisionId);
+ }
+
+ StateMachine previous = objectMapper.treeToValue(
+ snapshot.path("stateMachine"), StateMachine.class);
+ StateMachine current = findStateMachine(previousArn);
+ String restoredRevisionId = null;
+ if (current == null) {
+ throw new IllegalStateException(
+ "The original state machine no longer exists: " + previousArn);
+ }
+ if (!snapshot.path("replacement").asBoolean(false)) {
+ if (!stateMachineConfigurationMatches(
+ current,
+ previous.getDefinition(),
+ previous.getRoleArn(),
+ previous.getLoggingConfiguration(),
+ previous.getTracingConfiguration(),
+ previous.getEncryptionConfiguration())) {
+ stepFunctionsService.updateStateMachine(
+ previousArn,
+ new StepFunctionsService.UpdateStateMachineRequest(
+ previous.getDefinition(),
+ previous.getRoleArn(),
+ previous.getLoggingConfiguration(), true,
+ previous.getTracingConfiguration(), true,
+ previous.getEncryptionConfiguration(), true,
+ false,
+ null));
+ }
+ StateMachine restored = stepFunctionsService.describeStateMachine(previousArn);
+ restoredRevisionId = restored.getRevisionId();
+ if (!Objects.equals(restored.getTags(), previous.getTags())) {
+ stepFunctionsService.replaceStateMachineTags(
+ previousArn, previous.getTags());
+ }
+ }
+
+ resource.setPhysicalId(previousArn);
+ resource.getAttributes().clear();
+ JsonNode previousAttributes = snapshot.path("attributes");
+ previousAttributes.fields().forEachRemaining(entry ->
+ resource.getAttributes().put(entry.getKey(), entry.getValue().asText()));
+ if (restoredRevisionId != null) {
+ resource.getAttributes().put(
+ "StateMachineRevisionId", restoredRevisionId);
+ }
+ resource.setStatus("UPDATE_COMPLETE");
+ resource.setStatusReason(null);
+ return true;
+ } catch (Exception e) {
+ throw new IllegalStateException(
+ "Could not roll back Step Functions state machine "
+ + resource.getLogicalId(), e);
+ }
+ }
+
+ record UpdateCleanupResult(
+ boolean applicable,
+ boolean complete,
+ String previousPhysicalId,
+ int attempts,
+ String failureReason) {
+ }
+
+ private String resolveStateMachineDefinition(JsonNode props, CloudFormationTemplateEngine engine) {
+ if (props == null) {
+ throw new AwsException(
+ "ValidationError",
+ "A state machine definition is required",
+ 400);
+ }
+
+ boolean hasDefinitionString =
+ props.has("DefinitionString")
+ && !props.get("DefinitionString").isNull();
+ boolean hasDefinition =
+ props.has("Definition")
+ && !props.get("Definition").isNull();
+ boolean hasS3Location =
+ props.has("DefinitionS3Location")
+ && !props.get("DefinitionS3Location").isNull();
+ int sourceCount = (hasDefinitionString ? 1 : 0)
+ + (hasDefinition ? 1 : 0)
+ + (hasS3Location ? 1 : 0);
+ if (sourceCount != 1) {
+ throw new AwsException(
+ "ValidationError",
+ "Specify exactly one of Definition, DefinitionString, or DefinitionS3Location",
+ 400);
+ }
+
+ boolean definitionFromS3 = false;
+ String definition;
+ if (hasDefinitionString) {
+ definition = resolveOptional(props, "DefinitionString", engine);
+ } else if (hasDefinition) {
+ definition = engine.resolveNode(props.get("Definition")).toString();
+ } else {
+ JsonNode location = engine.resolveNode(props.get("DefinitionS3Location"));
+ String bucket = location.path("Bucket").asText(null);
+ String key = location.path("Key").asText(null);
+ String version = location.path("Version").asText(null);
+ if (bucket == null || bucket.isBlank() || key == null || key.isBlank()) {
+ throw new AwsException(
+ "ValidationError",
+ "DefinitionS3Location requires Bucket and Key",
+ 400);
+ }
+ S3Object object = s3Service.getObject(bucket, key, version);
+ definition = new String(object.getData(), StandardCharsets.UTF_8);
+ definitionFromS3 = true;
+ }
JsonNode subsNode = props.get("DefinitionSubstitutions");
- if (subsNode == null || subsNode.isNull()) {
- return definition;
+ if (subsNode != null && !subsNode.isNull()) {
+ JsonNode resolvedSubs = engine.resolveNode(subsNode);
+ Iterator<Map.Entry<String, JsonNode>> entries = resolvedSubs.fields();
+ while (entries.hasNext()) {
+ Map.Entry<String, JsonNode> entry = entries.next();
+ String placeholder = "${" + entry.getKey() + "}";
+ String value = entry.getValue().isTextual()
+ ? entry.getValue().asText()
+ : entry.getValue().toString();
+ definition = definition.replace(placeholder, value);
+ }
}
- JsonNode resolvedSubs = engine.resolveNode(subsNode);
- Iterator<Map.Entry<String, JsonNode>> entries = resolvedSubs.fields();
- while (entries.hasNext()) {
- Map.Entry<String, JsonNode> entry = entries.next();
- String placeholder = "${" + entry.getKey() + "}";
- String value = entry.getValue().isTextual() ? entry.getValue().asText() : entry.getValue().toString();
- definition = definition.replace(placeholder, value);
+ if (definitionFromS3) {
+ try {
+ definition = new CloudFormationYamlParser(objectMapper)
+ .parse(definition)
+ .toString();
+ } catch (Exception e) {
+ throw new AwsException(
+ "ValidationError",
+ "DefinitionS3Location contains invalid JSON or YAML: "
+ + e.getMessage(),
+ 400);
+ }
}
+
return definition;
}
@@ -5669,7 +6240,8 @@ public class CloudFormationResourceProvisioner {
* Mirrors the naming pattern AWS CloudFormation uses when no explicit name is provided.
*/
private String generatePhysicalName(String stackName, String logicalId, int maxLength, boolean lowercase) {
- String suffix = UUID.randomUUID().toString().replace("-", "").substring(0, 12);
+ String suffix = UUID.randomUUID().toString().replace("-", "")
+ .substring(0, GENERATED_NAME_SUFFIX_LENGTH);
String base = stackName + "-" + logicalId;
if (lowercase) {
base = base.toLowerCase();
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
index edd987bae4..100c5463c2 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationService.java
@@ -526,7 +526,9 @@ public class CloudFormationService {
private void executeTemplate(Stack stack, String templateBody, Map<String, String> params,
boolean isCreate, String region, String accountId) {
- String previousTemplateBody = stack.getTemplateBody();
+ StackUpdateSnapshot previousState = snapshotForUpdate(stack);
+ boolean updateCommitted = false;
+ Set<String> attemptedResourceIds = new LinkedHashSet<>();
try {
JsonNode template = parseTemplate(templateBody);
stack.setOriginalTemplateBody(templateBody);
@@ -588,7 +590,17 @@ public class CloudFormationService {
stack.getResources().put(logicalId, resource);
}
- addEvent(stack, logicalId, null, type, "CREATE_IN_PROGRESS", null);
+ String inProgressStatus = isCreate
+ ? "CREATE_IN_PROGRESS"
+ : "UPDATE_IN_PROGRESS";
+ addEvent(
+ stack,
+ logicalId,
+ resource.getPhysicalId(),
+ type,
+ inProgressStatus,
+ null);
+ attemptedResourceIds.add(logicalId);
if ("AWS::CloudFormation::Stack".equals(type)) {
resource = executeNestedStack(stack, logicalId,
props.isMissingNode() ? null : props,
@@ -598,6 +610,15 @@ public class CloudFormationService {
engine, region, accountId, stack.getStackName(),
resource.getPhysicalId(), resource.getAttributes());
}
+ resource.setUpdateReplacePolicy(
+ resDef.path("UpdateReplacePolicy").asText(null));
+ if (!isCreate) {
+ if ("CREATE_COMPLETE".equals(resource.getStatus())) {
+ resource.setStatus("UPDATE_COMPLETE");
+ } else if ("CREATE_FAILED".equals(resource.getStatus())) {
+ resource.setStatus("UPDATE_FAILED");
+ }
+ }
// Both branches return a fresh StackResource, so the policy is carried over here
// rather than on the instance the loop started with.
resource.setDeletionPolicy(deletionPolicy);
@@ -616,6 +637,12 @@ public class CloudFormationService {
// Provisioners work on a copy of the stored resource metadata. Keep the
// last known-good identity and status when an update attempt fails so a
// later retry or stack deletion still manages the original resource.
+ // The rollback walker must also know this resource is already restored;
+ // otherwise an earlier UPDATE_COMPLETE status looks like an unhandled
+ // mutation and incorrectly turns a safe rollback into ROLLBACK_FAILED.
+ previousResource.getAttributes().put(
+ CloudFormationResourceProvisioner.UPDATE_ROLLBACK_RESTORED_ATTR,
+ "true");
stack.getResources().put(logicalId, previousResource);
}
break;
@@ -626,10 +653,9 @@ public class CloudFormationService {
// A resource failed to provision: stop, and (on create) roll back what we built so a
// corrected re-deploy starts from a clean slate (acceptance criterion #9).
if (failedResource != null) {
- if (!isCreate) {
- stack.setTemplateBody(previousTemplateBody);
- }
- rollbackFailedExecution(stack, region, isCreate, failedResource);
+ rollbackFailedExecution(
+ stack, region, isCreate, failedResource, previousState,
+ attemptedResourceIds);
return;
}
@@ -677,6 +703,24 @@ public class CloudFormationService {
exportName, value, stack.getStackName());
});
+ if (!isCreate) {
+ updateCommitted = true;
+ if (hasReplacementUpdates(stack)) {
+ stack.setStatus("UPDATE_COMPLETE_CLEANUP_IN_PROGRESS");
+ stack.setLastUpdatedTime(now());
+ addEvent(stack, stack.getStackName(), stack.getStackId(),
+ "AWS::CloudFormation::Stack",
+ "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", null);
+ // The committed template and new physical IDs must be durable before old
+ // resources are deleted during replacement cleanup.
+ persistStack(stack);
+ }
+ List<UpdateCleanupFailure> cleanupFailures =
+ finishCommittedResourceCleanup(stack);
+ finishCommittedStackUpdate(stack, cleanupFailures);
+ return;
+ }
+
String completeStatus = isCreate ? "CREATE_COMPLETE" : "UPDATE_COMPLETE";
stack.setStatus(completeStatus);
stack.setLastUpdatedTime(now());
@@ -686,31 +730,47 @@ public class CloudFormationService {
LOG.infov("Stack {0} execution complete: {1}", stack.getStackName(), completeStatus);
} catch (Exception e) {
- LOG.errorv("Stack {0} execution failed: {1}", stack.getStackName(), e.getMessage());
- if (!isCreate) {
- stack.setTemplateBody(previousTemplateBody);
+ if (!isCreate && updateCommitted) {
+ LOG.errorv(
+ "Stack {0} update cleanup could not finish: {1}",
+ stack.getStackName(), e.getMessage());
+ stack.setStatus("UPDATE_COMPLETE_CLEANUP_IN_PROGRESS");
+ stack.setStatusReason(e.getMessage());
+ stack.setLastUpdatedTime(now());
+ addEvent(stack, stack.getStackName(), stack.getStackId(),
+ "AWS::CloudFormation::Stack",
+ "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", e.getMessage());
+ persistStack(stack);
+ return;
}
+ LOG.errorv("Stack {0} execution failed: {1}", stack.getStackName(), e.getMessage());
String failStatus = isCreate ? "CREATE_FAILED" : "UPDATE_FAILED";
stack.setStatus(failStatus);
stack.setStatusReason(e.getMessage());
addEvent(stack, stack.getStackName(), stack.getStackId(),
"AWS::CloudFormation::Stack", failStatus, e.getMessage());
- persistStack(stack);
+ if (isCreate) {
+ persistStack(stack);
+ } else {
+ rollbackFailedUpdate(
+ stack, region, previousState, attemptedResourceIds, e.getMessage());
+ }
}
}
/**
* Handles a resource that failed to provision.
*
- * <p>On a <b>create</b>, rolls back by deleting the resources that were successfully created in
- * this execution, leaving a clean slate ({@code ROLLBACK_COMPLETE}) so a corrected re-deploy can
- * start from scratch. On an <b>update</b>, marks {@code UPDATE_ROLLBACK_COMPLETE}; the caller
- * restores the prior template and failed-resource metadata so retries and deletion continue to
- * manage the last known-good physical resource. Rolling back side effects from resources that
- * completed earlier in the failed update remains out of scope.
+ * <p>On a <b>create</b>, rolls back by deleting resources created by the failed execution. On
+ * an <b>update</b>, restores the prior resource, template, output, and export state.
*/
- private void rollbackFailedExecution(Stack stack, String region, boolean isCreate,
- StackResource failedResource) {
+ private void rollbackFailedExecution(
+ Stack stack,
+ String region,
+ boolean isCreate,
+ StackResource failedResource,
+ StackUpdateSnapshot previousState,
+ Set<String> attemptedResourceIds) {
String failStatus = isCreate ? "CREATE_FAILED" : "UPDATE_FAILED";
stack.setStatus(failStatus);
stack.setStatusReason(failedResource.getStatusReason());
@@ -740,20 +800,283 @@ public class CloudFormationService {
LOG.errorv("Stack {0} rollback failed: {1}", stack.getStackName(), reason);
}
} else {
- if ("true".equals(failedResource.getAttributes().remove(
- CloudFormationResourceProvisioner.UPDATE_ROLLBACK_RESTORED_ATTR))) {
- failedResource.setStatus("CREATE_COMPLETE");
- failedResource.setStatusReason(null);
+ rollbackFailedUpdate(
+ stack, region, previousState, attemptedResourceIds,
+ failedResource.getStatusReason());
+ return;
+ }
+ persistStack(stack);
+ }
+
+ private List<UpdateCleanupFailure> finishCommittedResourceCleanup(Stack stack) {
+ List<UpdateCleanupFailure> failures = new ArrayList<>();
+ for (StackResource resource : stack.getResources().values()) {
+ String cleanupPhysicalId = provisioner.updateCleanupPhysicalId(resource);
+ if (cleanupPhysicalId != null) {
+ addEvent(
+ stack,
+ resource.getLogicalId(),
+ cleanupPhysicalId,
+ resource.getResourceType(),
+ "DELETE_IN_PROGRESS",
+ null);
}
+ while (true) {
+ CloudFormationResourceProvisioner.UpdateCleanupResult result =
+ provisioner.completeUpdate(resource);
+ if (!result.applicable()) {
+ break;
+ }
+ if (result.complete()) {
+ if (cleanupPhysicalId != null) {
+ addEvent(
+ stack,
+ resource.getLogicalId(),
+ cleanupPhysicalId,
+ resource.getResourceType(),
+ "DELETE_COMPLETE",
+ null);
+ }
+ provisioner.clearUpdate(resource);
+ break;
+ }
+ if (result.attempts() < 3) {
+ continue;
+ }
+
+ String reason = result.failureReason() != null
+ ? result.failureReason()
+ : "Resource deletion failed during update cleanup";
+ failures.add(new UpdateCleanupFailure(
+ resource.getLogicalId(), result.previousPhysicalId(), reason));
+ addEvent(
+ stack,
+ resource.getLogicalId(),
+ result.previousPhysicalId(),
+ resource.getResourceType(),
+ "DELETE_FAILED",
+ reason);
+ provisioner.clearUpdate(resource);
+ break;
+ }
+ }
+ return failures;
+ }
+
+ private void finishCommittedStackUpdate(
+ Stack stack, List<UpdateCleanupFailure> cleanupFailures) {
+ String statusReason = null;
+ if (!cleanupFailures.isEmpty()) {
+ statusReason = "The following resource(s) could not be deleted during update cleanup: ["
+ + cleanupFailures.stream()
+ .map(failure -> failure.logicalId()
+ + " (" + failure.physicalId() + ")")
+ .collect(java.util.stream.Collectors.joining(", "))
+ + "].";
+ }
+ stack.setStatus("UPDATE_COMPLETE");
+ stack.setStatusReason(statusReason);
+ stack.setLastUpdatedTime(now());
+ addEvent(stack, stack.getStackName(), stack.getStackId(),
+ "AWS::CloudFormation::Stack", "UPDATE_COMPLETE", statusReason);
+ persistStack(stack);
+ LOG.infov("Stack {0} execution complete: UPDATE_COMPLETE", stack.getStackName());
+ }
+
+ private boolean hasReplacementUpdates(Stack stack) {
+ return stack.getResources().values().stream()
+ .anyMatch(provisioner::hasReplacementUpdate);
+ }
+
+ private void rollbackFailedUpdate(
+ Stack stack,
+ String region,
+ StackUpdateSnapshot previousState,
+ Set<String> attemptedResourceIds,
+ String failureReason) {
+ stack.setStatus("UPDATE_ROLLBACK_IN_PROGRESS");
+ stack.setStatusReason(failureReason);
+ addEvent(stack, stack.getStackName(), stack.getStackId(),
+ "AWS::CloudFormation::Stack", "UPDATE_ROLLBACK_IN_PROGRESS", failureReason);
+
+ List<String> rollbackFailures = rollbackUpdatedResources(
+ stack, previousState.resources(), attemptedResourceIds, region);
+ if (rollbackFailures.isEmpty()) {
+ stack.setTemplateBody(previousState.templateBody());
+ }
+ try {
+ restoreOutputAndExportState(stack, region, previousState);
+ } catch (Exception e) {
+ rollbackFailures.add("Outputs");
+ LOG.errorv("Could not restore outputs and exports for stack {0}: {1}",
+ stack.getStackName(), e.getMessage());
+ }
+ stack.setLastUpdatedTime(now());
+ if (rollbackFailures.isEmpty()) {
stack.setStatus("UPDATE_ROLLBACK_COMPLETE");
- stack.setLastUpdatedTime(now());
+ stack.setStatusReason(null);
addEvent(stack, stack.getStackName(), stack.getStackId(),
"AWS::CloudFormation::Stack", "UPDATE_ROLLBACK_COMPLETE", null);
- LOG.infov("Stack {0} update rolled back (UPDATE_ROLLBACK_COMPLETE)", stack.getStackName());
+ LOG.infov("Stack {0} update rolled back (UPDATE_ROLLBACK_COMPLETE)",
+ stack.getStackName());
+ } else {
+ String reason = "The following resource(s) failed to roll back: ["
+ + String.join(", ", rollbackFailures) + "].";
+ stack.setStatus("UPDATE_ROLLBACK_FAILED");
+ stack.setStatusReason(reason);
+ addEvent(stack, stack.getStackName(), stack.getStackId(),
+ "AWS::CloudFormation::Stack", "UPDATE_ROLLBACK_FAILED", reason);
+ LOG.errorv("Stack {0} update rollback failed: {1}", stack.getStackName(), reason);
}
persistStack(stack);
}
+ private List<String> rollbackUpdatedResources(
+ Stack stack,
+ Map<String, StackResource> previousResources,
+ Set<String> attemptedResourceIds,
+ String region) {
+ List<StackResource> resources = new ArrayList<>(stack.getResources().values());
+ Collections.reverse(resources);
+ List<String> failures = new ArrayList<>();
+ List<String> removedResources = new ArrayList<>();
+ for (StackResource resource : resources) {
+ if (!attemptedResourceIds.contains(resource.getLogicalId())) {
+ continue;
+ }
+ try {
+ StackResource previous = previousResources.get(resource.getLogicalId());
+ if (previous == null) {
+ boolean rollbackOwned = "true".equals(resource.getAttributes().get(
+ CfnRollback.ROLLBACK_OWNED_ATTR));
+ if (resource.getPhysicalId() != null || rollbackOwned) {
+ addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
+ resource.getResourceType(), "DELETE_IN_PROGRESS",
+ "Resource creation cancelled during update rollback");
+ provisioner.delete(resource, region);
+ }
+ addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
+ resource.getResourceType(), "DELETE_COMPLETE",
+ "Resource creation cancelled during update rollback");
+ removedResources.add(resource.getLogicalId());
+ } else if ("true".equals(resource.getAttributes().remove(
+ CloudFormationResourceProvisioner.UPDATE_ROLLBACK_RESTORED_ATTR))
+ || provisioner.rollbackUpdate(resource)) {
+ resource.setStatus(previous.getStatus());
+ resource.setStatusReason(previous.getStatusReason());
+ addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
+ resource.getResourceType(), "UPDATE_COMPLETE",
+ "Resource update rolled back");
+ } else if (resource.getStatus() != null
+ && resource.getStatus().startsWith("UPDATE_")) {
+ String reason = "Rollback is not implemented for "
+ + resource.getResourceType();
+ failures.add(resource.getLogicalId());
+ resource.setStatus("UPDATE_FAILED");
+ resource.setStatusReason(reason);
+ addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
+ resource.getResourceType(), "UPDATE_FAILED", reason);
+ }
+ } catch (Exception e) {
+ failures.add(resource.getLogicalId());
+ resource.setStatus("UPDATE_FAILED");
+ resource.setStatusReason(e.getMessage());
+ addEvent(stack, resource.getLogicalId(), resource.getPhysicalId(),
+ resource.getResourceType(), "UPDATE_FAILED", e.getMessage());
+ LOG.errorv("Could not roll back resource {0}: {1}",
+ resource.getLogicalId(), e.getMessage());
+ }
+ }
+ removedResources.forEach(stack.getResources()::remove);
+ return failures;
+ }
+
+ private void restoreOutputAndExportState(
+ Stack stack, String region, StackUpdateSnapshot previousState) {
+ RuntimeException storageFailure = null;
+ for (String exportName : new ArrayList<>(stack.getExports().keySet())) {
+ String key = exportKey(region, exportName);
+ exports.remove(key);
+ try {
+ exportBackend.deleteForAccount(storageAccount, key);
+ } catch (RuntimeException e) {
+ storageFailure = appendFailure(storageFailure, e);
+ }
+ }
+
+ stack.getOutputs().clear();
+ stack.getOutputs().putAll(previousState.outputs());
+ stack.getExports().clear();
+ stack.getExports().putAll(previousState.exports());
+ stack.getOutputExportNames().clear();
+ stack.getOutputExportNames().putAll(previousState.outputExportNames());
+
+ for (Map.Entry<String, String> entry : previousState.exports().entrySet()) {
+ String key = exportKey(region, entry.getKey());
+ exports.put(key, entry.getValue());
+ try {
+ exportBackend.putForAccount(storageAccount, key, entry.getValue());
+ } catch (RuntimeException e) {
+ storageFailure = appendFailure(storageFailure, e);
+ }
+ }
+ if (storageFailure != null) {
+ throw storageFailure;
+ }
+ }
+
+ private static RuntimeException appendFailure(
+ RuntimeException existing, RuntimeException additional) {
+ if (existing == null) {
+ return additional;
+ }
+ existing.addSuppressed(additional);
+ return existing;
+ }
+
+ private StackUpdateSnapshot snapshotForUpdate(Stack stack) {
+ return new StackUpdateSnapshot(
+ stack.getTemplateBody(),
+ new LinkedHashMap<>(stack.getOutputs()),
+ new LinkedHashMap<>(stack.getExports()),
+ new LinkedHashMap<>(stack.getOutputExportNames()),
+ copyResources(stack.getResources()));
+ }
+
+ private Map<String, StackResource> copyResources(
+ Map<String, StackResource> resources) {
+ Map<String, StackResource> copies = new LinkedHashMap<>();
+ resources.forEach((logicalId, resource) ->
+ copies.put(logicalId, copyResource(resource)));
+ return copies;
+ }
+
+ private StackResource copyResource(StackResource source) {
+ StackResource copy = new StackResource();
+ copy.setLogicalId(source.getLogicalId());
+ copy.setPhysicalId(source.getPhysicalId());
+ copy.setResourceType(source.getResourceType());
+ copy.setStatus(source.getStatus());
+ copy.setStatusReason(source.getStatusReason());
+ copy.setDeletionPolicy(source.getDeletionPolicy());
+ copy.setUpdateReplacePolicy(source.getUpdateReplacePolicy());
+ copy.setTimestamp(source.getTimestamp());
+ copy.setAttributes(new HashMap<>(source.getAttributes()));
+ return copy;
+ }
+
+ private record StackUpdateSnapshot(
+ String templateBody,
+ Map<String, String> outputs,
+ Map<String, String> exports,
+ Map<String, String> outputExportNames,
+ Map<String, StackResource> resources) {
+ }
+
+ private record UpdateCleanupFailure(
+ String logicalId, String physicalId, String failureReason) {
+ }
+
/** Deletes every resource created in this execution, in reverse order. */
private List<String> rollbackCreatedResources(Stack stack, String region) {
List<StackResource> resources = new ArrayList<>(stack.getResources().values());
@@ -798,9 +1121,11 @@ public class CloudFormationService {
List<String> failedResources = new ArrayList<>();
for (StackResource resource : resources) {
- // CREATE_COMPLETE: first delete attempt. DELETE_FAILED: a previous delete left the
- // resource behind (e.g. the bucket was non-empty); AWS re-attempts it on retry.
+ // CREATE_COMPLETE/UPDATE_COMPLETE: first delete attempt. DELETE_FAILED: a previous
+ // delete left the resource behind (e.g. the bucket was non-empty); AWS re-attempts
+ // it on retry.
boolean deletable = "CREATE_COMPLETE".equals(resource.getStatus())
+ || "UPDATE_COMPLETE".equals(resource.getStatus())
|| "DELETE_FAILED".equals(resource.getStatus());
if (resource.getPhysicalId() == null || !deletable) {
continue;
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java
index a74e01dd83..e12a10fbf4 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/model/StackResource.java
@@ -16,6 +16,7 @@ public class StackResource {
private String deletionPolicy;
private String status = "CREATE_IN_PROGRESS";
private String statusReason;
+ private String updateReplacePolicy;
private Instant timestamp = Instant.now();
private Map<String, String> attributes = new HashMap<>();
@@ -31,6 +32,10 @@ public class StackResource {
public void setStatus(String status) { this.status = status; }
public String getStatusReason() { return statusReason; }
public void setStatusReason(String statusReason) { this.statusReason = statusReason; }
+ public String getUpdateReplacePolicy() { return updateReplacePolicy; }
+ public void setUpdateReplacePolicy(String updateReplacePolicy) {
+ this.updateReplacePolicy = updateReplacePolicy;
+ }
public Instant getTimestamp() { return timestamp; }
public void setTimestamp(Instant timestamp) { this.timestamp = timestamp; }
public Map<String, String> getAttributes() { return attributes; }
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
index d0fb078d31..c6784a64b4 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
@@ -34,6 +34,7 @@ public class StepFunctionsJsonHandler {
public Response handle(String action, JsonNode request, String region) {
return switch (action) {
case "CreateStateMachine" -> handleCreateStateMachine(request, region);
+ case "UpdateStateMachine" -> handleUpdateStateMachine(request);
case "DescribeStateMachine" -> handleDescribeStateMachine(request);
case "ListStateMachines" -> handleListStateMachines(request, region);
case "DeleteStateMachine" -> handleDeleteStateMachine(request);
@@ -65,27 +66,71 @@ public class StepFunctionsJsonHandler {
}
private Response handleCreateStateMachine(JsonNode request, String region) {
- StateMachine sm = service.createStateMachine(
- request.path("name").asText(),
- request.path("definition").asText(),
- request.path("roleArn").asText(),
- request.path("type").asText(null),
+ boolean publish = parseOptionalBoolean(request, "publish", false);
+ StepFunctionsService.CreateStateMachineResult result = service.createStateMachine(
+ requiredText(request, "name"),
+ requiredText(request, "definition"),
+ requiredText(request, "roleArn"),
+ optionalText(request, "type"),
region,
- parseTagsArray(request.path("tags"))
+ parseTagsArray(request.path("tags")),
+ request.get("loggingConfiguration"),
+ request.get("tracingConfiguration"),
+ request.get("encryptionConfiguration"),
+ publish,
+ optionalText(request, "versionDescription")
);
+ StateMachine sm = result.stateMachine();
ObjectNode response = objectMapper.createObjectNode();
response.put("stateMachineArn", sm.getStateMachineArn());
response.put("creationDate", sm.getCreationDate());
- // Publishing a version on create is opt-in (publish=true).
- if (request.path("publish").asBoolean(false)) {
- var version = service.publishStateMachineVersion(sm.getStateMachineArn());
- response.put("stateMachineVersionArn", version.getStateMachineVersionArn());
+ if (result.version() != null) {
+ response.put(
+ "stateMachineVersionArn",
+ result.version().getStateMachineVersionArn());
+ } else {
+ response.putNull("stateMachineVersionArn");
+ }
+ return Response.ok(response).build();
+ }
+
+ private Response handleUpdateStateMachine(JsonNode request) {
+ String stateMachineArn = requiredText(request, "stateMachineArn");
+ String definition = optionalText(request, "definition");
+ String roleArn = optionalText(request, "roleArn");
+ // AWS requires at least one updatable field; a bare stateMachineArn returns MissingRequiredParameter.
+ if (definition == null && roleArn == null) {
+ throw new AwsException("MissingRequiredParameter",
+ "Either the definition or the roleArn must be specified.", 400);
+ }
+ boolean publish = parseOptionalBoolean(request, "publish", false);
+ StepFunctionsService.UpdateStateMachineResult result = service.updateStateMachine(
+ stateMachineArn,
+ new StepFunctionsService.UpdateStateMachineRequest(
+ definition,
+ roleArn,
+ request.get("loggingConfiguration"), request.has("loggingConfiguration"),
+ request.get("tracingConfiguration"), request.has("tracingConfiguration"),
+ request.get("encryptionConfiguration"), request.has("encryptionConfiguration"),
+ publish,
+ optionalText(request, "versionDescription")));
+ StateMachine sm = result.stateMachine();
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("updateDate", sm.getUpdateDate());
+ response.put("revisionId", sm.getRevisionId());
+ if (result.version() != null) {
+ response.put("stateMachineVersionArn", result.version().getStateMachineVersionArn());
+ } else {
+ response.putNull("stateMachineVersionArn");
}
return Response.ok(response).build();
}
private Response handlePublishStateMachineVersion(JsonNode request) {
- var version = service.publishStateMachineVersion(request.path("stateMachineArn").asText());
+ var version = service.publishStateMachineVersion(
+ requiredText(request, "stateMachineArn"),
+ optionalText(request, "revisionId"),
+ optionalText(request, "description"));
ObjectNode response = objectMapper.createObjectNode();
response.put("stateMachineVersionArn", version.getStateMachineVersionArn());
response.put("creationDate", version.getCreationDate());
@@ -110,15 +155,40 @@ public class StepFunctionsJsonHandler {
}
private Response handleDescribeStateMachine(JsonNode request) {
- StateMachine sm = service.describeStateMachine(request.path("stateMachineArn").asText());
+ String includedData = optionalText(request, "includedData");
+ if (includedData != null
+ && !"ALL_DATA".equals(includedData)
+ && !"METADATA_ONLY".equals(includedData)) {
+ throw new AwsException(
+ "ValidationException",
+ "includedData must be ALL_DATA or METADATA_ONLY.", 400);
+ }
+ boolean metadataOnly = "METADATA_ONLY".equals(includedData);
+ StateMachine sm = service.describeStateMachine(
+ requiredText(request, "stateMachineArn"));
ObjectNode response = objectMapper.createObjectNode();
response.put("stateMachineArn", sm.getStateMachineArn());
response.put("name", sm.getName());
- response.put("definition", sm.getDefinition());
+ response.put("definition", metadataOnly ? "{}" : sm.getDefinition());
response.put("roleArn", sm.getRoleArn());
response.put("type", sm.getType());
response.put("status", sm.getStatus());
response.put("creationDate", sm.getCreationDate());
+ if (sm.getDescription() != null) {
+ response.put("description", sm.getDescription());
+ }
+ if (sm.getLoggingConfiguration() != null) {
+ response.set("loggingConfiguration", sm.getLoggingConfiguration());
+ }
+ if (sm.getTracingConfiguration() != null) {
+ response.set("tracingConfiguration", sm.getTracingConfiguration());
+ }
+ if (sm.getEncryptionConfiguration() != null) {
+ response.set("encryptionConfiguration", sm.getEncryptionConfiguration());
+ }
+ if (sm.getRevisionId() != null) {
+ response.put("revisionId", sm.getRevisionId());
+ }
return Response.ok(response).build();
}
@@ -390,6 +460,40 @@ public class StepFunctionsJsonHandler {
return tags;
}
+ private static String requiredText(JsonNode request, String fieldName) {
+ JsonNode node = request.get(fieldName);
+ if (node == null || node.isNull()) {
+ throw new AwsException("MissingRequiredParameter", fieldName + " is required.", 400);
+ }
+ if (!node.isTextual()) {
+ throw new AwsException("ValidationException", fieldName + " must be a string.", 400);
+ }
+ return node.asText();
+ }
+
+ private static String optionalText(JsonNode request, String fieldName) {
+ JsonNode node = request.get(fieldName);
+ if (node == null || node.isNull()) {
+ return null;
+ }
+ if (!node.isTextual()) {
+ throw new AwsException("ValidationException", fieldName + " must be a string.", 400);
+ }
+ return node.asText();
+ }
+
+ private static boolean parseOptionalBoolean(
+ JsonNode request, String fieldName, boolean defaultValue) {
+ JsonNode node = request.get(fieldName);
+ if (node == null || node.isNull()) {
+ return defaultValue;
+ }
+ if (!node.isBoolean()) {
+ throw new AwsException("ValidationException", fieldName + " must be a boolean.", 400);
+ }
+ return node.asBoolean();
+ }
+
/**
* Reads an optional integer field from the JSON request, rejecting wrong types
* with a typed ValidationException. JsonNode.asInt() silently coerces strings,
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
index 9b0a48d6cb..857f80e893 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
@@ -1,6 +1,7 @@
package io.github.hectorvent.floci.services.stepfunctions;
import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.AwsArnUtils;
import io.github.hectorvent.floci.core.common.RegionResolver;
import io.github.hectorvent.floci.core.storage.StorageBackend;
import io.github.hectorvent.floci.core.storage.StorageFactory;
@@ -82,34 +83,277 @@ public class StepFunctionsService implements Resettable {
// ──────────────────────────── State Machines ────────────────────────────
- public StateMachine createStateMachine(String name, String definition, String roleArn, String type, String region, Map<String, String> tags) {
- String arn = regionResolver.buildArn("states", region, "stateMachine:" + name);
- if (stateMachineStore.get(arn).isPresent()) {
- throw new AwsException("StateMachineAlreadyExists", "State machine already exists: " + arn, 400);
+ public StateMachine createStateMachine(String name, String definition, String roleArn, String type,
+ String region, Map<String, String> tags) {
+ return createStateMachine(name, definition, roleArn, type, region, tags, null, null, null);
+ }
+
+ public StateMachine createStateMachine(
+ String name,
+ String definition,
+ String roleArn,
+ String type,
+ String region,
+ Map<String, String> tags,
+ JsonNode loggingConfiguration,
+ JsonNode tracingConfiguration,
+ JsonNode encryptionConfiguration) {
+ return createStateMachineInternal(
+ name,
+ definition,
+ roleArn,
+ type,
+ region,
+ tags,
+ loggingConfiguration,
+ tracingConfiguration,
+ encryptionConfiguration,
+ false,
+ null,
+ null,
+ false).stateMachine();
+ }
+
+ public CreateStateMachineResult createStateMachine(
+ String name,
+ String definition,
+ String roleArn,
+ String type,
+ String region,
+ Map<String, String> tags,
+ JsonNode loggingConfiguration,
+ JsonNode tracingConfiguration,
+ JsonNode encryptionConfiguration,
+ boolean publish,
+ String versionDescription) {
+ return createStateMachineInternal(
+ name,
+ definition,
+ roleArn,
+ type,
+ region,
+ tags,
+ loggingConfiguration,
+ tracingConfiguration,
+ encryptionConfiguration,
+ publish,
+ versionDescription,
+ null,
+ true);
+ }
+
+ public StateMachine createStateMachineWithRevisionId(
+ String name,
+ String definition,
+ String roleArn,
+ String type,
+ String region,
+ Map<String, String> tags,
+ JsonNode loggingConfiguration,
+ JsonNode tracingConfiguration,
+ JsonNode encryptionConfiguration,
+ String revisionId) {
+ if (revisionId == null || revisionId.isBlank()) {
+ throw new IllegalArgumentException("revisionId is required");
}
+ return createStateMachineInternal(
+ name,
+ definition,
+ roleArn,
+ type,
+ region,
+ tags,
+ loggingConfiguration,
+ tracingConfiguration,
+ encryptionConfiguration,
+ false,
+ null,
+ revisionId,
+ false).stateMachine();
+ }
+ private synchronized CreateStateMachineResult createStateMachineInternal(
+ String name,
+ String definition,
+ String roleArn,
+ String type,
+ String region,
+ Map<String, String> tags,
+ JsonNode loggingConfiguration,
+ JsonNode tracingConfiguration,
+ JsonNode encryptionConfiguration,
+ boolean publish,
+ String versionDescription,
+ String initialRevisionId,
+ boolean allowIdempotentCreate) {
+ validateStateMachineName(name);
validateDefinition(definition);
+ validateRoleArn(roleArn);
+ validateStateMachineType(type);
+ validateConfigurations(loggingConfiguration, tracingConfiguration, encryptionConfiguration);
+ validateVersionDescription(publish, versionDescription);
+
+ String effectiveType = type == null || type.isBlank() ? "STANDARD" : type;
+ JsonNode effectiveLoggingConfiguration = loggingConfiguration != null
+ ? copyNode(loggingConfiguration) : defaultLoggingConfiguration();
+ JsonNode effectiveTracingConfiguration = tracingConfiguration != null
+ ? copyNode(tracingConfiguration) : defaultTracingConfiguration();
+ JsonNode effectiveEncryptionConfiguration = encryptionConfiguration != null
+ ? copyNode(encryptionConfiguration) : defaultEncryptionConfiguration();
+ String arn = regionResolver.buildArn("states", region, "stateMachine:" + name);
+ Optional<StateMachine> existing = stateMachineStore.get(arn);
+ if (existing.isPresent()) {
+ StateMachine stateMachine = existing.get();
+ if (allowIdempotentCreate
+ && isIdempotentCreateRequest(
+ stateMachine,
+ definition,
+ effectiveType,
+ effectiveLoggingConfiguration,
+ effectiveTracingConfiguration,
+ effectiveEncryptionConfiguration,
+ publish,
+ versionDescription)) {
+ return new CreateStateMachineResult(
+ copyStateMachine(stateMachine),
+ creationVersion(stateMachine));
+ }
+ throw new AwsException(
+ "StateMachineAlreadyExists",
+ "State machine already exists: " + arn,
+ 400);
+ }
StateMachine sm = new StateMachine();
sm.setStateMachineArn(arn);
sm.setName(name);
sm.setDefinition(definition);
sm.setRoleArn(roleArn);
- if (type != null && !type.isEmpty()) {
- sm.setType(type);
- }
+ sm.setType(effectiveType);
if (tags != null && !tags.isEmpty()) {
sm.getTags().putAll(tags);
}
-
+ sm.setRevisionId(initialRevisionId != null
+ ? initialRevisionId
+ : UUID.randomUUID().toString());
+ sm.setLoggingConfiguration(effectiveLoggingConfiguration);
+ sm.setTracingConfiguration(effectiveTracingConfiguration);
+ sm.setEncryptionConfiguration(effectiveEncryptionConfiguration);
+ sm.setCreationVersionDescription(versionDescription);
+
+ StateMachineVersion version = publish
+ ? addVersion(sm, versionDescription)
+ : null;
+ if (version != null) {
+ sm.setCreationVersionArn(version.getStateMachineVersionArn());
+ }
stateMachineStore.put(arn, sm);
LOG.infov("Created State Machine: {0}", arn);
- return sm;
+ return new CreateStateMachineResult(copyStateMachine(sm), version);
+ }
+
+ public record CreateStateMachineResult(
+ StateMachine stateMachine,
+ StateMachineVersion version) {
+ }
+
+ public record UpdateStateMachineRequest(
+ String definition,
+ String roleArn,
+ JsonNode loggingConfiguration,
+ boolean loggingConfigurationProvided,
+ JsonNode tracingConfiguration,
+ boolean tracingConfigurationProvided,
+ JsonNode encryptionConfiguration,
+ boolean encryptionConfigurationProvided,
+ boolean publish,
+ String versionDescription) {
+ }
+
+ public record UpdateStateMachineResult(StateMachine stateMachine, StateMachineVersion version) {
+ }
+
+ public synchronized UpdateStateMachineResult updateStateMachine(
+ String arn, UpdateStateMachineRequest request) {
+ validateUpdateStateMachineArn(arn);
+ if (request.definition() == null && request.roleArn() == null) {
+ throw new AwsException("MissingRequiredParameter",
+ "Either the definition or the roleArn must be specified.", 400);
+ }
+ if (request.definition() != null) {
+ validateDefinition(request.definition());
+ }
+ if (request.roleArn() != null) {
+ validateRoleArn(request.roleArn());
+ }
+ if (request.loggingConfigurationProvided()) {
+ validateLoggingConfiguration(request.loggingConfiguration());
+ }
+ if (request.tracingConfigurationProvided()) {
+ validateTracingConfiguration(request.tracingConfiguration());
+ }
+ if (request.encryptionConfigurationProvided()) {
+ validateEncryptionConfiguration(request.encryptionConfiguration());
+ }
+ validateVersionDescription(request.publish(), request.versionDescription());
+
+ StateMachine current = stateMachineStore.get(arn)
+ .orElseThrow(() -> new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist: " + arn, 400));
+ StateMachine updated = copyStateMachine(current);
+
+ if (request.definition() != null) {
+ updated.setDefinition(request.definition());
+ }
+ if (request.roleArn() != null) {
+ updated.setRoleArn(request.roleArn());
+ }
+ if (request.loggingConfigurationProvided()) {
+ updated.setLoggingConfiguration(copyNode(request.loggingConfiguration()));
+ }
+ if (request.tracingConfigurationProvided()) {
+ updated.setTracingConfiguration(copyNode(request.tracingConfiguration()));
+ }
+ if (request.encryptionConfigurationProvided()) {
+ updated.setEncryptionConfiguration(copyNode(request.encryptionConfiguration()));
+ }
+
+ updated.setRevisionId(UUID.randomUUID().toString());
+ updated.setUpdateDate(System.currentTimeMillis() / 1000.0);
+ StateMachineVersion version = request.publish()
+ ? addVersion(updated, request.versionDescription())
+ : null;
+ stateMachineStore.put(arn, updated);
+ LOG.infov("Updated State Machine: {0}", arn);
+ return new UpdateStateMachineResult(copyStateMachine(updated), version);
}
public StateMachine describeStateMachine(String arn) {
- return stateMachineStore.get(arn)
- .orElseThrow(() -> new AwsException("StateMachineDoesNotExist", "State machine does not exist", 400));
+ validateDescribeStateMachineArn(arn);
+ Optional<StateMachine> stateMachine = stateMachineStore.get(arn);
+ if (stateMachine.isPresent()) {
+ return copyStateMachine(stateMachine.get());
+ }
+
+ int versionSeparator = arn != null ? arn.lastIndexOf(':') : -1;
+ if (versionSeparator > 0 && versionSeparator < arn.length() - 1) {
+ String versionText = arn.substring(versionSeparator + 1);
+ if (versionText.chars().allMatch(Character::isDigit)) {
+ String baseArn = arn.substring(0, versionSeparator);
+ Optional<StateMachine> baseStateMachine = stateMachineStore.get(baseArn);
+ if (baseStateMachine.isPresent()) {
+ return baseStateMachine.get().getVersions().stream()
+ .filter(version -> arn.equals(version.getStateMachineVersionArn()))
+ .findFirst()
+ .map(version -> stateMachineFromVersion(baseStateMachine.get(), version))
+ .orElseThrow(() -> new AwsException(
+ "StateMachineDoesNotExist",
+ "State machine does not exist", 400));
+ }
+ }
+ }
+ throw new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist", 400);
}
public List<StateMachine> listStateMachines(String region) {
@@ -120,13 +364,39 @@ public class StepFunctionsService implements Resettable {
// ── State machine versions ──────────────────────────────────────────────
public StateMachineVersion publishStateMachineVersion(String stateMachineArn) {
- StateMachine sm = describeStateMachine(stateMachineArn);
- int next = sm.getVersionCounter() + 1;
- sm.setVersionCounter(next);
- StateMachineVersion version = new StateMachineVersion(
- stateMachineArn + ":" + next, next, System.currentTimeMillis() / 1000.0);
- sm.getVersions().add(version);
- stateMachineStore.put(stateMachineArn, sm);
+ return publishStateMachineVersion(stateMachineArn, null, null);
+ }
+
+ public synchronized StateMachineVersion publishStateMachineVersion(
+ String stateMachineArn,
+ String revisionId,
+ String description) {
+ validateStateMachineArn(stateMachineArn);
+ validateVersionDescription(true, description);
+ StateMachine current = stateMachineStore.get(stateMachineArn)
+ .orElseThrow(() -> new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist", 400));
+ if (revisionId != null && !Objects.equals(revisionId, current.getRevisionId())) {
+ throw new AwsException(
+ "ConflictException",
+ "The state machine revision does not match revisionId " + revisionId,
+ 409);
+ }
+
+ StateMachine updated = copyStateMachine(current);
+ if (updated.getRevisionId() == null) {
+ updated.setRevisionId(UUID.randomUUID().toString());
+ }
+ Optional<StateMachineVersion> existingVersion = updated.getVersions().stream()
+ .filter(version -> Objects.equals(
+ updated.getRevisionId(), version.getRevisionId()))
+ .findFirst();
+ if (existingVersion.isPresent()) {
+ return copyVersion(existingVersion.get());
+ }
+
+ StateMachineVersion version = addVersion(updated, description);
+ stateMachineStore.put(stateMachineArn, updated);
return version;
}
@@ -141,7 +411,8 @@ public class StepFunctionsService implements Resettable {
// second-resolution, so tie-break on the version number (also descending) to keep the order
// correct when several versions are published within the same second — otherwise the
// Terraform provider can latch onto the wrong version ARN.
- List<StateMachineVersion> versions = new ArrayList<>(sm.getVersions());
+ List<StateMachineVersion> versions = new ArrayList<>();
+ sm.getVersions().forEach(version -> versions.add(copyVersion(version)));
versions.sort(Comparator
.comparingDouble(StateMachineVersion::getCreationDate)
.thenComparingInt(StateMachineVersion::getVersion)
@@ -150,15 +421,18 @@ public class StepFunctionsService implements Resettable {
return List.copyOf(versions);
}
- public void deleteStateMachineVersion(String stateMachineVersionArn) {
+ public synchronized void deleteStateMachineVersion(String stateMachineVersionArn) {
int lastColon = stateMachineVersionArn.lastIndexOf(':');
if (lastColon < 0) {
return;
}
String baseArn = stateMachineVersionArn.substring(0, lastColon);
- stateMachineStore.get(baseArn).ifPresent(sm -> {
- sm.getVersions().removeIf(v -> stateMachineVersionArn.equals(v.getStateMachineVersionArn()));
- stateMachineStore.put(baseArn, sm);
+ stateMachineStore.get(baseArn).ifPresent(current -> {
+ StateMachine updated = copyStateMachine(current);
+ updated.getVersions().removeIf(
+ version -> stateMachineVersionArn.equals(
+ version.getStateMachineVersionArn()));
+ stateMachineStore.put(baseArn, updated);
});
}
@@ -166,6 +440,20 @@ public class StepFunctionsService implements Resettable {
stateMachineStore.delete(arn);
}
+ public synchronized boolean deleteStateMachineIfRevisionMatches(
+ String arn, String expectedRevisionId) {
+ Optional<StateMachine> existing = stateMachineStore.get(arn);
+ if (existing.isEmpty()) {
+ return false;
+ }
+ if (expectedRevisionId == null
+ || !Objects.equals(expectedRevisionId, existing.get().getRevisionId())) {
+ return false;
+ }
+ stateMachineStore.delete(arn);
+ return true;
+ }
+
// ──────────────────────────── Executions ────────────────────────────
public Execution startExecution(String stateMachineArn, String name, String input, String region) {
@@ -418,12 +706,205 @@ public class StepFunctionsService implements Resettable {
throw new AwsException("ResourceNotFound", "Resource not found: " + arn, 400);
}
+ public synchronized void replaceStateMachineTags(String arn, Map<String, String> tags) {
+ StateMachine current = stateMachineStore.get(arn)
+ .orElseThrow(() -> new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist: " + arn, 400));
+ StateMachine updated = copyStateMachine(current);
+ updated.setTags(new HashMap<>(tags != null ? tags : Map.of()));
+ stateMachineStore.put(arn, updated);
+ }
+
+ private StateMachineVersion addVersion(StateMachine stateMachine, String description) {
+ int next = stateMachine.getVersionCounter() + 1;
+ stateMachine.setVersionCounter(next);
+ StateMachineVersion version = new StateMachineVersion(
+ stateMachine.getStateMachineArn() + ":" + next,
+ next,
+ System.currentTimeMillis() / 1000.0);
+ version.setDescription(description);
+ version.setName(stateMachine.getName());
+ version.setDefinition(stateMachine.getDefinition());
+ version.setRoleArn(stateMachine.getRoleArn());
+ version.setType(stateMachine.getType());
+ version.setStatus(stateMachine.getStatus());
+ version.setRevisionId(stateMachine.getRevisionId());
+ version.setLoggingConfiguration(copyNode(stateMachine.getLoggingConfiguration()));
+ version.setTracingConfiguration(copyNode(stateMachine.getTracingConfiguration()));
+ version.setEncryptionConfiguration(copyNode(stateMachine.getEncryptionConfiguration()));
+ stateMachine.getVersions().add(version);
+ return copyVersion(version);
+ }
+
+ private StateMachine copyStateMachine(StateMachine source) {
+ StateMachine copy = new StateMachine();
+ copy.setStateMachineArn(source.getStateMachineArn());
+ copy.setName(source.getName());
+ copy.setDefinition(source.getDefinition());
+ copy.setRoleArn(source.getRoleArn());
+ copy.setType(source.getType());
+ copy.setStatus(source.getStatus());
+ copy.setCreationDate(source.getCreationDate());
+ copy.setUpdateDate(source.getUpdateDate());
+ copy.setRevisionId(source.getRevisionId());
+ copy.setDescription(source.getDescription());
+ copy.setLoggingConfiguration(source.getLoggingConfiguration() != null
+ ? copyNode(source.getLoggingConfiguration()) : defaultLoggingConfiguration());
+ copy.setTracingConfiguration(source.getTracingConfiguration() != null
+ ? copyNode(source.getTracingConfiguration()) : defaultTracingConfiguration());
+ copy.setEncryptionConfiguration(source.getEncryptionConfiguration() != null
+ ? copyNode(source.getEncryptionConfiguration()) : defaultEncryptionConfiguration());
+ copy.setTags(new HashMap<>(source.getTags() != null ? source.getTags() : Map.of()));
+ copy.setCreationVersionArn(source.getCreationVersionArn());
+ copy.setCreationVersionDescription(source.getCreationVersionDescription());
+ copy.setVersionCounter(source.getVersionCounter());
+ List<StateMachineVersion> versions = new ArrayList<>();
+ for (StateMachineVersion version :
+ source.getVersions() != null ? source.getVersions() : List.<StateMachineVersion>of()) {
+ versions.add(copyVersion(version));
+ }
+ copy.setVersions(versions);
+ return copy;
+ }
+
+ private boolean isIdempotentCreateRequest(
+ StateMachine existing,
+ String definition,
+ String type,
+ JsonNode loggingConfiguration,
+ JsonNode tracingConfiguration,
+ JsonNode encryptionConfiguration,
+ boolean publish,
+ String versionDescription) {
+ return Objects.equals(existing.getDefinition(), definition)
+ && Objects.equals(existing.getType(), type)
+ && Objects.equals(existing.getLoggingConfiguration(), loggingConfiguration)
+ && Objects.equals(existing.getTracingConfiguration(), tracingConfiguration)
+ && Objects.equals(existing.getEncryptionConfiguration(), encryptionConfiguration)
+ && (existing.getCreationVersionArn() != null) == publish
+ && Objects.equals(
+ existing.getCreationVersionDescription(),
+ versionDescription);
+ }
+
+ private StateMachineVersion creationVersion(StateMachine stateMachine) {
+ if (stateMachine.getCreationVersionArn() == null) {
+ return null;
+ }
+ return stateMachine.getVersions().stream()
+ .filter(version -> Objects.equals(
+ stateMachine.getCreationVersionArn(),
+ version.getStateMachineVersionArn()))
+ .findFirst()
+ .map(this::copyVersion)
+ .orElseGet(() -> new StateMachineVersion(
+ stateMachine.getCreationVersionArn(),
+ 1,
+ stateMachine.getCreationDate()));
+ }
+
+ private StateMachine stateMachineFromVersion(
+ StateMachine current, StateMachineVersion version) {
+ StateMachine described = new StateMachine();
+ described.setStateMachineArn(version.getStateMachineVersionArn());
+ described.setName(version.getName() != null ? version.getName() : current.getName());
+ described.setDefinition(version.getDefinition() != null
+ ? version.getDefinition() : current.getDefinition());
+ described.setRoleArn(version.getRoleArn() != null
+ ? version.getRoleArn() : current.getRoleArn());
+ described.setType(version.getType() != null ? version.getType() : current.getType());
+ described.setStatus(version.getStatus() != null
+ ? version.getStatus() : current.getStatus());
+ described.setCreationDate(version.getCreationDate());
+ described.setRevisionId(version.getRevisionId() != null
+ ? version.getRevisionId() : current.getRevisionId());
+ described.setDescription(version.getDescription());
+ described.setLoggingConfiguration(version.getLoggingConfiguration() != null
+ ? copyNode(version.getLoggingConfiguration())
+ : copyNode(current.getLoggingConfiguration()));
+ described.setTracingConfiguration(version.getTracingConfiguration() != null
+ ? copyNode(version.getTracingConfiguration())
+ : copyNode(current.getTracingConfiguration()));
+ described.setEncryptionConfiguration(version.getEncryptionConfiguration() != null
+ ? copyNode(version.getEncryptionConfiguration())
+ : copyNode(current.getEncryptionConfiguration()));
+ return described;
+ }
+
+ private StateMachineVersion copyVersion(StateMachineVersion source) {
+ StateMachineVersion copy = new StateMachineVersion(
+ source.getStateMachineVersionArn(),
+ source.getVersion(),
+ source.getCreationDate());
+ copy.setDescription(source.getDescription());
+ copy.setName(source.getName());
+ copy.setDefinition(source.getDefinition());
+ copy.setRoleArn(source.getRoleArn());
+ copy.setType(source.getType());
+ copy.setStatus(source.getStatus());
+ copy.setRevisionId(source.getRevisionId());
+ copy.setLoggingConfiguration(copyNode(source.getLoggingConfiguration()));
+ copy.setTracingConfiguration(copyNode(source.getTracingConfiguration()));
+ copy.setEncryptionConfiguration(copyNode(source.getEncryptionConfiguration()));
+ return copy;
+ }
+
+ private record VersionArn(String baseArn, int version) {
+ }
+
+ private static VersionArn parseVersionArn(String arn) {
+ if (arn == null) {
+ return null;
+ }
+ int separator = arn.lastIndexOf(':');
+ if (separator < 0 || separator == arn.length() - 1) {
+ return null;
+ }
+ String suffix = arn.substring(separator + 1);
+ if (!suffix.chars().allMatch(Character::isDigit)) {
+ return null;
+ }
+ try {
+ return new VersionArn(
+ arn.substring(0, separator),
+ Integer.parseInt(suffix));
+ } catch (NumberFormatException ignored) {
+ return null;
+ }
+ }
+
+ private static JsonNode copyNode(JsonNode node) {
+ return node == null ? null : node.deepCopy();
+ }
+
+ private JsonNode defaultLoggingConfiguration() {
+ var configuration = objectMapper.createObjectNode();
+ configuration.put("level", "OFF");
+ configuration.put("includeExecutionData", false);
+ configuration.putArray("destinations");
+ return configuration;
+ }
+
+ private JsonNode defaultTracingConfiguration() {
+ return objectMapper.createObjectNode().put("enabled", false);
+ }
+
+ private JsonNode defaultEncryptionConfiguration() {
+ return objectMapper.createObjectNode().put("type", "AWS_OWNED_KEY");
+ }
+
// ──────────────────────────── Validation ────────────────────────────
public record Diagnostic(String severity, String code, String message, String location) {}
public record ValidationResult(boolean valid, List<Diagnostic> diagnostics, boolean truncated) {}
private static final int MAX_DEFINITION_LENGTH = 1_048_576;
+ private static final int MAX_ARN_LENGTH = 256;
+ private static final int MAX_VERSION_DESCRIPTION_LENGTH = 256;
+ private static final String INVALID_STATE_MACHINE_NAME_CHARACTERS =
+ "<>[]{}?*\"#%\\^|~`$&,;:/";
+ private static final Set<String> STATE_TYPES = Set.of(
+ "Pass", "Task", "Choice", "Wait", "Succeed", "Fail", "Parallel", "Map");
private static final String PARSE_ERROR_MARKER = "INVALID_JSON_DESCRIPTION:";
// Parse the structured location out of validator flat error strings,
@@ -512,7 +993,246 @@ public class StepFunctionsService implements Resettable {
return new Diagnostic("ERROR", code, message, location);
}
+ private static void validateStateMachineName(String name) {
+ boolean invalidCharacter = name != null && name.codePoints().anyMatch(codePoint ->
+ Character.isWhitespace(codePoint)
+ || Character.isISOControl(codePoint)
+ || INVALID_STATE_MACHINE_NAME_CHARACTERS.indexOf(codePoint) >= 0);
+ if (name == null || name.isBlank() || name.length() > 80 || invalidCharacter) {
+ throw new AwsException(
+ "InvalidName",
+ "Invalid state machine name: '" + name + "'",
+ 400);
+ }
+ }
+
+ private static void validateStateMachineArn(String arn) {
+ if (arn == null || arn.isBlank() || arn.length() > MAX_ARN_LENGTH) {
+ throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
+ }
+ try {
+ AwsArnUtils.Arn parsed = AwsArnUtils.parse(arn);
+ String resource = parsed.resource();
+ String name = resource != null && resource.startsWith("stateMachine:")
+ ? resource.substring("stateMachine:".length())
+ : null;
+ if (!"states".equals(parsed.service())
+ || parsed.region().isBlank()
+ || parsed.accountId().isBlank()
+ || name == null
+ || name.isBlank()
+ || name.length() > 80
+ || name.indexOf(':') >= 0
+ || name.chars().anyMatch(Character::isWhitespace)) {
+ throw new IllegalArgumentException("Invalid state machine ARN");
+ }
+ } catch (IllegalArgumentException e) {
+ throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
+ }
+ }
+
+ private static void validateDescribeStateMachineArn(String arn) {
+ if (arn == null || arn.isBlank() || arn.length() > MAX_ARN_LENGTH) {
+ throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
+ }
+ try {
+ AwsArnUtils.Arn parsed = AwsArnUtils.parse(arn);
+ String resource = parsed.resource();
+ String name = resource != null && resource.startsWith("stateMachine:")
+ ? resource.substring("stateMachine:".length())
+ : null;
+ if ("states".equals(parsed.service())
+ && name != null
+ && name.indexOf('/') >= 0) {
+ throw new AwsException(
+ "ValidationException",
+ "DescribeStateMachine does not accept a qualified Distributed Map ARN.",
+ 400);
+ }
+ } catch (IllegalArgumentException e) {
+ throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
+ }
+
+ VersionArn versionArn = parseVersionArn(arn);
+ validateStateMachineArn(
+ versionArn != null ? versionArn.baseArn() : arn);
+ }
+
+ private static void validateUpdateStateMachineArn(String arn) {
+ if (arn != null && arn.length() <= MAX_ARN_LENGTH) {
+ try {
+ AwsArnUtils.Arn parsed = AwsArnUtils.parse(arn);
+ String resource = parsed.resource();
+ String name = resource != null && resource.startsWith("stateMachine:")
+ ? resource.substring("stateMachine:".length())
+ : null;
+ int qualifierSeparator = name != null ? name.indexOf('/') : -1;
+ if ("states".equals(parsed.service())
+ && !parsed.region().isBlank()
+ && !parsed.accountId().isBlank()
+ && qualifierSeparator > 0
+ && qualifierSeparator < name.length() - 1) {
+ throw new AwsException("ValidationException",
+ "UpdateStateMachine does not accept a qualified Distributed Map ARN.",
+ 400);
+ }
+ } catch (IllegalArgumentException ignored) {
+ // The general validator below maps malformed input to InvalidArn.
+ }
+ }
+ validateStateMachineArn(arn);
+ }
+
+ private static void validateRoleArn(String roleArn) {
+ if (roleArn == null || roleArn.isBlank() || roleArn.length() > MAX_ARN_LENGTH) {
+ throw new AwsException("InvalidArn", "Invalid roleArn: '" + roleArn + "'", 400);
+ }
+ try {
+ AwsArnUtils.Arn parsed = AwsArnUtils.parse(roleArn);
+ String resource = parsed.resource();
+ if (!"iam".equals(parsed.service())
+ || !parsed.region().isEmpty()
+ || parsed.accountId().isBlank()
+ || resource == null
+ || !resource.startsWith("role/")
+ || resource.length() == "role/".length()
+ || roleArn.chars().anyMatch(Character::isWhitespace)) {
+ throw new IllegalArgumentException("Invalid IAM role ARN");
+ }
+ } catch (IllegalArgumentException e) {
+ throw new AwsException("InvalidArn", "Invalid roleArn: '" + roleArn + "'", 400);
+ }
+ }
+
+ private static void validateStateMachineType(String type) {
+ if (type != null && !type.isBlank()
+ && !"STANDARD".equals(type) && !"EXPRESS".equals(type)) {
+ throw new AwsException("StateMachineTypeNotSupported",
+ "State machine type must be STANDARD or EXPRESS.", 400);
+ }
+ }
+
+ private static void validateConfigurations(
+ JsonNode loggingConfiguration,
+ JsonNode tracingConfiguration,
+ JsonNode encryptionConfiguration) {
+ if (loggingConfiguration != null) {
+ validateLoggingConfiguration(loggingConfiguration);
+ }
+ if (tracingConfiguration != null) {
+ validateTracingConfiguration(tracingConfiguration);
+ }
+ if (encryptionConfiguration != null) {
+ validateEncryptionConfiguration(encryptionConfiguration);
+ }
+ }
+
+ private static void validateVersionDescription(boolean publish, String description) {
+ if (description != null && !publish) {
+ throw new AwsException("ValidationException",
+ "versionDescription can only be specified when publish is true.", 400);
+ }
+ if (description != null && description.length() > MAX_VERSION_DESCRIPTION_LENGTH) {
+ throw new AwsException("ValidationException",
+ "versionDescription exceeds maximum length of "
+ + MAX_VERSION_DESCRIPTION_LENGTH + " characters.", 400);
+ }
+ }
+
+ private static void validateLoggingConfiguration(JsonNode configuration) {
+ if (configuration == null || !configuration.isObject()) {
+ throw new AwsException("InvalidLoggingConfiguration",
+ "loggingConfiguration must be an object.", 400);
+ }
+
+ JsonNode levelNode = configuration.get("level");
+ String level = levelNode == null ? "OFF" : levelNode.asText(null);
+ if (level == null || !Set.of("ALL", "ERROR", "FATAL", "OFF").contains(level)) {
+ throw new AwsException("InvalidLoggingConfiguration",
+ "loggingConfiguration.level must be ALL, ERROR, FATAL, or OFF.", 400);
+ }
+ JsonNode includeExecutionData = configuration.get("includeExecutionData");
+ if (includeExecutionData != null && !includeExecutionData.isBoolean()) {
+ throw new AwsException("InvalidLoggingConfiguration",
+ "loggingConfiguration.includeExecutionData must be a boolean.", 400);
+ }
+
+ JsonNode destinations = configuration.get("destinations");
+ if (destinations != null && (!destinations.isArray() || destinations.size() > 1)) {
+ throw new AwsException("InvalidLoggingConfiguration",
+ "loggingConfiguration.destinations must contain at most one destination.", 400);
+ }
+ if (!"OFF".equals(level) && (destinations == null || destinations.isEmpty())) {
+ throw new AwsException("InvalidLoggingConfiguration",
+ "A logging destination is required when the log level is not OFF.", 400);
+ }
+ if (destinations != null) {
+ for (JsonNode destination : destinations) {
+ String logGroupArn = destination.path("cloudWatchLogsLogGroup")
+ .path("logGroupArn").asText(null);
+ if (logGroupArn == null || logGroupArn.isBlank()) {
+ throw new AwsException("InvalidLoggingConfiguration",
+ "Each logging destination must include a CloudWatch Logs logGroupArn.", 400);
+ }
+ }
+ }
+ }
+
+ private static void validateTracingConfiguration(JsonNode configuration) {
+ if (configuration == null || !configuration.isObject()) {
+ throw new AwsException("InvalidTracingConfiguration",
+ "tracingConfiguration must be an object.", 400);
+ }
+ JsonNode enabled = configuration.get("enabled");
+ if (enabled != null && !enabled.isBoolean()) {
+ throw new AwsException("InvalidTracingConfiguration",
+ "tracingConfiguration.enabled must be a boolean.", 400);
+ }
+ }
+
+ private static void validateEncryptionConfiguration(JsonNode configuration) {
+ if (configuration == null || !configuration.isObject()) {
+ throw new AwsException("InvalidEncryptionConfiguration",
+ "encryptionConfiguration must be an object.", 400);
+ }
+ JsonNode typeNode = configuration.get("type");
+ String type = typeNode != null && typeNode.isTextual() ? typeNode.asText() : null;
+ if (!"AWS_OWNED_KEY".equals(type) && !"CUSTOMER_MANAGED_KMS_KEY".equals(type)) {
+ throw new AwsException("InvalidEncryptionConfiguration",
+ "encryptionConfiguration.type must be AWS_OWNED_KEY or CUSTOMER_MANAGED_KMS_KEY.", 400);
+ }
+
+ JsonNode keyId = configuration.get("kmsKeyId");
+ if (keyId != null
+ && (!keyId.isTextual() || keyId.asText().isBlank() || keyId.asText().length() > 2048)) {
+ throw new AwsException("InvalidEncryptionConfiguration",
+ "encryptionConfiguration.kmsKeyId must contain between 1 and 2048 characters.", 400);
+ }
+ if ("CUSTOMER_MANAGED_KMS_KEY".equals(type) && keyId == null) {
+ throw new AwsException("InvalidEncryptionConfiguration",
+ "encryptionConfiguration.kmsKeyId is required for a customer-managed key.", 400);
+ }
+
+ JsonNode reusePeriod = configuration.get("kmsDataKeyReusePeriodSeconds");
+ if (reusePeriod != null
+ && (!reusePeriod.isIntegralNumber()
+ || reusePeriod.asInt() < 60
+ || reusePeriod.asInt() > 900)) {
+ throw new AwsException("InvalidEncryptionConfiguration",
+ "encryptionConfiguration.kmsDataKeyReusePeriodSeconds must be between 60 and 900.", 400);
+ }
+ }
+
private void validateDefinition(String definition) {
+ if (definition == null || definition.isBlank()) {
+ throw new AwsException("InvalidDefinition",
+ "Invalid State Machine Definition: definition must not be empty.", 400);
+ }
+ if (definition.length() > MAX_DEFINITION_LENGTH) {
+ throw new AwsException("ValidationException",
+ "definition exceeds maximum length of "
+ + MAX_DEFINITION_LENGTH + " characters.", 400);
+ }
List<String> errors = collectValidationErrors(definition);
if (errors.isEmpty()) {
return;
@@ -538,22 +1258,63 @@ public class StepFunctionsService implements Resettable {
return errors;
}
+ if (def == null || !def.isObject()) {
+ errors.add("The state machine definition must be a JSON object");
+ return errors;
+ }
+
+ JsonNode startAtNode = def.get("StartAt");
+ String startAt = startAtNode != null && startAtNode.isTextual()
+ ? startAtNode.asText()
+ : null;
+ if (startAt == null || startAt.isBlank()) {
+ errors.add("The field 'StartAt' is required and must be a non-empty string");
+ }
+
+ JsonNode states = def.get("States");
+ if (states == null || !states.isObject() || states.isEmpty()) {
+ errors.add("The field 'States' is required and must be a non-empty object");
+ return errors;
+ }
+ if (startAt != null && !startAt.isBlank() && !states.has(startAt)) {
+ errors.add("The value of 'StartAt' must match a state in 'States'");
+ }
+
String topLevelQL = def.path("QueryLanguage").asText("JSONPath");
boolean topLevelJsonata = "JSONata".equals(topLevelQL);
- JsonNode states = def.path("States");
- if (states.isObject()) {
- var fields = states.fields();
- while (fields.hasNext()) {
- var entry = fields.next();
- validateState("/States/" + entry.getKey(), entry.getValue(), topLevelJsonata, errors);
- }
+ var fields = states.fields();
+ while (fields.hasNext()) {
+ var entry = fields.next();
+ validateState("/States/" + entry.getKey(), entry.getValue(), topLevelJsonata, errors);
}
return errors;
}
private void validateState(String statePath, JsonNode stateDef,
boolean topLevelJsonata, List<String> errors) {
+ if (!stateDef.isObject()) {
+ errors.add("State must be an object at " + statePath);
+ return;
+ }
+ String stateType = stateDef.path("Type").asText(null);
+ if (stateType == null || !STATE_TYPES.contains(stateType)) {
+ errors.add("State must declare a valid field 'Type' at " + statePath);
+ return;
+ }
+ boolean terminalType = "Succeed".equals(stateType) || "Fail".equals(stateType);
+ boolean choiceType = "Choice".equals(stateType);
+ boolean hasTerminalTransition = stateDef.path("End").asBoolean(false)
+ || stateDef.path("Next").isTextual();
+ if (!terminalType && !choiceType && !hasTerminalTransition) {
+ errors.add("State must declare either 'Next' or 'End' at " + statePath);
+ }
+ if (choiceType
+ && (!stateDef.path("Choices").isArray()
+ || stateDef.path("Choices").isEmpty())) {
+ errors.add("Choice state must declare a non-empty field 'Choices' at " + statePath);
+ }
+
String stateQL = stateDef.path("QueryLanguage").asText(null);
boolean stateIsJsonata = stateQL != null ? "JSONata".equals(stateQL) : topLevelJsonata;
@@ -567,7 +1328,7 @@ public class StepFunctionsService implements Resettable {
}
}
- if ("Map".equals(stateDef.path("Type").asText())) {
+ if ("Map".equals(stateType)) {
validateMapConcurrency(statePath, stateDef, stateIsJsonata, errors);
if (stateDef.has("ItemReader")) {
validateItemReader(statePath, stateDef, errors);
@@ -578,7 +1339,7 @@ public class StepFunctionsService implements Resettable {
String processorField = stateDef.has("ItemProcessor") ? "ItemProcessor" : "Iterator";
validateNestedStates(stateDef.path(processorField).path("States"),
statePath + "/" + processorField + "/States", topLevelJsonata, errors);
- } else if ("Parallel".equals(stateDef.path("Type").asText())) {
+ } else if ("Parallel".equals(stateType)) {
JsonNode branches = stateDef.path("Branches");
if (branches.isArray()) {
for (int i = 0; i < branches.size(); i++) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.java
index 45cfa61675..57536a7aca 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.java
@@ -1,6 +1,7 @@
package io.github.hectorvent.floci.services.stepfunctions.model;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.JsonNode;
import io.quarkus.runtime.annotations.RegisterForReflection;
import java.util.ArrayList;
@@ -18,7 +19,15 @@ public class StateMachine {
private String type = "STANDARD";
private String status = "ACTIVE";
private double creationDate;
+ private Double updateDate;
+ private String revisionId;
+ private String description;
+ private JsonNode loggingConfiguration;
+ private JsonNode tracingConfiguration;
+ private JsonNode encryptionConfiguration;
private Map<String, String> tags = new HashMap<>();
+ private String creationVersionArn;
+ private String creationVersionDescription;
private int versionCounter = 0;
private List<StateMachineVersion> versions = new ArrayList<>();
@@ -47,9 +56,37 @@ public class StateMachine {
public double getCreationDate() { return creationDate; }
public void setCreationDate(double creationDate) { this.creationDate = creationDate; }
+ public Double getUpdateDate() { return updateDate; }
+ public void setUpdateDate(Double updateDate) { this.updateDate = updateDate; }
+
+ public String getRevisionId() { return revisionId; }
+ public void setRevisionId(String revisionId) { this.revisionId = revisionId; }
+
+ public String getDescription() { return description; }
+ public void setDescription(String description) { this.description = description; }
+
+ public JsonNode getLoggingConfiguration() { return loggingConfiguration; }
+ public void setLoggingConfiguration(JsonNode loggingConfiguration) { this.loggingConfiguration = loggingConfiguration; }
+
+ public JsonNode getTracingConfiguration() { return tracingConfiguration; }
+ public void setTracingConfiguration(JsonNode tracingConfiguration) { this.tracingConfiguration = tracingConfiguration; }
+
+ public JsonNode getEncryptionConfiguration() { return encryptionConfiguration; }
+ public void setEncryptionConfiguration(JsonNode encryptionConfiguration) { this.encryptionConfiguration = encryptionConfiguration; }
+
public Map<String, String> getTags() { return tags; }
public void setTags(Map<String, String> tags) { this.tags = tags; }
+ public String getCreationVersionArn() { return creationVersionArn; }
+ public void setCreationVersionArn(String creationVersionArn) {
+ this.creationVersionArn = creationVersionArn;
+ }
+
+ public String getCreationVersionDescription() { return creationVersionDescription; }
+ public void setCreationVersionDescription(String creationVersionDescription) {
+ this.creationVersionDescription = creationVersionDescription;
+ }
+
public int getVersionCounter() { return versionCounter; }
public void setVersionCounter(int versionCounter) { this.versionCounter = versionCounter; }
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.java
index 805a69a620..cc1e322f8a 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.java
@@ -1,6 +1,7 @@
package io.github.hectorvent.floci.services.stepfunctions.model;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.JsonNode;
import io.quarkus.runtime.annotations.RegisterForReflection;
/** A published version of a state machine ({@code <stateMachineArn>:<version>}). */
@@ -10,6 +11,16 @@ public class StateMachineVersion {
private String stateMachineVersionArn;
private int version;
private double creationDate;
+ private String description;
+ private String name;
+ private String definition;
+ private String roleArn;
+ private String type;
+ private String status;
+ private String revisionId;
+ private JsonNode loggingConfiguration;
+ private JsonNode tracingConfiguration;
+ private JsonNode encryptionConfiguration;
public StateMachineVersion() {
}
@@ -28,4 +39,34 @@ public class StateMachineVersion {
public double getCreationDate() { return creationDate; }
public void setCreationDate(double creationDate) { this.creationDate = creationDate; }
+
+ public String getDescription() { return description; }
+ public void setDescription(String description) { this.description = description; }
+
+ public String getName() { return name; }
+ public void setName(String name) { this.name = name; }
+
+ public String getDefinition() { return definition; }
+ public void setDefinition(String definition) { this.definition = definition; }
+
+ public String getRoleArn() { return roleArn; }
+ public void setRoleArn(String roleArn) { this.roleArn = roleArn; }
+
+ public String getType() { return type; }
+ public void setType(String type) { this.type = type; }
+
+ public String getStatus() { return status; }
+ public void setStatus(String status) { this.status = status; }
+
+ public String getRevisionId() { return revisionId; }
+ public void setRevisionId(String revisionId) { this.revisionId = revisionId; }
+
+ public JsonNode getLoggingConfiguration() { return loggingConfiguration; }
+ public void setLoggingConfiguration(JsonNode loggingConfiguration) { this.loggingConfiguration = loggingConfiguration; }
+
+ public JsonNode getTracingConfiguration() { return tracingConfiguration; }
+ public void setTracingConfiguration(JsonNode tracingConfiguration) { this.tracingConfiguration = tracingConfiguration; }
+
+ public JsonNode getEncryptionConfiguration() { return encryptionConfiguration; }
+ public void setEncryptionConfiguration(JsonNode encryptionConfiguration) { this.encryptionConfiguration = encryptionConfiguration; }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEventBusIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEventBusIntegrationTest.java
index d6c5d1a71b..220295bfe5 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEventBusIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationEventBusIntegrationTest.java
@@ -220,6 +220,31 @@ class CloudFormationEventBusIntegrationTest {
""".formatted(busName);
}
+ private static String eventBusAndNamedRuleTemplate(String busName, String description) {
+ return """
+ {
+ "Resources": {
+ "Bus": {
+ "Type": "AWS::Events::EventBus",
+ "Properties": {
+ "Name": "%s",
+ "Description": "%s"
+ }
+ },
+ "Rule": {
+ "Type": "AWS::Events::Rule",
+ "Properties": {
+ "Name": "%s-rule",
+ "EventBusName": { "Ref": "Bus" },
+ "EventPattern": { "source": ["com.example.orders"] },
+ "State": "ENABLED"
+ }
+ }
+ }
+ }
+ """.formatted(busName, description, busName);
+ }
+
@Test
void customEventBusIsRegisteredSoRuleReferencingItSucceeds() throws InterruptedException {
String suffix = Long.toString(System.nanoTime(), 36);
@@ -359,7 +384,7 @@ class CloudFormationEventBusIntegrationTest {
String suffix = Long.toString(System.nanoTime(), 36);
String busName = "update-bus-" + suffix;
String stackName = "eventbus-update-" + suffix;
- String originalTemplate = eventBusOnlyTemplate(busName, "before");
+ String originalTemplate = eventBusAndNamedRuleTemplate(busName, "before");
createStack(stackName, originalTemplate);
assertStackStatus(stackName, "CREATE_COMPLETE");
@@ -367,7 +392,7 @@ class CloudFormationEventBusIntegrationTest {
updateStack(stackName, originalTemplate);
assertStackStatus(stackName, "UPDATE_COMPLETE");
- updateStack(stackName, eventBusOnlyTemplate(busName, "after"));
+ updateStack(stackName, eventBusAndNamedRuleTemplate(busName, "after"));
assertStackStatus(stackName, "UPDATE_ROLLBACK_COMPLETE");
given()
@@ -388,6 +413,17 @@ class CloudFormationEventBusIntegrationTest {
deleteStack(stackName);
awaitStackDeleted(stackName);
+
+ given()
+ .contentType("application/x-amz-json-1.1")
+ .header("Authorization", EVENTS_AUTH)
+ .header("X-Amz-Target", "AWSEvents.DescribeEventBus")
+ .body("{\"Name\":\"" + busName + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("ResourceNotFoundException"));
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
index 83193b9611..a10b0a7ba0 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationIntegrationTest.java
@@ -9,6 +9,7 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -17,6 +18,7 @@ import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Base64;
+import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import static io.restassured.RestAssured.given;
@@ -44,6 +46,9 @@ class CloudFormationIntegrationTest {
@Inject
MutableClock clock;
+ @Inject
+ CloudFormationService cloudFormationService;
+
@BeforeAll
static void configureRestAssured() {
RestAssuredJsonUtils.configureAwsContentTypes();
@@ -7147,6 +7152,1567 @@ class CloudFormationIntegrationTest {
.body("__type", containsString("StateMachineDoesNotExist"));
}
+ @Test
+ void updateStack_stepFunctionsStateMachine_updatesInPlaceWithoutRecreateFailure() {
+ // Regression: a stack UPDATE that re-provisions a state machine must update it in place.
+ // Previously the provisioner always called CreateStateMachine, which failed with
+ // StateMachineAlreadyExists on the existing name and rolled the whole stack update back.
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-update-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"%s\\",\\"End\\":true}}}"
+ }
+ }
+ },
+ "Outputs": {
+ "StateMachineArn": { "Value": { "Ref": "MyStateMachine" } }
+ }
+ }
+ """;
+
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-cfn-update-stack-" + suffix;
+ String stateMachineName = "cfn-sfn-update-pipeline-" + suffix;
+ String expectedArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + stateMachineName;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(stateMachineName, "marker-v1"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ // Update the definition; the StateMachineName is unchanged, so this is an in-place update.
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(stateMachineName, "marker-v2"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ // The stack update succeeded (no UPDATE_ROLLBACK), and the ARN is stable across the update.
+ String describeXml = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+ assertThat(describeXml, containsString("<StackStatus>UPDATE_COMPLETE</StackStatus>"));
+ assertThat(describeXml, containsString("<OutputValue>" + expectedArn + "</OutputValue>"));
+
+ // The state machine kept its ARN and reflects the updated definition.
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + expectedArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("marker-v2"))
+ .body("definition", not(containsString("marker-v1")));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_stepFunctionsStateMachine_replacesAndClearsTags() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-cfn-tags-" + suffix;
+ String stateMachineName = "cfn-sfn-tags-" + suffix;
+ String stateMachineArn = "arn:aws:states:us-east-1:000000000000:stateMachine:" + stateMachineName;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-tags-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"%s\\",\\"End\\":true}}}"%s
+ }
+ }
+ }
+ }
+ """;
+ String initialTags = """
+ ,
+ "Tags": [
+ {"Key": "removed", "Value": "old"},
+ {"Key": "retained", "Value": "v1"}
+ ]
+ """;
+ String replacementTags = """
+ ,
+ "Tags": [
+ {"Key": "retained", "Value": "v2"},
+ {"Key": "added", "Value": "new"}
+ ]
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(stateMachineName, "marker-v1", initialTags))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(stateMachineName, "marker-v2", replacementTags))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.ListTagsForResource")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"resourceArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("tags.size()", equalTo(2))
+ .body("tags.find { it.key == 'retained' }.value", equalTo("v2"))
+ .body("tags.find { it.key == 'added' }.value", equalTo("new"))
+ .body("tags.find { it.key == 'removed' }", nullValue());
+
+ // Omitting Tags from the new CloudFormation resource model removes all previously managed tags.
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(stateMachineName, "marker-v3", ""))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.ListTagsForResource")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"resourceArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("tags.size()", equalTo(0));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_stepFunctionsTagOnlyChangeDoesNotCreateRevision() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-tag-only-" + suffix;
+ String stateMachineName = "sfn-tag-only-machine-" + suffix;
+ String stateMachineArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + stateMachineName;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-tag-only-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"End\\":true}}}",
+ "Tags": %s
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(
+ stateMachineName, "[{\"Key\":\"stage\",\"Value\":\"one\"}]"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String initialRevision = given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().jsonPath().getString("revisionId");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(
+ stateMachineName, "[{\"Key\":\"stage\",\"Value\":\"two\"}]"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("revisionId", equalTo(initialRevision));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.ListTagsForResource")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"resourceArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("tags.size()", equalTo(1))
+ .body("tags[0].key", equalTo("stage"))
+ .body("tags[0].value", equalTo("two"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_laterFailureRestoresStepFunctionsStateAndTemplate() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-update-rollback-" + suffix;
+ String stateMachineName = "sfn-update-rollback-machine-" + suffix;
+ String exportName = "sfn-update-rollback-export-" + suffix;
+ String stateMachineArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + stateMachineName;
+ String initialTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-rollback-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"marker-v1\\",\\"End\\":true}}}",
+ "Tags": [{"Key":"stage","Value":"one"}]
+ }
+ }
+ },
+ "Outputs": {
+ "Marker": {
+ "Value": "old-output",
+ "Export": {"Name": "%s"}
+ }
+ }
+ }
+ """.formatted(stateMachineName, exportName);
+ String failingTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-rollback-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"marker-v2\\",\\"End\\":true}}}",
+ "Tags": [{"Key":"stage","Value":"two"}]
+ }
+ },
+ "BadSecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "DependsOn": "MyStateMachine",
+ "Properties": {
+ "Name": "sfn-update-rollback-secret-%s",
+ "SecretString": "explicit",
+ "GenerateSecretString": {"PasswordLength": 32}
+ }
+ }
+ },
+ "Outputs": {
+ "Marker": {
+ "Value": "new-output",
+ "Export": {"Name": "%s"}
+ }
+ }
+ }
+ """.formatted(stateMachineName, suffix, exportName);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", initialTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String initialRevision = given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().jsonPath().getString("revisionId");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", failingTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>UPDATE_ROLLBACK_COMPLETE</StackStatus>"))
+ .body(containsString("<OutputValue>old-output</OutputValue>"))
+ .body(not(containsString("<OutputValue>new-output</OutputValue>")));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "ListExports")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<Name>" + exportName + "</Name>"))
+ .body(containsString("<Value>old-output</Value>"))
+ .body(not(containsString("<Value>new-output</Value>")));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("marker-v1"))
+ .body("definition", not(containsString("marker-v2")))
+ .body("revisionId", not(equalTo(initialRevision)));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.ListTagsForResource")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"resourceArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("tags[0].value", equalTo("one"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "GetTemplate")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("marker-v1"))
+ .body(not(containsString("marker-v2")));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_unsupportedResourceRollbackRemainsExplicitlyFailed() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "unsupported-update-rollback-" + suffix;
+ String parameterName = "/cfn/unsupported-update-rollback/" + suffix;
+ String template = """
+ {
+ "Resources": {
+ "Parameter": {
+ "Type": "AWS::SSM::Parameter",
+ "Properties": {
+ "Name": "%s",
+ "Type": "String",
+ "Value": "%s"
+ }
+ }
+ %s
+ }
+ }
+ """;
+ String initialTemplate = template.formatted(parameterName, "initial", "");
+ String failingTemplate = template.formatted(
+ parameterName,
+ "updated",
+ """
+ ,
+ "BadSecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "DependsOn": "Parameter",
+ "Properties": {
+ "Name": "unsupported-update-rollback-secret-%s",
+ "SecretString": "explicit",
+ "GenerateSecretString": {"PasswordLength": 32}
+ }
+ }
+ """.formatted(suffix));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", initialTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", failingTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>UPDATE_ROLLBACK_FAILED</StackStatus>"))
+ .body(containsString("Parameter"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<LogicalResourceId>Parameter</LogicalResourceId>"))
+ .body(containsString("<ResourceStatus>UPDATE_FAILED</ResourceStatus>"))
+ .body(not(containsString("<LogicalResourceId>BadSecret</LogicalResourceId>")));
+
+ given()
+ .header("X-Amz-Target", "AmazonSSM.GetParameter")
+ .contentType(SSM_CONTENT_TYPE)
+ .body("{\"Name\":\"" + parameterName + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("Parameter.Value", equalTo("updated"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "GetTemplate")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("updated"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_replacementFailureKeepsOldStateMachineAndDeletesNewOne() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-replacement-rollback-" + suffix;
+ String oldName = "sfn-replacement-old-" + suffix;
+ String newName = "sfn-replacement-new-" + suffix;
+ String oldArn = "arn:aws:states:us-east-1:000000000000:stateMachine:" + oldName;
+ String newArn = "arn:aws:states:us-east-1:000000000000:stateMachine:" + newName;
+ String initialTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-replacement-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"old-definition\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """.formatted(oldName);
+ String failingTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-replacement-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"new-definition\\",\\"End\\":true}}}"
+ }
+ },
+ "BadSecret": {
+ "Type": "AWS::SecretsManager::Secret",
+ "DependsOn": "MyStateMachine",
+ "Properties": {
+ "Name": "sfn-replacement-secret-%s",
+ "SecretString": "explicit",
+ "GenerateSecretString": {"PasswordLength": 32}
+ }
+ }
+ }
+ }
+ """.formatted(newName, suffix);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", initialTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", failingTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>UPDATE_ROLLBACK_COMPLETE</StackStatus>"));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + oldArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("old-definition"));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + newArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_replacementNameCollisionKeepsUnrelatedStateMachine() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-replacement-collision-" + suffix;
+ String oldName = "sfn-collision-old-" + suffix;
+ String newName = "sfn-collision-owned-elsewhere-" + suffix;
+ String oldArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + oldName;
+ String newArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + newName;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-collision-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"%s\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(oldName, "stack-owned"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.CreateStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("""
+ {
+ "name":"%s",
+ "roleArn":"arn:aws:iam::000000000000:role/unrelated-role",
+ "definition":"{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"unrelated\\",\\"End\\":true}}}"
+ }
+ """.formatted(newName))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(newName, "replacement"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>UPDATE_ROLLBACK_COMPLETE</StackStatus>"));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + oldArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("stack-owned"));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + newArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("unrelated"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DeleteStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + newArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_successfulReplacementDeletesOldStateMachineAfterCommit() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-replacement-success-" + suffix;
+ String oldName = "sfn-success-old-" + suffix;
+ String newName = "sfn-success-new-" + suffix;
+ String oldArn = "arn:aws:states:us-east-1:000000000000:stateMachine:" + oldName;
+ String newArn = "arn:aws:states:us-east-1:000000000000:stateMachine:" + newName;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-replacement-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"%s\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(oldName, "old"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(newName, "new"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + oldArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + newArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("\"new\""));
+
+ String events = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackEvents")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString();
+ assertThat(events, containsString(oldArn));
+ assertThat(events, containsString("<ResourceStatus>DELETE_IN_PROGRESS</ResourceStatus>"));
+ assertThat(events, containsString("<ResourceStatus>DELETE_COMPLETE</ResourceStatus>"));
+ assertThat(events, containsString("<ResourceStatus>UPDATE_IN_PROGRESS</ResourceStatus>"));
+ assertThat(events, containsString("<ResourceStatus>UPDATE_COMPLETE</ResourceStatus>"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_replacementRetainPolicyKeepsOldStateMachine() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-replacement-retain-" + suffix;
+ String oldName = "sfn-retain-old-" + suffix;
+ String newName = "sfn-retain-new-" + suffix;
+ String oldArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + oldName;
+ String newArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + newName;
+ String initialTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-retain-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"old\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """.formatted(oldName);
+ String updatedTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "UpdateReplacePolicy": "Retain",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-retain-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"new\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """.formatted(newName);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", initialTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", updatedTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + oldArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("\"old\""));
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + newArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("\"new\""));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DeleteStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + oldArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_stepFunctionsLoadsS3DefinitionAndMutableConfigurations() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-cfn-s3-" + suffix;
+ String stateMachineName = "sfn-s3-" + suffix;
+ String stateMachineArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:"
+ + stateMachineName;
+ String bucket = "sfn-definitions-" + suffix;
+ String key = "definition.yaml";
+ String s3Definition = """
+ {StartAt: Done, States: {Done: {Type: Pass, Result: '${Marker}', End: true}}}
+ """;
+
+ given()
+ .when()
+ .put("/" + bucket)
+ .then()
+ .statusCode(200);
+ given()
+ .contentType("text/yaml")
+ .body(s3Definition)
+ .when()
+ .put("/" + bucket + "/" + key)
+ .then()
+ .statusCode(200);
+
+ String initialTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-s3-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"inline\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """.formatted(stateMachineName);
+ String updatedTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-s3-role",
+ "DefinitionS3Location": {"Bucket":"%s","Key":"%s"},
+ "DefinitionSubstitutions": {"Marker":"from-s3"},
+ "LoggingConfiguration": {
+ "Level": "ALL",
+ "IncludeExecutionData": true,
+ "Destinations": [{
+ "CloudWatchLogsLogGroup": {
+ "LogGroupArn": "arn:aws:logs:us-east-1:000000000000:log-group:sfn:*"
+ }
+ }]
+ },
+ "TracingConfiguration": {"Enabled": true},
+ "EncryptionConfiguration": {
+ "Type": "CUSTOMER_MANAGED_KMS_KEY",
+ "KmsKeyId": "alias/cfn-sfn-key",
+ "KmsDataKeyReusePeriodSeconds": 120
+ }
+ }
+ }
+ }
+ }
+ """.formatted(stateMachineName, bucket, key);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", initialTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", updatedTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString("from-s3"))
+ .body("definition", not(containsString("inline")))
+ .body("loggingConfiguration.level", equalTo("ALL"))
+ .body("loggingConfiguration.includeExecutionData", equalTo(true))
+ .body("tracingConfiguration.enabled", equalTo(true))
+ .body(
+ "encryptionConfiguration.type",
+ equalTo("CUSTOMER_MANAGED_KMS_KEY"))
+ .body("encryptionConfiguration.kmsKeyId", equalTo("alias/cfn-sfn-key"))
+ .body(
+ "encryptionConfiguration.kmsDataKeyReusePeriodSeconds",
+ equalTo(120));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ given().when().delete("/" + bucket + "/" + key).then().statusCode(204);
+ given().when().delete("/" + bucket).then().statusCode(204);
+ }
+
+ @Test
+ void createStack_stepFunctionsRequiresExactlyOneDefinitionSource() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String missingStack = "sfn-definition-missing-" + suffix;
+ String multipleStack = "sfn-definition-multiple-" + suffix;
+ String missingName = "sfn-definition-missing-machine-" + suffix;
+ String multipleName = "sfn-definition-multiple-machine-" + suffix;
+ String missingTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-definition-role"
+ }
+ }
+ }
+ }
+ """.formatted(missingName);
+ String multipleTemplate = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-definition-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"End\\":true}}}",
+ "Definition": {
+ "StartAt": "Done",
+ "States": {"Done": {"Type": "Pass", "End": true}}
+ }
+ }
+ }
+ }
+ }
+ """.formatted(multipleName);
+
+ for (Map.Entry<String, String> invalidTemplate : Map.of(
+ missingStack, missingTemplate,
+ multipleStack, multipleTemplate).entrySet()) {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", invalidTemplate.getKey())
+ .formParam("TemplateBody", invalidTemplate.getValue())
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", invalidTemplate.getKey())
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>ROLLBACK_COMPLETE</StackStatus>"));
+ }
+
+ for (String stateMachineName : java.util.List.of(missingName, multipleName)) {
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"arn:aws:states:us-east-1:"
+ + "000000000000:stateMachine:" + stateMachineName + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+ }
+
+ for (String stack : java.util.List.of(missingStack, multipleStack)) {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stack)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+ }
+
+ @Test
+ void updateStack_longGeneratedStepFunctionsNameWithoutModeRemainsInPlace() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-legacy-generated-" + "x".repeat(55) + suffix;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-generated-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String oldArn = physicalIdByLogicalId(given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString(), "MyStateMachine");
+
+ var stack = cloudFormationService.describeStacks(stackName, "us-east-1").getFirst();
+ stack.getResources().get("MyStateMachine").getAttributes().remove("FlociStepFunctionsNameMode");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String newArn = physicalIdByLogicalId(given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString(), "MyStateMachine");
+ assertEquals(oldArn, newArn);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_generatedStepFunctionsTypeChangeReplacesResource() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-generated-type-" + suffix;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineType": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-generated-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted("STANDARD"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String oldArn = physicalIdByLogicalId(given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString(), "MyStateMachine");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted("EXPRESS"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String newArn = physicalIdByLogicalId(given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString(), "MyStateMachine");
+ assertNotEquals(oldArn, newArn);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + oldArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + newArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("type", equalTo("EXPRESS"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_stepFunctionsNameModeChangesReplaceResource() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-name-mode-" + suffix;
+ String explicitName = "sfn-explicit-" + suffix;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ %s
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-name-mode-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"End\\":true}}}"
+ }
+ }
+ }
+ }
+ """;
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(""))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String generatedArn = physicalIdByLogicalId(given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString(), "MyStateMachine");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody",
+ template.formatted("\"StateMachineName\": \"" + explicitName + "\","))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String explicitArn = physicalIdByLogicalId(given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString(), "MyStateMachine");
+ assertThat(explicitArn, equalTo(
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + explicitName));
+ assertNotEquals(generatedArn, explicitArn);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", template.formatted(""))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String regeneratedArn = physicalIdByLogicalId(given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackResources")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .extract().asString(), "MyStateMachine");
+ assertNotEquals(explicitArn, regeneratedArn);
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + explicitArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + regeneratedArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ void updateStack_stepFunctionsConfigurationsUpdateInPlace() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-config-update-" + suffix;
+ String stateMachineName = "sfn-config-machine-" + suffix;
+ String stateMachineArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:" + stateMachineName;
+ String template = """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-config-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"End\\":true}}}",
+ "LoggingConfiguration": %s,
+ "TracingConfiguration": %s,
+ "EncryptionConfiguration": %s
+ }
+ }
+ },
+ "Outputs": {
+ "Revision": {
+ "Value": {
+ "Fn::GetAtt": ["MyStateMachine", "StateMachineRevisionId"]
+ }
+ }
+ }
+ }
+ """;
+ String initialTemplate = template.formatted(
+ stateMachineName,
+ "{\"Level\":\"OFF\",\"IncludeExecutionData\":false}",
+ "{\"Enabled\":false}",
+ "{\"Type\":\"AWS_OWNED_KEY\"}");
+ String updatedTemplate = template.formatted(
+ stateMachineName,
+ """
+ {
+ "Level":"ALL",
+ "IncludeExecutionData":true,
+ "Destinations":[{
+ "CloudWatchLogsLogGroup":{
+ "LogGroupArn":"arn:aws:logs:us-east-1:000000000000:log-group:sfn:*"
+ }
+ }]
+ }
+ """.strip(),
+ "{\"Enabled\":true}",
+ """
+ {
+ "Type":"CUSTOMER_MANAGED_KMS_KEY",
+ "KmsKeyId":"alias/cfn-sfn-key",
+ "KmsDataKeyReusePeriodSeconds":120
+ }
+ """.strip());
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", initialTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String initialRevision = given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("loggingConfiguration.level", equalTo("OFF"))
+ .body("tracingConfiguration.enabled", equalTo(false))
+ .body("encryptionConfiguration.type", equalTo("AWS_OWNED_KEY"))
+ .extract().jsonPath().getString("revisionId");
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<OutputValue>" + initialRevision + "</OutputValue>"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", updatedTemplate)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+
+ String updatedRevision = given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("loggingConfiguration.level", equalTo("ALL"))
+ .body("loggingConfiguration.includeExecutionData", equalTo(true))
+ .body("loggingConfiguration.destinations[0].cloudWatchLogsLogGroup.logGroupArn",
+ equalTo("arn:aws:logs:us-east-1:000000000000:log-group:sfn:*"))
+ .body("tracingConfiguration.enabled", equalTo(true))
+ .body("encryptionConfiguration.type",
+ equalTo("CUSTOMER_MANAGED_KMS_KEY"))
+ .body("encryptionConfiguration.kmsKeyId", equalTo("alias/cfn-sfn-key"))
+ .body("encryptionConfiguration.kmsDataKeyReusePeriodSeconds", equalTo(120))
+ .extract().jsonPath().getString("revisionId");
+ assertNotEquals(initialRevision, updatedRevision);
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<OutputValue>" + updatedRevision + "</OutputValue>"));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
// ── Issue #924: roll back failed stack creates (criterion #9) ────────────
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationStepFunctionsCleanupIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationStepFunctionsCleanupIntegrationTest.java
new file mode 100644
index 0000000000..5c8b2cc81f
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationStepFunctionsCleanupIntegrationTest.java
@@ -0,0 +1,254 @@
+package io.github.hectorvent.floci.services.cloudformation;
+
+import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsService;
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.mockito.InjectSpy;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.not;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@QuarkusTest
+class CloudFormationStepFunctionsCleanupIntegrationTest {
+
+ private static final String SFN_CONTENT_TYPE = "application/x-amz-json-1.0";
+
+ @InjectSpy
+ StepFunctionsService stepFunctionsService;
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ void permanentReplacementCleanupFailureKeepsCommittedUpdateAndWarns() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-cleanup-warning-" + suffix;
+ String oldName = "sfn-cleanup-old-" + suffix;
+ String newName = "sfn-cleanup-new-" + suffix;
+ String exportName = "sfn-cleanup-export-" + suffix;
+ String oldArn = stateMachineArn(oldName);
+ String newArn = stateMachineArn(newName);
+
+ createStack(stackName, template(oldName, "old-definition", "old-output", exportName));
+
+ Mockito.doThrow(new IllegalStateException("simulated cleanup failure"))
+ .when(stepFunctionsService)
+ .deleteStateMachineIfRevisionMatches(eq(oldArn), anyString());
+
+ updateStack(stackName, template(newName, "new-definition", "new-output", exportName));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>UPDATE_COMPLETE</StackStatus>"))
+ .body(containsString("<StackStatusReason>"))
+ .body(containsString(oldArn))
+ .body(containsString("<OutputValue>new-output</OutputValue>"))
+ .body(not(containsString("<OutputValue>old-output</OutputValue>")));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "ListExports")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<Name>" + exportName + "</Name>"))
+ .body(containsString("<Value>new-output</Value>"))
+ .body(not(containsString("<Value>old-output</Value>")));
+
+ assertStateMachine(oldArn, "old-definition");
+ assertStateMachine(newArn, "new-definition");
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "GetTemplate")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString(newName))
+ .body(not(containsString(oldName)));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackEvents")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<PhysicalResourceId>" + oldArn + "</PhysicalResourceId>"))
+ .body(containsString("<ResourceStatus>DELETE_IN_PROGRESS</ResourceStatus>"))
+ .body(containsString("<ResourceStatus>DELETE_FAILED</ResourceStatus>"));
+
+ verify(stepFunctionsService, times(3))
+ .deleteStateMachineIfRevisionMatches(eq(oldArn), anyString());
+
+ Mockito.doCallRealMethod()
+ .when(stepFunctionsService)
+ .deleteStateMachineIfRevisionMatches(eq(oldArn), anyString());
+ deleteStack(stackName);
+ stepFunctionsService.deleteStateMachine(oldArn);
+ }
+
+ @Test
+ void transientReplacementCleanupFailureSucceedsOnThirdAttempt() {
+ String suffix = Long.toString(System.nanoTime(), 36);
+ String stackName = "sfn-cleanup-retry-" + suffix;
+ String oldName = "sfn-cleanup-retry-old-" + suffix;
+ String newName = "sfn-cleanup-retry-new-" + suffix;
+ String exportName = "sfn-cleanup-retry-export-" + suffix;
+ String oldArn = stateMachineArn(oldName);
+ String newArn = stateMachineArn(newName);
+
+ createStack(stackName, template(oldName, "old-definition", "old-output", exportName));
+
+ Mockito.doThrow(new IllegalStateException("first cleanup failure"))
+ .doThrow(new IllegalStateException("second cleanup failure"))
+ .doCallRealMethod()
+ .when(stepFunctionsService)
+ .deleteStateMachineIfRevisionMatches(eq(oldArn), anyString());
+
+ updateStack(stackName, template(newName, "new-definition", "new-output", exportName));
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStacks")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<StackStatus>UPDATE_COMPLETE</StackStatus>"))
+ .body(not(containsString("<StackStatusReason>")))
+ .body(containsString("<OutputValue>new-output</OutputValue>"));
+
+ assertStateMachineMissing(oldArn);
+ assertStateMachine(newArn, "new-definition");
+ verify(stepFunctionsService, times(3))
+ .deleteStateMachineIfRevisionMatches(eq(oldArn), anyString());
+
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DescribeStackEvents")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body(containsString("<PhysicalResourceId>" + oldArn + "</PhysicalResourceId>"))
+ .body(containsString("<ResourceStatus>DELETE_IN_PROGRESS</ResourceStatus>"))
+ .body(containsString("<ResourceStatus>DELETE_COMPLETE</ResourceStatus>"))
+ .body(not(containsString("<ResourceStatus>DELETE_FAILED</ResourceStatus>")));
+
+ deleteStack(stackName);
+ }
+
+ private static void createStack(String stackName, String templateBody) {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", templateBody)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private static void updateStack(String stackName, String templateBody) {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "UpdateStack")
+ .formParam("StackName", stackName)
+ .formParam("TemplateBody", templateBody)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private static void deleteStack(String stackName) {
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "DeleteStack")
+ .formParam("StackName", stackName)
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private static void assertStateMachine(String arn, String definitionMarker) {
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + arn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("definition", containsString(definitionMarker));
+ }
+
+ private static void assertStateMachineMissing(String arn) {
+ given()
+ .header("X-Amz-Target", "AWSStepFunctions.DescribeStateMachine")
+ .contentType(SFN_CONTENT_TYPE)
+ .body("{\"stateMachineArn\":\"" + arn + "\"}")
+ .when()
+ .post("/")
+ .then()
+ .statusCode(400)
+ .body("__type", containsString("StateMachineDoesNotExist"));
+ }
+
+ private static String stateMachineArn(String name) {
+ return "arn:aws:states:us-east-1:000000000000:stateMachine:" + name;
+ }
+
+ private static String template(
+ String stateMachineName,
+ String definitionMarker,
+ String outputValue,
+ String exportName) {
+ return """
+ {
+ "Resources": {
+ "MyStateMachine": {
+ "Type": "AWS::StepFunctions::StateMachine",
+ "Properties": {
+ "StateMachineName": "%s",
+ "RoleArn": "arn:aws:iam::000000000000:role/cfn-sfn-cleanup-role",
+ "DefinitionString": "{\\"StartAt\\":\\"Done\\",\\"States\\":{\\"Done\\":{\\"Type\\":\\"Pass\\",\\"Result\\":\\"%s\\",\\"End\\":true}}}"
+ }
+ }
+ },
+ "Outputs": {
+ "Marker": {
+ "Value": "%s",
+ "Export": {"Name": "%s"}
+ }
+ }
+ }
+ """.formatted(
+ stateMachineName, definitionMarker, outputValue, exportName);
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsUpdateStateMachineIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsUpdateStateMachineIntegrationTest.java
new file mode 100644
index 0000000000..5a1523dd01
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsUpdateStateMachineIntegrationTest.java
@@ -0,0 +1,354 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * UpdateStateMachine — the AWS API action and the behavior CloudFormation relies on when a stack
+ * update re-provisions an AWS::StepFunctions::StateMachine (previously Floci always called
+ * CreateStateMachine, which failed with StateMachineAlreadyExists and rolled the stack update back).
+ */
+@QuarkusTest
+class StepFunctionsUpdateStateMachineIntegrationTest {
+
+ private static final String CT = "application/x-amz-json-1.0";
+ private static final String DEF = "{\\\"StartAt\\\":\\\"D\\\",\\\"States\\\":{\\\"D\\\":{\\\"Type\\\":\\\"Pass\\\",\\\"End\\\":true}}}";
+ private static final String DEF2 = "{\\\"StartAt\\\":\\\"W\\\",\\\"States\\\":{\\\"W\\\":{\\\"Type\\\":\\\"Wait\\\",\\\"Seconds\\\":1,\\\"End\\\":true}}}";
+
+ @BeforeAll
+ static void setup() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ private static Response call(String target, String body) {
+ return given().header("X-Amz-Target", "AWSStepFunctions." + target).contentType(CT).body(body).when().post("/");
+ }
+
+ private static String createStateMachine(String name) {
+ return call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r1\"}")
+ .then().statusCode(200).extract().jsonPath().getString("stateMachineArn");
+ }
+
+ @Test
+ void updateChangesDefinitionAndRoleArn() {
+ String arn = createStateMachine("upd-def-" + System.currentTimeMillis());
+
+ Response update = call("UpdateStateMachine",
+ "{\"stateMachineArn\":\"" + arn + "\",\"definition\":\"" + DEF2 + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r2\"}")
+ .then().statusCode(200)
+ .body("updateDate", notNullValue())
+ .body("revisionId", notNullValue())
+ .extract().response();
+ assertTrue(update.asString().contains("\"stateMachineVersionArn\":null"));
+
+ // The update is reflected in DescribeStateMachine.
+ Response describe = call("DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("roleArn", is("arn:aws:iam::000000000000:role/r2"))
+ .body("definition", containsString("\"Wait\""))
+ .extract().response();
+ assertFalse(describe.jsonPath().getMap("").containsKey("updateDate"));
+ }
+
+ @Test
+ void directUpdatePreservesExistingTags() {
+ String name = "upd-tags-" + System.currentTimeMillis();
+ String arn = call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r1\","
+ + "\"tags\":[{\"key\":\"owner\",\"value\":\"platform\"},"
+ + "{\"key\":\"stage\",\"value\":\"test\"}]}")
+ .then().statusCode(200).extract().jsonPath().getString("stateMachineArn");
+
+ call("UpdateStateMachine",
+ "{\"stateMachineArn\":\"" + arn + "\",\"definition\":\"" + DEF2 + "\"}")
+ .then().statusCode(200);
+
+ call("ListTagsForResource", "{\"resourceArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("tags.size()", is(2))
+ .body("tags.find { it.key == 'owner' }.value", is("platform"))
+ .body("tags.find { it.key == 'stage' }.value", is("test"));
+ }
+
+ @Test
+ void updateMissingStateMachineReturnsStateMachineDoesNotExist() {
+ String missing = "arn:aws:states:us-east-1:000000000000:stateMachine:missing-" + System.currentTimeMillis();
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + missing + "\",\"definition\":\"" + DEF + "\"}")
+ .then().statusCode(400).body(containsString("StateMachineDoesNotExist"));
+ }
+
+ @Test
+ void updateWithoutDefinitionOrRoleArnReturnsMissingRequiredParameter() {
+ String arn = createStateMachine("upd-empty-" + System.currentTimeMillis());
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(400).body(containsString("MissingRequiredParameter"));
+ }
+
+ @Test
+ void updateWithPublishReturnsVersionArn() {
+ String arn = createStateMachine("upd-pub-" + System.currentTimeMillis());
+ Response published = call("UpdateStateMachine", """
+ {
+ "stateMachineArn":"%s",
+ "definition":"%s",
+ "roleArn":"arn:aws:iam::000000000000:role/r2",
+ "loggingConfiguration":{
+ "level":"ALL",
+ "includeExecutionData":true,
+ "destinations":[{
+ "cloudWatchLogsLogGroup":{
+ "logGroupArn":"arn:aws:logs:us-east-1:000000000000:log-group:version:*"
+ }
+ }]
+ },
+ "tracingConfiguration":{"enabled":true},
+ "encryptionConfiguration":{
+ "type":"CUSTOMER_MANAGED_KMS_KEY",
+ "kmsKeyId":"alias/version-key",
+ "kmsDataKeyReusePeriodSeconds":120
+ },
+ "publish":true,
+ "versionDescription":"first update"
+ }
+ """.formatted(arn, DEF2));
+ published.then().statusCode(200)
+ .body("updateDate", notNullValue())
+ .body("revisionId", notNullValue())
+ .body("stateMachineVersionArn", containsString(arn + ":1"));
+ String versionArn = published.jsonPath().getString("stateMachineVersionArn");
+ String versionRevision = published.jsonPath().getString("revisionId");
+
+ call("UpdateStateMachine", """
+ {
+ "stateMachineArn":"%s",
+ "definition":"%s",
+ "roleArn":"arn:aws:iam::000000000000:role/r3",
+ "loggingConfiguration":{
+ "level":"OFF",
+ "includeExecutionData":false,
+ "destinations":[]
+ },
+ "tracingConfiguration":{"enabled":false},
+ "encryptionConfiguration":{"type":"AWS_OWNED_KEY"}
+ }
+ """.formatted(arn, DEF))
+ .then().statusCode(200);
+
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + versionArn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineArn", is(versionArn))
+ .body("creationDate", notNullValue())
+ .body("definition", containsString("\"Wait\""))
+ .body("roleArn", is("arn:aws:iam::000000000000:role/r2"))
+ .body("revisionId", is(versionRevision))
+ .body("description", is("first update"))
+ .body("loggingConfiguration.level", is("ALL"))
+ .body("loggingConfiguration.includeExecutionData", is(true))
+ .body("tracingConfiguration.enabled", is(true))
+ .body("encryptionConfiguration.type", is("CUSTOMER_MANAGED_KMS_KEY"))
+ .body("encryptionConfiguration.kmsKeyId", is("alias/version-key"))
+ .body("encryptionConfiguration.kmsDataKeyReusePeriodSeconds", is(120));
+
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("definition", containsString("\"Pass\""))
+ .body("roleArn", is("arn:aws:iam::000000000000:role/r3"))
+ .body("loggingConfiguration.level", is("OFF"))
+ .body("tracingConfiguration.enabled", is(false))
+ .body("encryptionConfiguration.type", is("AWS_OWNED_KEY"));
+
+ call("DeleteStateMachineVersion",
+ "{\"stateMachineVersionArn\":\"" + versionArn + "\"}")
+ .then().statusCode(200);
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + versionArn + "\"}")
+ .then().statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+ }
+
+ @Test
+ void updateValidatesRequiredAndMalformedArns() {
+ call("UpdateStateMachine", "{\"definition\":\"" + DEF2 + "\"}")
+ .then().statusCode(400).body(containsString("MissingRequiredParameter"));
+
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"\",\"definition\":\"" + DEF2 + "\"}")
+ .then().statusCode(400).body(containsString("InvalidArn"));
+
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"not-an-arn\",\"definition\":\""
+ + DEF2 + "\"}")
+ .then().statusCode(400).body(containsString("InvalidArn"));
+
+ call("UpdateStateMachine", "{\"stateMachineArn\":42,\"definition\":\"" + DEF2 + "\"}")
+ .then().statusCode(400).body(containsString("ValidationException"));
+
+ String distributedMapArn =
+ "arn:aws:states:us-east-1:000000000000:stateMachine:machine/map-label";
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + distributedMapArn
+ + "\",\"definition\":\"" + DEF2 + "\"}")
+ .then().statusCode(400).body(containsString("ValidationException"));
+ }
+
+ @Test
+ void rejectedInputsDoNotMutateTheStateMachine() {
+ String arn = createStateMachine("upd-invalid-" + System.currentTimeMillis());
+ String initialRevision = call(
+ "DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200).extract().jsonPath().getString("revisionId");
+
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn + "\",\"roleArn\":\"\"}")
+ .then().statusCode(400).body(containsString("InvalidArn"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn
+ + "\",\"roleArn\":\"arn:aws:s3:::not-a-role\"}")
+ .then().statusCode(400).body(containsString("InvalidArn"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn + "\",\"definition\":\"\"}")
+ .then().statusCode(400).body(containsString("InvalidDefinition"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn
+ + "\",\"definition\":\"{}\"}")
+ .then().statusCode(400).body(containsString("InvalidDefinition"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn
+ + "\",\"definition\":\"{\\\"States\\\":{\\\"A\\\":{"
+ + "\\\"Type\\\":\\\"Pass\\\",\\\"End\\\":true}}}\"}")
+ .then().statusCode(400).body(containsString("InvalidDefinition"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn
+ + "\",\"definition\":\"{\\\"StartAt\\\":\\\"A\\\","
+ + "\\\"States\\\":{\\\"A\\\":{\\\"End\\\":true}}}\"}")
+ .then().statusCode(400).body(containsString("InvalidDefinition"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn + "\",\"definition\":\""
+ + DEF2 + "\",\"loggingConfiguration\":{\"level\":\"TRACE\"}}")
+ .then().statusCode(400).body(containsString("InvalidLoggingConfiguration"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn + "\",\"definition\":\""
+ + DEF2 + "\",\"tracingConfiguration\":{\"enabled\":\"yes\"}}")
+ .then().statusCode(400).body(containsString("InvalidTracingConfiguration"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn + "\",\"definition\":\""
+ + DEF2
+ + "\",\"encryptionConfiguration\":{\"type\":\"CUSTOMER_MANAGED_KMS_KEY\"}}")
+ .then().statusCode(400).body(containsString("InvalidEncryptionConfiguration"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn + "\",\"definition\":\""
+ + DEF2 + "\",\"versionDescription\":\"not published\"}")
+ .then().statusCode(400).body(containsString("ValidationException"));
+
+ Response after = call(
+ "DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}");
+ after.then().statusCode(200)
+ .body("definition", containsString("\"Pass\""))
+ .body("roleArn", is("arn:aws:iam::000000000000:role/r1"));
+ assertEquals(initialRevision, after.jsonPath().getString("revisionId"));
+ }
+
+ @Test
+ void updateRotatesRevisionAndRoundTripsConfigurations() {
+ String arn = createStateMachine("upd-config-" + System.currentTimeMillis());
+ Response initial = call(
+ "DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}");
+ initial.then().statusCode(200)
+ .body("loggingConfiguration.level", is("OFF"))
+ .body("loggingConfiguration.includeExecutionData", is(false))
+ .body("loggingConfiguration.destinations.size()", is(0))
+ .body("tracingConfiguration.enabled", is(false))
+ .body("encryptionConfiguration.type", is("AWS_OWNED_KEY"));
+ String initialRevision = initial.jsonPath().getString("revisionId");
+
+ Response update = call("UpdateStateMachine", """
+ {
+ "stateMachineArn":"%s",
+ "definition":"%s",
+ "loggingConfiguration":{
+ "level":"ALL",
+ "includeExecutionData":true,
+ "destinations":[{
+ "cloudWatchLogsLogGroup":{
+ "logGroupArn":"arn:aws:logs:us-east-1:000000000000:log-group:sfn:*"
+ }
+ }]
+ },
+ "tracingConfiguration":{"enabled":true},
+ "encryptionConfiguration":{
+ "type":"CUSTOMER_MANAGED_KMS_KEY",
+ "kmsKeyId":"alias/sfn-key",
+ "kmsDataKeyReusePeriodSeconds":120
+ }
+ }
+ """.formatted(arn, DEF2));
+ update.then().statusCode(200).body("revisionId", notNullValue());
+ String updatedRevision = update.jsonPath().getString("revisionId");
+ assertNotEquals(initialRevision, updatedRevision);
+
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("revisionId", is(updatedRevision))
+ .body("loggingConfiguration.level", is("ALL"))
+ .body("loggingConfiguration.includeExecutionData", is(true))
+ .body("tracingConfiguration.enabled", is(true))
+ .body("encryptionConfiguration.type", is("CUSTOMER_MANAGED_KMS_KEY"))
+ .body("encryptionConfiguration.kmsKeyId", is("alias/sfn-key"))
+ .body("encryptionConfiguration.kmsDataKeyReusePeriodSeconds", is(120));
+
+ call("DescribeStateMachine",
+ "{\"stateMachineArn\":\"" + arn + "\",\"includedData\":\"METADATA_ONLY\"}")
+ .then().statusCode(200)
+ .body("definition", is("{}"))
+ .body("encryptionConfiguration.type", is("CUSTOMER_MANAGED_KMS_KEY"));
+
+ call("DescribeStateMachine",
+ "{\"stateMachineArn\":\"" + arn + "\",\"includedData\":\"ALL_DATA\"}")
+ .then().statusCode(200)
+ .body("definition", containsString("\"Wait\""));
+
+ call("DescribeStateMachine",
+ "{\"stateMachineArn\":\"" + arn + "\",\"includedData\":\"INVALID\"}")
+ .then().statusCode(400)
+ .body(containsString("ValidationException"));
+
+ call("DescribeStateMachine",
+ "{\"stateMachineArn\":\"" + arn + "\",\"includedData\":42}")
+ .then().statusCode(400)
+ .body(containsString("ValidationException"));
+ }
+
+ @Test
+ void createRejectsUnsupportedStateMachineTypeBeforePersistence() {
+ String name = "invalid-type-" + System.currentTimeMillis();
+ call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r1\","
+ + "\"type\":\"BASIC\"}")
+ .then().statusCode(400)
+ .body(containsString("StateMachineTypeNotSupported"));
+
+ call("DescribeStateMachine", "{\"stateMachineArn\":"
+ + "\"arn:aws:states:us-east-1:000000000000:stateMachine:" + name + "\"}")
+ .then().statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+ }
+
+ @Test
+ void describeValidatesRequiredAndQualifiedArns() {
+ call("DescribeStateMachine", "{}")
+ .then().statusCode(400)
+ .body(containsString("MissingRequiredParameter"));
+ call("DescribeStateMachine", "{\"stateMachineArn\":42}")
+ .then().statusCode(400)
+ .body(containsString("ValidationException"));
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"not-an-arn\"}")
+ .then().statusCode(400)
+ .body(containsString("InvalidArn"));
+ call("DescribeStateMachine", "{\"stateMachineArn\":"
+ + "\"arn:aws:states:us-east-1:000000000000:"
+ + "stateMachine:machine/map-label\"}")
+ .then().statusCode(400)
+ .body(containsString("ValidationException"));
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.java
index 8efc05cbce..d4218f19cb 100644
--- a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.java
@@ -11,6 +11,7 @@ import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.emptyOrNullString;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
+import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* State machine version APIs — the Terraform AWS provider calls ListStateMachineVersions after
@@ -58,19 +59,25 @@ class StepFunctionsVersionsIntegrationTest {
}
@Test
- void listVersionsAreReturnedNewestFirst() {
+ void publishIsIdempotentPerRevisionAndVersionsAreReturnedNewestFirst() {
String name = "ver-order-" + System.currentTimeMillis();
String arn = call("CreateStateMachine",
"{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"}")
.then().statusCode(200).extract().jsonPath().getString("stateMachineArn");
- // Publish three versions (1, 2, 3). AWS lists them newest first, and the Terraform provider
- // reads the version ARN off this list, so the order must be descending — even though the three
- // publishes land within the same (second-resolution) creationDate, the version-number tie-break
- // keeps 3 ahead of 2 ahead of 1.
- call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}").then().statusCode(200);
- call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}").then().statusCode(200);
- call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}").then().statusCode(200);
+ // Re-publishing the same revision is idempotent and returns the existing version.
+ call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200).body("stateMachineVersionArn", is(arn + ":1"));
+ call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200).body("stateMachineVersionArn", is(arn + ":1"));
+
+ // Each update creates a new revision, so publishing those revisions advances the version.
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r2\",\"publish\":true}")
+ .then().statusCode(200).body("stateMachineVersionArn", is(arn + ":2"));
+ call("UpdateStateMachine", "{\"stateMachineArn\":\"" + arn
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r3\",\"publish\":true}")
+ .then().statusCode(200).body("stateMachineVersionArn", is(arn + ":3"));
call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")
.then().statusCode(200)
@@ -91,10 +98,139 @@ class StepFunctionsVersionsIntegrationTest {
@Test
void createWithPublishReturnsVersionArn() {
String name = "ver-pub-" + System.currentTimeMillis();
- call("CreateStateMachine",
- "{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\",\"publish\":true}")
+ String arn = call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\","
+ + "\"publish\":true,\"versionDescription\":\"initial release\"}")
.then().statusCode(200)
.body("stateMachineVersionArn", not(emptyOrNullString()))
- .body("stateMachineVersionArn", containsString(":1"));
+ .body("stateMachineVersionArn", containsString(":1"))
+ .extract().jsonPath().getString("stateMachineArn");
+
+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineVersions.size()", is(1))
+ .body("stateMachineVersions[0].stateMachineVersionArn", is(arn + ":1"));
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + ":1\"}")
+ .then().statusCode(200)
+ .body("description", is("initial release"));
+ }
+
+ @Test
+ void createWithoutPublishReturnsExplicitNullVersionArn() {
+ String name = "ver-unpublished-" + System.currentTimeMillis();
+ Response response = call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"}")
+ .then().statusCode(200)
+ .extract().response();
+
+ assertTrue(response.asString().contains("\"stateMachineVersionArn\":null"));
+ }
+
+ @Test
+ void createIsIdempotentForAwsContractFieldsAndIgnoresRoleAndTags() {
+ String name = "ver-create-idempotent-" + System.currentTimeMillis();
+ String originalRequest = "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/original\","
+ + "\"tags\":[{\"key\":\"owner\",\"value\":\"original\"}],"
+ + "\"publish\":true,\"versionDescription\":\"initial release\"}";
+ String arn = call("CreateStateMachine", originalRequest)
+ .then().statusCode(200)
+ .body("stateMachineVersionArn", containsString(":1"))
+ .extract().jsonPath().getString("stateMachineArn");
+
+ call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/ignored\","
+ + "\"tags\":[{\"key\":\"owner\",\"value\":\"ignored\"}],"
+ + "\"publish\":true,\"versionDescription\":\"initial release\"}")
+ .then().statusCode(200)
+ .body("stateMachineArn", is(arn))
+ .body("stateMachineVersionArn", is(arn + ":1"));
+
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("roleArn", is("arn:aws:iam::000000000000:role/original"));
+ call("ListTagsForResource", "{\"resourceArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("tags.size()", is(1))
+ .body("tags[0].key", is("owner"))
+ .body("tags[0].value", is("original"));
+
+ call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/original\","
+ + "\"publish\":true,\"versionDescription\":\"different\"}")
+ .then().statusCode(400)
+ .body(containsString("StateMachineAlreadyExists"));
+ call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/original\","
+ + "\"tracingConfiguration\":{\"enabled\":true},"
+ + "\"publish\":true,\"versionDescription\":\"initial release\"}")
+ .then().statusCode(400)
+ .body(containsString("StateMachineAlreadyExists"));
+ call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/original\"}")
+ .then().statusCode(400)
+ .body(containsString("StateMachineAlreadyExists"));
+ }
+
+ @Test
+ void publishHonorsRevisionAndDescriptionContract() {
+ String name = "ver-revision-" + System.currentTimeMillis();
+ String arn = call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"}")
+ .then().statusCode(200)
+ .extract().jsonPath().getString("stateMachineArn");
+ String revision = call(
+ "DescribeStateMachine",
+ "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .extract().jsonPath().getString("revisionId");
+
+ call("PublishStateMachineVersion",
+ "{\"stateMachineArn\":\"" + arn + "\",\"revisionId\":\""
+ + revision + "\",\"description\":\"first revision\"}")
+ .then().statusCode(200)
+ .body("stateMachineVersionArn", is(arn + ":1"));
+ call("PublishStateMachineVersion",
+ "{\"stateMachineArn\":\"" + arn + "\",\"revisionId\":\""
+ + revision + "\",\"description\":\"ignored replay\"}")
+ .then().statusCode(200)
+ .body("stateMachineVersionArn", is(arn + ":1"));
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + arn + ":1\"}")
+ .then().statusCode(200)
+ .body("description", is("first revision"));
+
+ call("PublishStateMachineVersion",
+ "{\"stateMachineArn\":\"" + arn
+ + "\",\"revisionId\":\"00000000-0000-0000-0000-000000000000\"}")
+ .then().statusCode(409)
+ .body(containsString("ConflictException"));
+ }
+
+ @Test
+ void invalidCreatePublishOptionsAndNamesAreRejectedBeforeStorage() {
+ String name = "ver-invalid-publish-" + System.currentTimeMillis();
+ String baseRequest = "{\"name\":\"" + name + "\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"";
+
+ call("CreateStateMachine",
+ baseRequest + ",\"versionDescription\":\"requires publish\"}")
+ .then().statusCode(400)
+ .body(containsString("ValidationException"));
+ call("CreateStateMachine", baseRequest + "}")
+ .then().statusCode(200)
+ .body("stateMachineArn", containsString(name));
+
+ call("CreateStateMachine",
+ "{\"name\":\"invalid name\",\"definition\":\"" + DEF
+ + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"}")
+ .then().statusCode(400)
+ .body(containsString("InvalidName"));
}
}