Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(stepfunctions): add state machine version APIs (Publish/List/DeleteStateMachineVersion) (#1562)

Alex Banna3fe7a60a58ca
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 7a5b7fdf0c..d0fb078d31 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
@@ -37,6 +37,9 @@ public class StepFunctionsJsonHandler {
case "DescribeStateMachine" -> handleDescribeStateMachine(request);
case "ListStateMachines" -> handleListStateMachines(request, region);
case "DeleteStateMachine" -> handleDeleteStateMachine(request);
+ case "PublishStateMachineVersion" -> handlePublishStateMachineVersion(request);
+ case "ListStateMachineVersions" -> handleListStateMachineVersions(request);
+ case "DeleteStateMachineVersion" -> handleDeleteStateMachineVersion(request);
case "ValidateStateMachineDefinition" -> handleValidateStateMachineDefinition(request);
case "StartExecution" -> handleStartExecution(request, region);
case "StartSyncExecution" -> handleStartSyncExecution(request, region);
@@ -73,9 +76,39 @@ public class StepFunctionsJsonHandler {
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());
+ }
+ return Response.ok(response).build();
+ }
+
+ private Response handlePublishStateMachineVersion(JsonNode request) {
+ var version = service.publishStateMachineVersion(request.path("stateMachineArn").asText());
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("stateMachineVersionArn", version.getStateMachineVersionArn());
+ response.put("creationDate", version.getCreationDate());
+ return Response.ok(response).build();
+ }
+
+ private Response handleListStateMachineVersions(JsonNode request) {
+ var versions = service.listStateMachineVersions(request.path("stateMachineArn").asText());
+ ObjectNode response = objectMapper.createObjectNode();
+ ArrayNode array = response.putArray("stateMachineVersions");
+ for (var v : versions) {
+ ObjectNode item = array.addObject();
+ item.put("stateMachineVersionArn", v.getStateMachineVersionArn());
+ item.put("creationDate", v.getCreationDate());
+ }
return Response.ok(response).build();
}
+ private Response handleDeleteStateMachineVersion(JsonNode request) {
+ service.deleteStateMachineVersion(request.path("stateMachineVersionArn").asText());
+ return Response.ok(objectMapper.createObjectNode()).build();
+ }
+
private Response handleDescribeStateMachine(JsonNode request) {
StateMachine sm = service.describeStateMachine(request.path("stateMachineArn").asText());
ObjectNode response = objectMapper.createObjectNode();
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 13c6845738..5252a7f7a1 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
@@ -12,6 +12,7 @@ import io.github.hectorvent.floci.services.stepfunctions.model.ActivityTask;
import io.github.hectorvent.floci.services.stepfunctions.model.Execution;
import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;
import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;
+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachineVersion;
import io.github.hectorvent.floci.core.common.Resettable;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
@@ -107,6 +108,51 @@ public class StepFunctionsService implements Resettable {
return stateMachineStore.scan(k -> k.startsWith(prefix));
}
+ // ── 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 version;
+ }
+
+ public List<StateMachineVersion> listStateMachineVersions(String stateMachineArn) {
+ // AWS returns InvalidArn for a non-existent state machine here — StateMachineDoesNotExist is
+ // not one of ListStateMachineVersions' declared errors (Publish, which does declare it, keeps
+ // using describeStateMachine).
+ StateMachine sm = stateMachineStore.get(stateMachineArn)
+ .orElseThrow(() -> new AwsException("InvalidArn",
+ "Invalid Arn: '" + stateMachineArn + "'", 400));
+ // AWS lists versions newest first (descending by creationDate). creationDate is only
+ // 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());
+ versions.sort(Comparator
+ .comparingDouble(StateMachineVersion::getCreationDate)
+ .thenComparingInt(StateMachineVersion::getVersion)
+ .reversed());
+ // Defensive copy so callers can't mutate (or trip over concurrent mutation of) the stored list.
+ return List.copyOf(versions);
+ }
+
+ public 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);
+ });
+ }
+
public void deleteStateMachine(String arn) {
stateMachineStore.delete(arn);
}
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 e89f2c3559..45cfa61675 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
@@ -3,7 +3,9 @@ package io.github.hectorvent.floci.services.stepfunctions.model;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.quarkus.runtime.annotations.RegisterForReflection;
+import java.util.ArrayList;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
@RegisterForReflection
@@ -17,6 +19,8 @@ public class StateMachine {
private String status = "ACTIVE";
private double creationDate;
private Map<String, String> tags = new HashMap<>();
+ private int versionCounter = 0;
+ private List<StateMachineVersion> versions = new ArrayList<>();
public StateMachine() {
this.creationDate = System.currentTimeMillis() / 1000.0;
@@ -45,4 +49,10 @@ public class StateMachine {
public Map<String, String> getTags() { return tags; }
public void setTags(Map<String, String> tags) { this.tags = tags; }
+
+ public int getVersionCounter() { return versionCounter; }
+ public void setVersionCounter(int versionCounter) { this.versionCounter = versionCounter; }
+
+ public List<StateMachineVersion> getVersions() { return versions; }
+ public void setVersions(List<StateMachineVersion> versions) { this.versions = versions; }
}
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
new file mode 100644
index 0000000000..805a69a620
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.java
@@ -0,0 +1,31 @@
+package io.github.hectorvent.floci.services.stepfunctions.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+/** A published version of a state machine ({@code <stateMachineArn>:<version>}). */
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class StateMachineVersion {
+ private String stateMachineVersionArn;
+ private int version;
+ private double creationDate;
+
+ public StateMachineVersion() {
+ }
+
+ public StateMachineVersion(String stateMachineVersionArn, int version, double creationDate) {
+ this.stateMachineVersionArn = stateMachineVersionArn;
+ this.version = version;
+ this.creationDate = creationDate;
+ }
+
+ public String getStateMachineVersionArn() { return stateMachineVersionArn; }
+ public void setStateMachineVersionArn(String stateMachineVersionArn) { this.stateMachineVersionArn = stateMachineVersionArn; }
+
+ public int getVersion() { return version; }
+ public void setVersion(int version) { this.version = version; }
+
+ public double getCreationDate() { return creationDate; }
+ public void setCreationDate(double creationDate) { this.creationDate = creationDate; }
+}
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
new file mode 100644
index 0000000000..8efc05cbce
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.java
@@ -0,0 +1,100 @@
+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.emptyOrNullString;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+
+/**
+ * State machine version APIs — the Terraform AWS provider calls ListStateMachineVersions after
+ * creating an aws_sfn_state_machine; previously Floci returned UnsupportedOperation.
+ */
+@QuarkusTest
+class StepFunctionsVersionsIntegrationTest {
+
+ private static final String CT = "application/x-amz-json-1.0";
+ private static final String DEF = "{\\\"StartAt\\\":\\\"D\\\",\\\"States\\\":{\\\"D\\\":{\\\"Type\\\":\\\"Pass\\\",\\\"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("/");
+ }
+
+ @Test
+ void listVersionsEmptyByDefaultThenPublishAndDelete() {
+ String name = "ver-test-" + System.currentTimeMillis();
+ String arn = call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"}")
+ .then().statusCode(200).extract().jsonPath().getString("stateMachineArn");
+
+ // No versions published yet -> empty list (the call that previously failed).
+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200).body("stateMachineVersions", is(java.util.Collections.emptyList()));
+
+ // Publish a version.
+ String versionArn = call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200).body("stateMachineVersionArn", containsString(arn + ":1"))
+ .extract().jsonPath().getString("stateMachineVersionArn");
+
+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200).body("stateMachineVersions[0].stateMachineVersionArn", is(versionArn));
+
+ // Delete it.
+ call("DeleteStateMachineVersion", "{\"stateMachineVersionArn\":\"" + versionArn + "\"}")
+ .then().statusCode(200);
+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200).body("stateMachineVersions", is(java.util.Collections.emptyList()));
+ }
+
+ @Test
+ void listVersionsAreReturnedNewestFirst() {
+ 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);
+
+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineVersions[0].stateMachineVersionArn", is(arn + ":3"))
+ .body("stateMachineVersions[1].stateMachineVersionArn", is(arn + ":2"))
+ .body("stateMachineVersions[2].stateMachineVersionArn", is(arn + ":1"));
+ }
+
+ @Test
+ void listVersionsForMissingStateMachineReturnsInvalidArn() {
+ // AWS returns InvalidArn (not StateMachineDoesNotExist) when the state machine does not exist,
+ // since StateMachineDoesNotExist is not a declared error for ListStateMachineVersions.
+ String missing = "arn:aws:states:us-east-1:000000000000:stateMachine:missing-" + System.currentTimeMillis();
+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + missing + "\"}")
+ .then().statusCode(400).body(containsString("InvalidArn"));
+ }
+
+ @Test
+ void createWithPublishReturnsVersionArn() {
+ String name = "ver-pub-" + System.currentTimeMillis();
+ call("CreateStateMachine",
+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\",\"publish\":true}")
+ .then().statusCode(200)
+ .body("stateMachineVersionArn", not(emptyOrNullString()))
+ .body("stateMachineVersionArn", containsString(":1"));
+ }
+}