Light, fluffy, and always free - The AWS Local Emulator alternative
fix(codeartifact): treat identical-content maven redeploy as idempotent (#4837)
Priamo Germosencd89be4a80a7
diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.mdindex 093a61febb..58128c4ab4 100644--- a/docs/services/codeartifact.md+++ b/docs/services/codeartifact.md@@ -108,6 +108,14 @@ shared settings list. Two config knobs,image version or point at an already-running instance and skip container management, matching thepattern used elsewhere in Floci for sidecars.+Each Reposilite repository is provisioned with `redeployment: false`, so redeploying an existing+GAV path with different content is rejected with a real `409`, matching AWS's documented asset+immutability. Reposilite's own setting has no content-aware mode, though, and would reject a+byte-identical redeploy too; Floci fetches the existing artifact first and short-circuits to `200`+on an exact match, matching AWS's own documented exception ("Overwriting package assets" in+CodeArtifact's packages overview) that a republish is idempotent when the content hasn't actually+changed.+## The npm repository endpoint`GetRepositoryEndpoint` for `format=npm` returns `http://localhost:4566/codeartifact/npm/<domain>/<repository>/`.diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.javaindex a30e0d8315..1123a5033c 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java@@ -9,6 +9,7 @@ import jakarta.inject.Inject;import org.jboss.logging.Logger;import java.io.IOException;+import java.io.InputStream;import java.net.URI;import java.net.http.HttpClient;import java.net.http.HttpRequest;@@ -16,6 +17,7 @@ import java.net.http.HttpRequest.BodyPublishers;import java.net.http.HttpResponse;import java.net.http.HttpResponse.BodyHandlers;import java.time.Duration;+import java.util.Arrays;import java.util.Optional;/**@@ -233,18 +235,82 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {}}- /** Deploys {@code content} to {@code repoId}'s {@code gav} path, returning the HTTP status. */+ /**+ * Deploys {@code content} to {@code repoId}'s {@code gav} path, returning the HTTP status.+ *+ * <p>Reposilite's own {@code redeployment: false} setting (set in {@link #ensureRepository})+ * rejects a redeploy to an existing path unconditionally, even when the new content is+ * byte-identical to what is already there (confirmed against a real instance). AWS's own+ * CodeArtifact docs ("Overwriting package assets" in the packages-overview page) say a+ * republish of an asset whose content matches what is already published succeeds because the+ * operation is idempotent; only a genuine content mismatch is a real conflict. Reposilite has+ * no content-aware mode of its own, so this checks the existing artifact first and+ * short-circuits to a 200 on an exact match rather than ever sending Reposilite a PUT it would+ * reject regardless of whether the retry was actually harmless. That check is best-effort: any+ * failure reading the existing artifact falls through to the real PUT below rather than failing+ * the deploy outright, since Reposilite's own redeployment check is still there to catch a+ * genuine conflict either way.+ */public int deployArtifact(String repoId, String gav, byte[] content) {String baseUrl = manager.ensureReady();+ if (existingArtifactMatches(baseUrl, repoId, gav, content)) {+ return 200;+ }HttpRequest request = authenticated(baseUrl, repoId, gav).PUT(BodyPublishers.ofByteArray(content)).build();return send(request, BodyHandlers.discarding()).statusCode();}+ /**+ * {@code true} when {@code repoId}'s {@code gav} path already holds content identical to+ * {@code content}. Streams the existing artifact in fixed-size chunks rather than buffering it+ * whole: {@code content} is already fully resident (RESTEasy Reactive buffers the whole request+ * body before {@link CodeArtifactMavenController#deploy} ever runs), so comparing this way+ * costs no second full copy for a large artifact the way downloading it to compare would.+ *+ * <p>Any failure reading the existing artifact, including one genuinely unexpected (a timeout,+ * a dropped connection), reads the same as "can't confirm a match" rather than propagating: a+ * client's upload must never fail just because this best-effort preflight did, when the real+ * PUT below is always there as the safe fallback.+ */+ private boolean existingArtifactMatches(String baseUrl, String repoId, String gav, byte[] content) {+ HttpRequest request = authenticated(baseUrl, repoId, gav).GET().build();+ try {+ HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());+ if (response.statusCode() != 200) {+ response.body().close();+ return false;+ }+ try (InputStream in = response.body()) {+ byte[] buffer = new byte[8192];+ int offset = 0;+ int read;+ while ((read = in.read(buffer)) != -1) {+ if (offset + read > content.length+ || !Arrays.equals(buffer, 0, read, content, offset, offset + read)) {+ return false;+ }+ offset += read;+ }+ return offset == content.length;+ }+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ return false;+ } catch (IOException e) {+ LOG.warnv(e, "Could not check {0}/{1} for an existing match before deploying: {2}", repoId, gav,+ e.getMessage());+ return false;+ }+ }+/** Fetches {@code repoId}'s {@code gav} path, or {@link Optional#empty()} on a non-200 response. */public Optional<FetchedArtifact> fetchArtifact(String repoId, String gav) {- String baseUrl = manager.ensureReady();+ return fetchArtifact(manager.ensureReady(), repoId, gav);+ }++ private Optional<FetchedArtifact> fetchArtifact(String baseUrl, String repoId, String gav) {HttpRequest request = authenticated(baseUrl, repoId, gav).GET().build();HttpResponse<byte[]> response = send(request, BodyHandlers.ofByteArray());if (response.statusCode() != 200) {diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.javaindex 852a1d65c8..518df921ad 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java@@ -90,8 +90,54 @@ class CodeArtifactMavenDockerIntegrationTest {.then().statusCode(200);}+ /**+ * Reposilite's {@code redeployment: false} rejects a redeploy to an existing GAV path+ * unconditionally, even when the new content is byte-identical to what is already there. AWS's+ * own CodeArtifact docs ("Overwriting package assets" in packages-overview.html) say that case+ * specifically succeeds because the operation is idempotent; only a genuine content mismatch,+ * covered by {@link #redeployingDifferentBytesStillConflicts}, is a real conflict.+ */@Test@Order(2)+ void redeployingTheExactSameBytesSucceedsIdempotently() {+ byte[] content = "real-jar-bytes".getBytes(StandardCharsets.UTF_8);++ given().header("Authorization", "Bearer " + bearerToken).body(content)+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/" + GAV)+ .then().statusCode(200);++ byte[] fetched = given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/" + GAV)+ .then().statusCode(200)+ .extract().asByteArray();+ assertEquals(new String(content, StandardCharsets.UTF_8), new String(fetched, StandardCharsets.UTF_8));+ }++ /**+ * The real content-mismatch counterpart to the idempotent-retry test above, against the live+ * shared Reposilite container rather than a fake server: proves the fix only closes the+ * byte-identical-retry gap and leaves Reposilite's own {@code redeployment: false} enforcement+ * for a genuine conflict untouched, so a config change there that started allowing silent+ * overwrites would still be caught here.+ */+ @Test+ @Order(3)+ void redeployingDifferentBytesStillConflicts() {+ byte[] different = "different-jar-bytes".getBytes(StandardCharsets.UTF_8);++ given().header("Authorization", "Bearer " + bearerToken).body(different)+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/" + GAV)+ .then().statusCode(409);++ byte[] fetched = given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/" + GAV)+ .then().statusCode(200)+ .extract().asByteArray();+ assertEquals("real-jar-bytes", new String(fetched, StandardCharsets.UTF_8));+ }++ @Test+ @Order(4)void missingArtifactAndMissingRepositoryAreNotFound() {given().header("Authorization", "Bearer " + bearerToken).get("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/does/not/exist.jar")@@ -103,7 +149,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(3)+ @Order(5)void repositoriesAreIsolatedFromEachOther() {given().contentType("application/json").header("Authorization", AUTH).body("{}").post("/v1/repository?domain=" + DOMAIN + "&repository=other-repo")@@ -115,7 +161,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(4)+ @Order(6)void missingOrWrongDomainTokensAreUnauthorized() {// Challenges as Basic, not Bearer: a real Maven wagon client only retries a 401 with its// configured settings.xml credentials when the challenge scheme matches what it sent.@@ -141,7 +187,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(5)+ @Order(7)void concurrentFirstUseOfANewRepositoryOnlyProvisionsItOnce() throws InterruptedException {given().contentType("application/json").header("Authorization", AUTH).body("{}").post("/v1/repository?domain=" + DOMAIN + "&repository=concurrent-repo")@@ -186,7 +232,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(6)+ @Order(8)void recreatingASameNamedRepositoryDoesNotInheritThePreviousOnesArtifacts() {given().contentType("application/json").header("Authorization", AUTH).body("{}").post("/v1/repository?domain=" + DOMAIN + "&repository=reused-name")@@ -208,7 +254,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(7)+ @Order(9)void aRealMavenClientsBasicAuthCredentialsAreAcceptedWithTheTokenAsThePassword() {String basic = "Basic " + Base64.getEncoder().encodeToString(("aws:" + bearerToken).getBytes(StandardCharsets.UTF_8));byte[] content = "basic-auth-bytes".getBytes(StandardCharsets.UTF_8);@@ -225,7 +271,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(8)+ @Order(10)void aDomainCreatedInANonDefaultRegionIsServedThroughTheTokensOwnRegionNotTheDefault() {// The default region here is us-east-1 (application.yml). Every other test in this class// creates its domain under an AUTH header whose SigV4 scope is also us-east-1, so those@@ -259,7 +305,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(9)+ @Order(11)void aDomainCreatedUnderANonDefaultAccountIsServedThroughTheTokensOwnAccountNotTheDefault() {// Every other test in this class authenticates as the default account (000000000000), so// none of them would notice if the owner half of the token-scope fix regressed and every@@ -291,7 +337,7 @@ class CodeArtifactMavenDockerIntegrationTest {}@Test- @Order(9)+ @Order(11)void deletingARepositoryReleasesItsStorageFromTheSharedReposiliteInstance() throws Exception {given().contentType("application/json").header("Authorization", AUTH).body("{}").post("/v1/repository?domain=" + DOMAIN + "&repository=released-repo")diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.javaindex b527ad81b0..dfb4f34892 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClientTest.java@@ -266,6 +266,74 @@ class ReposiliteSidecarClientTest {assertThat(authHeader.get(), equalTo("Basic dGVzdDp0ZXN0"));}+ @Test+ void deployArtifactShortCircuitsToTwoHundredWithoutPuttingWhenContentIsByteIdentical() {+ byte[] content = "hello".getBytes(StandardCharsets.UTF_8);+ List<String> methodsSeen = new CopyOnWriteArrayList<>();+ server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> {+ methodsSeen.add(exchange.getRequestMethod());+ respond(exchange, 200, "hello");+ });++ int status = client.deployArtifact("dom--repo", "com/example/a/1.0/a-1.0.jar", content);++ assertThat(status, is(200));+ assertThat(methodsSeen, equalTo(List.of("GET")));+ }++ @Test+ void deployArtifactStillPutsWhenExistingContentDiffers() {+ AtomicReference<byte[]> putBody = new AtomicReference<>();+ List<String> methodsSeen = new CopyOnWriteArrayList<>();+ server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> {+ methodsSeen.add(exchange.getRequestMethod());+ if ("PUT".equals(exchange.getRequestMethod())) {+ putBody.set(exchange.getRequestBody().readAllBytes());+ // Reposilite's real redeployment:false response for a genuine content mismatch;+ // this must pass straight through unchanged.+ respond(exchange, 409, "{\"status\":409,\"message\":\"Redeployment is not allowed\"}");+ } else {+ respond(exchange, 200, "goodbye");+ }+ });++ int status = client.deployArtifact("dom--repo", "com/example/a/1.0/a-1.0.jar",+ "hello".getBytes(StandardCharsets.UTF_8));++ assertThat(status, is(409));+ assertThat(methodsSeen, equalTo(List.of("GET", "PUT")));+ assertArrayEquals("hello".getBytes(StandardCharsets.UTF_8), putBody.get());+ }++ @Test+ void deployArtifactStillPutsWhenThePreflightCheckFails() {+ AtomicReference<byte[]> putBody = new AtomicReference<>();+ List<String> methodsSeen = new CopyOnWriteArrayList<>();+ server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> {+ methodsSeen.add(exchange.getRequestMethod());+ if ("PUT".equals(exchange.getRequestMethod())) {+ putBody.set(exchange.getRequestBody().readAllBytes());+ respond(exchange, 200, "");+ } else {+ // Simulates a dropped connection on the preflight GET (a timeout, a transient+ // network error): closing without ever sending a response is what the client sees+ // as an IOException, not a clean 4xx/5xx. The PUT must still go through. The JDK's+ // own HttpClient transparently retries an idempotent GET once on this kind of+ // connection-level failure before giving up, so more than one GET landing here+ // first is expected and not itself part of what this test is checking.+ exchange.close();+ }+ });++ int status = client.deployArtifact("dom--repo", "com/example/a/1.0/a-1.0.jar",+ "hello".getBytes(StandardCharsets.UTF_8));++ assertThat(status, is(200));+ assertTrue(methodsSeen.stream().allMatch(m -> m.equals("GET") || m.equals("PUT")));+ assertThat(methodsSeen.get(methodsSeen.size() - 1), equalTo("PUT"));+ assertArrayEquals("hello".getBytes(StandardCharsets.UTF_8), putBody.get());+ }+@Testvoid fetchArtifactReturnsBytesAndContentTypeOnSuccess() {server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> {