Light, fluffy, and always free - The AWS Local Emulator alternative
fix(msk): reject numberOfBrokerNodes values that only look whole after double rounding (#2571)
Allen Sanbornbd436eeea1d6
diff --git a/src/main/java/io/github/hectorvent/floci/services/msk/MskService.java b/src/main/java/io/github/hectorvent/floci/services/msk/MskService.javaindex a049c0cb79..924998d675 100644--- a/src/main/java/io/github/hectorvent/floci/services/msk/MskService.java+++ b/src/main/java/io/github/hectorvent/floci/services/msk/MskService.java@@ -187,7 +187,14 @@ public class MskService implements ResourceProvider {merged.setTags(request.getTags());if (request.getProvisioned() != null) {merged.setKafkaVersion(request.getProvisioned().getKafkaVersion());- merged.setNumberOfBrokerNodes(request.getProvisioned().getNumberOfBrokerNodes());+ // A malformed numberOfBrokerNodes carries no int value to copy (see BrokerCount),+ // so its "malformed" state has to be propagated explicitly rather than lost when+ // getNumberOfBrokerNodes() returns null the same way "absent" would.+ if (request.getProvisioned().isNumberOfBrokerNodesMalformed()) {+ merged.markNumberOfBrokerNodesMalformed();+ } else {+ merged.setNumberOfBrokerNodes(request.getProvisioned().getNumberOfBrokerNodes());+ }merged.setBrokerNodeGroupInfo(request.getProvisioned().getBrokerNodeGroupInfo());merged.setEncryptionInfo(request.getProvisioned().getEncryptionInfo());merged.setClientAuthentication(request.getProvisioned().getClientAuthentication());@@ -224,6 +231,13 @@ public class MskService implements ResourceProvider {"clusterName must be between 1 and " + MAX_CLUSTER_NAME_LENGTH + " characters.");}+ // A fractional or otherwise non-integral numberOfBrokerNodes (e.g. 2.7, or a literal+ // like 1.0000000000000001 that only looks whole once collapsed into a double) is+ // malformed rather than something to round - see BrokerCountDeserializer/BrokerCount.+ if (request.isNumberOfBrokerNodesMalformed()) {+ throw badRequest("numberOfBrokerNodes", "numberOfBrokerNodes must be a whole number.");+ }+Integer brokerNodes = request.getNumberOfBrokerNodes();if (brokerNodes != null && brokerNodes < MIN_BROKER_NODES) {throw badRequest("numberOfBrokerNodes",diff --git a/src/main/java/io/github/hectorvent/floci/services/msk/model/BrokerCount.java b/src/main/java/io/github/hectorvent/floci/services/msk/model/BrokerCount.javanew file mode 100644index 0000000000..2327fd07b4--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/msk/model/BrokerCount.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.services.msk.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * Result of parsing {@code numberOfBrokerNodes}: either an exact whole-number value, or a+ * marker that the request supplied something else.+ *+ * <p>{@link BrokerCountDeserializer} can't simply throw on malformed input: an exception+ * raised from inside a Jackson deserializer is caught while the request body is being read,+ * before the JAX-RS resource method - and therefore this service's own AWS-shaped+ * {@code AwsException} handling - ever runs, so the caller gets a bodyless 400 instead of an+ * MSK-style error. Carrying "malformed" as a value instead lets normal request validation+ * (see {@code MskService#validateCreateRequest}) raise the proper error once binding has+ * finished successfully.+ */+@RegisterForReflection+public final class BrokerCount {++ private static final BrokerCount MALFORMED = new BrokerCount(null, true);++ private final Integer value;+ private final boolean malformed;++ private BrokerCount(Integer value, boolean malformed) {+ this.value = value;+ this.malformed = malformed;+ }++ public static BrokerCount of(Integer value) {+ return new BrokerCount(value, false);+ }++ public static BrokerCount malformed() {+ return MALFORMED;+ }++ public Integer value() {+ return value;+ }++ public boolean isMalformed() {+ return malformed;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/msk/model/BrokerCountDeserializer.java b/src/main/java/io/github/hectorvent/floci/services/msk/model/BrokerCountDeserializer.javanew file mode 100644index 0000000000..f448f512a0--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/msk/model/BrokerCountDeserializer.java@@ -0,0 +1,56 @@+package io.github.hectorvent.floci.services.msk.model;++import com.fasterxml.jackson.core.JsonParser;+import com.fasterxml.jackson.core.JsonToken;+import com.fasterxml.jackson.databind.DeserializationContext;+import com.fasterxml.jackson.databind.JsonDeserializer;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.io.IOException;+import java.math.BigDecimal;++/**+ * Parses {@code numberOfBrokerNodes} without losing the precision needed to tell a whole+ * number from a fractional one.+ *+ * <p>Binding the field straight to {@code Integer} isn't safe: Jackson's default float-to-int+ * coercion (on by default) truncates a JSON float token the same way {@code intValue()} would,+ * silently turning 2.7 into 2. Comparing the value as a {@code double} after the fact doesn't+ * fix that either - it just moves the precision loss earlier. A literal like+ * {@code 1.0000000000000001} has no exact {@code double} representation, so parsing it into a+ * double collapses it to exactly {@code 1.0} before any {@code d == Math.rint(d)} check ever+ * runs, and the malformed input is silently accepted as a valid integer.+ *+ * <p>{@link JsonParser#getDecimalValue()} avoids that: it builds a {@link BigDecimal} straight+ * from the token's source text, the same way {@code new BigDecimal(String)} would, so it never+ * routes the value through a lossy {@code double}. Checking exactness on that value catches a+ * fractional literal - including one only a double comparison would have missed - while still+ * accepting a whole number written with a decimal point (e.g. {@code 3.0}).+ *+ * <p>This deserializer never throws on malformed input; it returns {@link BrokerCount#malformed()}+ * instead. See that class for why - in short, an exception raised here is caught while the+ * request body is still being read, before this service's AWS-shaped error handling ever runs.+ */+@RegisterForReflection+public class BrokerCountDeserializer extends JsonDeserializer<BrokerCount> {++ @Override+ public BrokerCount deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {+ JsonToken token = p.currentToken();+ if (token == JsonToken.VALUE_NULL) {+ return null;+ }+ if (token == JsonToken.VALUE_NUMBER_INT || token == JsonToken.VALUE_NUMBER_FLOAT) {+ BigDecimal decimal = p.getDecimalValue();+ if (decimal.stripTrailingZeros().scale() <= 0) {+ try {+ return BrokerCount.of(decimal.intValueExact());+ } catch (ArithmeticException overflow) {+ // Falls through to "malformed" below - out of int range is as malformed as+ // a fractional value.+ }+ }+ }+ return BrokerCount.malformed();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/msk/model/CreateClusterRequest.java b/src/main/java/io/github/hectorvent/floci/services/msk/model/CreateClusterRequest.javaindex 344069d9b3..561201835c 100644--- a/src/main/java/io/github/hectorvent/floci/services/msk/model/CreateClusterRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/msk/model/CreateClusterRequest.java@@ -1,7 +1,9 @@package io.github.hectorvent.floci.services.msk.model;+import com.fasterxml.jackson.annotation.JsonIgnore;import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import com.fasterxml.jackson.annotation.JsonProperty;+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;import io.quarkus.runtime.annotations.RegisterForReflection;import java.util.Map;@@ -16,8 +18,12 @@ public class CreateClusterRequest {@JsonProperty("kafkaVersion")private String kafkaVersion;+ // See BrokerCountDeserializer: binding straight to Integer would let Jackson (or a later+ // double comparison) silently narrow a fractional or precision-collapsed value. BrokerCount+ // carries "malformed" as a value rather than throwing during binding - see that class.@JsonProperty("numberOfBrokerNodes")- private Integer numberOfBrokerNodes;+ @JsonDeserialize(using = BrokerCountDeserializer.class)+ private BrokerCount numberOfBrokerNodes;@JsonProperty("brokerNodeGroupInfo")private BrokerNodeGroupInfo brokerNodeGroupInfo;@@ -57,8 +63,27 @@ public class CreateClusterRequest {public String getKafkaVersion() { return kafkaVersion; }public void setKafkaVersion(String kafkaVersion) { this.kafkaVersion = kafkaVersion; }- public Integer getNumberOfBrokerNodes() { return numberOfBrokerNodes; }- public void setNumberOfBrokerNodes(Integer numberOfBrokerNodes) { this.numberOfBrokerNodes = numberOfBrokerNodes; }+ // @JsonIgnore'd because their Integer signature would otherwise win as the property's+ // Jackson accessor (by JavaBean naming convention) over the field itself, and Jackson+ // would then try to hand a deserialized BrokerCount to a setter expecting Integer -+ // an IllegalArgumentException at invocation time. Ignoring these forces Jackson back onto+ // the annotated field, which is typed correctly for @JsonDeserialize to bind against.+ @JsonIgnore+ public Integer getNumberOfBrokerNodes() { return numberOfBrokerNodes != null ? numberOfBrokerNodes.value() : null; }+ @JsonIgnore+ public void setNumberOfBrokerNodes(Integer numberOfBrokerNodes) {+ this.numberOfBrokerNodes = numberOfBrokerNodes != null ? BrokerCount.of(numberOfBrokerNodes) : null;+ }++ /** True when the request supplied a numberOfBrokerNodes that isn't an exact whole number. */+ public boolean isNumberOfBrokerNodesMalformed() {+ return numberOfBrokerNodes != null && numberOfBrokerNodes.isMalformed();+ }++ /** Propagates a malformed numberOfBrokerNodes from a CreateClusterV2Request's provisioned block. */+ public void markNumberOfBrokerNodesMalformed() {+ this.numberOfBrokerNodes = BrokerCount.malformed();+ }public BrokerNodeGroupInfo getBrokerNodeGroupInfo() { return brokerNodeGroupInfo; }public void setBrokerNodeGroupInfo(BrokerNodeGroupInfo brokerNodeGroupInfo) { this.brokerNodeGroupInfo = brokerNodeGroupInfo; }diff --git a/src/main/java/io/github/hectorvent/floci/services/msk/model/ProvisionedRequest.java b/src/main/java/io/github/hectorvent/floci/services/msk/model/ProvisionedRequest.javaindex 68a57db4d3..a613377b19 100644--- a/src/main/java/io/github/hectorvent/floci/services/msk/model/ProvisionedRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/msk/model/ProvisionedRequest.java@@ -1,7 +1,9 @@package io.github.hectorvent.floci.services.msk.model;+import com.fasterxml.jackson.annotation.JsonIgnore;import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import com.fasterxml.jackson.annotation.JsonProperty;+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;import io.quarkus.runtime.annotations.RegisterForReflection;@RegisterForReflection@@ -11,8 +13,12 @@ public class ProvisionedRequest {@JsonProperty("kafkaVersion")private String kafkaVersion;+ // See BrokerCountDeserializer: binding straight to Integer would let Jackson (or a later+ // double comparison) silently narrow a fractional or precision-collapsed value. BrokerCount+ // carries "malformed" as a value rather than throwing during binding - see that class.@JsonProperty("numberOfBrokerNodes")- private Integer numberOfBrokerNodes;+ @JsonDeserialize(using = BrokerCountDeserializer.class)+ private BrokerCount numberOfBrokerNodes;@JsonProperty("brokerNodeGroupInfo")private BrokerNodeGroupInfo brokerNodeGroupInfo;@@ -46,8 +52,18 @@ public class ProvisionedRequest {public String getKafkaVersion() { return kafkaVersion; }public void setKafkaVersion(String kafkaVersion) { this.kafkaVersion = kafkaVersion; }- public Integer getNumberOfBrokerNodes() { return numberOfBrokerNodes; }- public void setNumberOfBrokerNodes(Integer numberOfBrokerNodes) { this.numberOfBrokerNodes = numberOfBrokerNodes; }+ // See CreateClusterRequest's identical accessors for why these are @JsonIgnore'd.+ @JsonIgnore+ public Integer getNumberOfBrokerNodes() { return numberOfBrokerNodes != null ? numberOfBrokerNodes.value() : null; }+ @JsonIgnore+ public void setNumberOfBrokerNodes(Integer numberOfBrokerNodes) {+ this.numberOfBrokerNodes = numberOfBrokerNodes != null ? BrokerCount.of(numberOfBrokerNodes) : null;+ }++ /** True when the request supplied a numberOfBrokerNodes that isn't an exact whole number. */+ public boolean isNumberOfBrokerNodesMalformed() {+ return numberOfBrokerNodes != null && numberOfBrokerNodes.isMalformed();+ }public BrokerNodeGroupInfo getBrokerNodeGroupInfo() { return brokerNodeGroupInfo; }public void setBrokerNodeGroupInfo(BrokerNodeGroupInfo brokerNodeGroupInfo) { this.brokerNodeGroupInfo = brokerNodeGroupInfo; }diff --git a/src/test/java/io/github/hectorvent/floci/services/msk/MskControllerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/msk/MskControllerIntegrationTest.javaindex 08bb37757d..9edc5dacdc 100644--- a/src/test/java/io/github/hectorvent/floci/services/msk/MskControllerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/msk/MskControllerIntegrationTest.java@@ -1048,6 +1048,102 @@ class MskControllerIntegrationTest {.body("clusterInfo.numberOfBrokerNodes", equalTo(30));}+ /**+ * A fractional count must not be narrowed into a plausible one: Jackson's default+ * float-to-int coercion would otherwise turn 2.7 into 2 and report a cluster the caller+ * never asked for.+ */+ @Test+ void createClusterRejectsAFractionalBrokerCountInsteadOfTruncatingIt() {+ given()+ .contentType("application/json")+ .body("""+ {"clusterName": "v1-brokers-fractional-test", "kafkaVersion": "3.6.0",+ "numberOfBrokerNodes": 2.7}+ """)+ .when()+ .post("/v1/clusters")+ .then()+ .statusCode(400)+ .body("invalidParameter", equalTo("numberOfBrokerNodes"));++ // ...and nothing was created under that name.+ given()+ .when()+ .get("/v1/clusters")+ .then()+ .statusCode(200)+ .body("clusterInfoList.clusterName", not(hasItem("v1-brokers-fractional-test")));+ }++ /**+ * A literal like 1.0000000000000001 has no exact double representation - parsing it as a+ * double collapses it to precisely 1.0, so a d == Math.rint(d) check performed after that+ * conversion would wrongly accept it as whole. This value must still be rejected: reading+ * the token as a BigDecimal (see BrokerCountDeserializer) catches the fractional part a+ * double comparison already lost.+ */+ @Test+ void createClusterRejectsABrokerCountThatOnlyLooksWholeAsADouble() {+ given()+ .contentType("application/json")+ .body("""+ {"clusterName": "v1-brokers-precision-test", "kafkaVersion": "3.6.0",+ "numberOfBrokerNodes": 1.0000000000000001}+ """)+ .when()+ .post("/v1/clusters")+ .then()+ .statusCode(400)+ .body("invalidParameter", equalTo("numberOfBrokerNodes"));++ given()+ .when()+ .get("/v1/clusters")+ .then()+ .statusCode(200)+ .body("clusterInfoList.clusterName", not(hasItem("v1-brokers-precision-test")));+ }++ /** A whole number written with a decimal point (e.g. 3.0) is not fractional and is accepted. */+ @Test+ void createClusterAcceptsAWholeNumberBrokerCountWrittenAsADecimal() {+ String clusterArn = given()+ .contentType("application/json")+ .body("""+ {"clusterName": "v1-brokers-whole-decimal-test", "kafkaVersion": "3.6.0",+ "numberOfBrokerNodes": 3.0}+ """)+ .when()+ .post("/v1/clusters")+ .then()+ .statusCode(200)+ .extract().path("clusterArn");++ given()+ .when()+ .get("/v1/clusters/{clusterArn}", clusterArn)+ .then()+ .statusCode(200)+ .body("clusterInfo.numberOfBrokerNodes", equalTo(3));+ }++ /** The V2 path nests the count under provisioned and must reject a fractional value too. */+ @Test+ void createClusterV2RejectsAFractionalBrokerCount() {+ given()+ .contentType("application/json")+ .body("""+ {"clusterName": "v2-brokers-fractional-test",+ "provisioned": {"kafkaVersion": "3.6.0", "numberOfBrokerNodes": 2.7}}+ """)+ .when()+ .post("/api/v2/clusters")+ .then()+ .statusCode(400)+ .body("invalidParameter", equalTo("numberOfBrokerNodes"));+ }+// ── Serverless clusters ──────────────────────────────────────────────────────────────@Test