Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(codeartifact): bridge CopyPackageVersions to every sidecar format (#5888)

Priamo Germosen5dcddc9dfa9c
diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.md
index dcbbc243a8..674763dc9e 100644
--- a/docs/services/codeartifact.md
+++ b/docs/services/codeartifact.md
@@ -45,7 +45,7 @@ behind them yet.
| `DescribePackageVersion` | Returns a package version's status, revision, and origin. |
| `GetPackageVersionAsset` | Downloads one asset from a package version by name, optionally pinned to a specific revision. |
| `GetPackageVersionReadme` | Returns the readme text for a package version; `npm`, `pypi`, and `nuget` only, matching AWS's own restriction for this action. |
-| `CopyPackageVersions` | Copies one or more versions of a package from one repository to another in the same domain; `generic` only. |
+| `CopyPackageVersions` | Copies one or more versions of a package from one repository to another in the same domain. |
| `TagResource` | Adds or updates tags on a domain or repository ARN. |
| `UntagResource` | Removes tags by key from a domain or repository ARN. |
| `ListTagsForResource` | Lists the tags on a domain or repository ARN. |
@@ -257,15 +257,28 @@ state.
`DisposePackageVersions`, and `UpdatePackageVersionsStatus` don't exist yet; the only way to
move a version from `Unfinished` to `Published` today is a follow-up `PublishPackageVersion`
call that omits the `unfinished` flag.
-- **`CopyPackageVersions` only supports the `generic` format, unlike real AWS.** The API
- reference does not restrict this action's `format` parameter the way it restricts
- `PublishPackageVersion`'s to `generic` alone; real CodeArtifact copies Maven, npm, pypi, and
- nuget versions too. This is a Floci implementation gap, not an AWS restriction being mirrored:
- Maven, npm, pypi, and nuget publish straight to their own sidecar and keep no `packageVersions`
- record this could read from or write to, so bridging them needs the same per-sidecar
- fetch-then-republish shape `GetPackageVersionAsset`'s own bridge already uses, not yet built.
- `includeFromUpstream` is accepted but has no effect, since Floci has no upstream-ingestion path
- for any format to begin with (see the upstream-resolution limitation below).
+- **`CopyPackageVersions` has no full cross-call rollback on a mid-copy sidecar failure.**
+ (`generic`, `maven`, `npm`, `pypi`, and `nuget` are all supported — matching real AWS, which
+ places no `format` restriction on this action at all, unlike `PublishPackageVersion`'s own
+ restriction to `generic`; `generic` copies through its own `packageVersions` record, while
+ `maven`, `npm`, `pypi`, and `nuget` each bridge straight to their own sidecar's real wire
+ protocol — `mvn deploy`, `npm publish`, `twine upload`, and `nuget push` respectively, confirmed
+ against a live container for each — since none of the four keeps a `packageVersions` record
+ this action could otherwise read from or write to.) A container-backed copy retains byte-for-byte
+ source assets, and a best-effort compensating cleanup restores or removes whatever one version's
+ own write touched if a later step in that same version fails, preserving the original error, but
+ a sidecar outage mid-cleanup can still leave a version in an inconsistent state, the same
+ residual risk the generic path's own write-level failure handling already accepts. A single call
+ also holds every fetched asset in memory until the whole batch's destination writes complete, so
+ a batch of many large assets is bounded by available heap, not disk; the same nominal-quota
+ tradeoff the 5 GB limitation below already accepts elsewhere. A copied `npm` or `pypi` version's
+ readme is propagated to the destination too, from this service's own record captured at publish
+ time, since neither sidecar can answer for one after the fact (`GetPackageVersionReadme`'s own
+ constraint, described earlier in this document); `nuget` needs no equivalent step, since
+ `GetPackageVersionReadme` already answers it live from the `.nupkg` this action already copies
+ in full. `includeFromUpstream` is accepted but has no effect, since Floci has no
+ upstream-ingestion path for any format to begin with (see
+ the upstream-resolution limitation below).
- **The 5 GB asset size quota is nominal.** `PublishPackageVersion` and the Maven, pypi, and
nuget repository endpoints all receive the request body as a single byte array before Floci ever
checks its length, so a request already large enough to exhaust available heap fails before the
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/Digests.java b/src/main/java/io/github/hectorvent/floci/core/common/Digests.java
index c5523334cc..3175d0ee49 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/Digests.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/Digests.java
@@ -19,9 +19,14 @@ public final class Digests {
}
}
+ /** The SHA-1 digest of {@code data} as lowercase hex. */
+ public static String sha1Hex(byte[] data) {
+ return HexFormat.of().formatHex(sha1(data));
+ }
+
/** The SHA-1 digest of the UTF-8 bytes of {@code text} as lowercase hex. */
public static String sha1Hex(String text) {
- return HexFormat.of().formatHex(sha1(text.getBytes(StandardCharsets.UTF_8)));
+ return sha1Hex(text.getBytes(StandardCharsets.UTF_8));
}
public static byte[] sha256(byte[] data) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/BagetterSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/BagetterSidecarClient.java
index 26ae7332b3..5a463150b3 100644
--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/BagetterSidecarClient.java
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/BagetterSidecarClient.java
@@ -8,6 +8,7 @@ import jakarta.inject.Inject;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
+import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.nio.charset.StandardCharsets;
@@ -153,6 +154,108 @@ public class BagetterSidecarClient implements RepositorySidecarManager {
}
}
+ /**
+ * NuGet's one asset per version is deterministically named (AWS's own normalization rule,
+ * already relied on by {@link #fetchPackageVersionAsset}), so enumerating it for {@code
+ * CopyPackageVersions} needs only confirm the version exists and name it the same way; empty
+ * when it doesn't.
+ */
+ @Override
+ public List<String> listPackageVersionAssetNames(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version) {
+ String lowerId = packageName.toLowerCase(Locale.ROOT);
+ Optional<String> normalizedVersion = matchVersion(repositoryContainerId, lowerId, version);
+ return normalizedVersion.map(v -> List.of(lowerId + "." + v + ".nupkg")).orElse(List.of());
+ }
+
+ /**
+ * Pushes {@code content} (the whole {@code .nupkg}, NuGet's one asset per version) through
+ * the real push wire shape {@code CodeArtifactNuGetController#push} already forwards
+ * unmodified, confirmed against a live BaGetter container: a {@code multipart/form-data}
+ * {@code PUT} to {@code /api/v2/package} whose first (only, here) part is the raw package
+ * bytes — no separate {@code name}/{@code version} form field, since BaGetter reads both from
+ * the {@code .nuspec} embedded in the package itself, not from {@code assetName} or this
+ * method's own {@code packageName}/{@code version} parameters.
+ *
+ * <p>Rejected outright with a real {@code 409} ("a package with this id and version already
+ * exists") if this exact id/version already exists, confirmed live, even for byte-identical
+ * content: unlike Maven's Reposilite, BaGetter has no idempotent-retry short-circuit of its
+ * own ({@code CodeArtifactNuGetController#push} does its own pre-check precisely because of
+ * this). The caller ({@code CodeArtifactService#copyContainerBackedPackageVersions}) already
+ * short-circuits an identical-content version as a no-op before ever reaching here, and is
+ * expected to have deleted a conflicting, differing existing version first for a genuine
+ * overwrite, the same reason {@code ReposiliteSidecarClient#storePackageVersionAsset}
+ * documents for Maven.
+ *
+ * <p>Runs inside {@link #lockFor}, the same lock {@link #deletePackage} and {@code
+ * CodeArtifactNuGetController#push} both already take for this repository: without it, a
+ * native push racing this exact id/version could interleave with this call's own write.
+ */
+ @Override
+ public void storePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName, byte[] content) {
+ synchronized (lockFor(repositoryContainerId)) {
+ String baseUrl = ensureReady(repositoryContainerId, null);
+ String boundary = "flociNuGetCopyBoundary" + System.nanoTime();
+ byte[] head = ("--" + boundary + "\r\n"
+ + "Content-Disposition: form-data; name=\"package\"; filename=\"" + assetName + "\"\r\n"
+ + "Content-Type: application/octet-stream\r\n\r\n").getBytes(StandardCharsets.UTF_8);
+ byte[] tail = ("\r\n--" + boundary + "--\r\n").getBytes(StandardCharsets.UTF_8);
+ byte[] body = new byte[head.length + content.length + tail.length];
+ System.arraycopy(head, 0, body, 0, head.length);
+ System.arraycopy(content, 0, body, head.length, content.length);
+ System.arraycopy(tail, 0, body, head.length + content.length, tail.length);
+
+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl),
+ "/api/v2/package"))
+ .timeout(Duration.ofSeconds(30))
+ .header("Content-Type", "multipart/form-data; boundary=" + boundary)
+ .PUT(BodyPublishers.ofByteArray(body))
+ .build();
+ HttpResponse<String> response;
+ try {
+ response = httpClient.send(request, BodyHandlers.ofString());
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not reach the BaGetter sidecar to push " + assetName, e);
+ }
+ if (response.statusCode() != 200 && response.statusCode() != 201 && response.statusCode() != 202) {
+ throw new IllegalStateException("Could not push " + assetName + " to the BaGetter sidecar: "
+ + "upstream returned " + response.statusCode());
+ }
+ }
+ }
+
+ /**
+ * Deletes the one version this asset belongs to, confirmed against a live container: NuGet
+ * has exactly one asset per version, so there is no finer grain to delete at than {@link
+ * #deletePackage}'s own per-version {@code DELETE /api/v2/package/<id>/<version>} already
+ * uses. Runs inside the same {@link #lockFor} lock {@link #storePackageVersionAsset} and
+ * {@link #deletePackage} both take, for the same reason.
+ */
+ @Override
+ public void deletePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName) {
+ synchronized (lockFor(repositoryContainerId)) {
+ String lowerId = packageName.toLowerCase(Locale.ROOT);
+ String normalizedVersion = NuGetVersions.normalize(version);
+ String baseUrl = ensureReady(repositoryContainerId, null);
+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/api/v2/package/"
+ + SidecarUriUtils.encodeSegment(lowerId) + "/" + SidecarUriUtils.encodeSegment(normalizedVersion));
+ HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(10)).DELETE().build();
+ HttpResponse<Void> response;
+ try {
+ response = httpClient.send(request, BodyHandlers.discarding());
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not reach the BaGetter sidecar to delete " + packageName
+ + " " + version + "'s asset " + assetName, e);
+ }
+ if (response.statusCode() != 204 && response.statusCode() != 404) {
+ throw new IllegalStateException("Could not delete " + packageName + " " + version + "'s asset "
+ + assetName + " from the BaGetter sidecar: upstream returned " + response.statusCode());
+ }
+ }
+ }
+
/**
* The lock {@link #deletePackage} and {@code CodeArtifactNuGetController}'s own push handler
* both take for one repository, so a push and a delete for the same repository can never
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java
index 8995026696..65c4e99116 100644
--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java
@@ -38,6 +38,7 @@ import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.time.Instant;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
@@ -1202,23 +1203,39 @@ public class CodeArtifactService implements Resettable {
* revision would: nothing before this helper existed ever let a client obtain a revision for
* these formats in the first place (not even a stale one), so this isn't a regression against
* any previously working staleness check.
+ *
+ * <p>Truncated to {@link #MAX_REVISION_LENGTH} (50) hex characters of the full SHA-256 digest,
+ * not the full 64: {@code CopyPackageVersions}' own {@code versionRevisions} value is
+ * wire-model-capped at 50 characters, so a revision this helper hands out through {@code
+ * DescribePackageVersion}/{@code GetPackageVersionAsset} must itself fit back into that field
+ * or a caller could never round-trip it through a revision-pinned copy. 50 hex characters
+ * (200 bits) is still astronomically collision-resistant for distinguishing the handful of
+ * live repository/namespace/package/version coordinates this emulator ever holds at once.
*/
private static String synthesizeContainerBackedRevision(String repoId, String namespace, String packageName,
String version) {
String revisionKey = repoId + "/" + (namespace == null ? "" : namespace) + "/" + packageName + "/" + version;
- return Digests.sha256Hex(revisionKey.getBytes(StandardCharsets.UTF_8));
+ return Digests.sha256Hex(revisionKey.getBytes(StandardCharsets.UTF_8)).substring(0, MAX_REVISION_LENGTH);
}
/**
* Copies one or more versions of a package from one repository to another in the same
- * domain. Only {@code generic} is supported today — unlike real AWS, which does not
- * restrict this action's {@code format} the way it restricts {@link #publishPackageVersion}'s
- * to {@code generic} alone (confirmed against the wire model: {@code
- * CopyPackageVersionsRequest.format}'s own doc carries no such restriction). This is a Floci
- * implementation gap, not an AWS restriction being mirrored: Maven, npm, pypi, and nuget
- * publish straight to their own sidecar and keep no {@code packageVersions} record this could
- * read from or write to, so bridging them needs the same per-sidecar fetch-then-republish
- * shape {@code GetPackageVersionAsset}'s own bridge already uses, not yet built here.
+ * domain, for every format CodeArtifact supports: {@code generic} through its own {@code
+ * packageVersions} store, and {@code maven}/{@code npm}/{@code pypi}/{@code nuget} bridged to
+ * their own sidecar (see {@link #copyContainerBackedPackageVersions}). Matches real AWS,
+ * which does not restrict this action's {@code format} the way it restricts {@link
+ * #publishPackageVersion}'s to {@code generic} alone (confirmed against the wire model:
+ * {@code CopyPackageVersionsRequest.format}'s own doc carries no such restriction) — every
+ * container-backed format publishes straight to its own sidecar and keeps no {@code
+ * packageVersions} record this could otherwise read from or write to, so each needed the
+ * same per-sidecar fetch-then-republish shape {@code GetPackageVersionAsset}'s own bridge
+ * already uses, built on each sidecar's own real wire protocol and confirmed live against a
+ * real container for every one of the four: {@code ReposiliteSidecarClient} reuses the write
+ * path {@link CodeArtifactMavenController}'s own {@code mvn deploy} passthrough already
+ * proved; {@code VerdaccioSidecarClient}, {@code PypiserverSidecarClient}, and {@code
+ * BagetterSidecarClient} each speak the real {@code npm publish}/{@code twine upload}/{@code
+ * nuget push} wire shape directly, the same one their own data-plane proxies already forward
+ * unmodified for a native client.
*
* <p>Confirmed against the CodeArtifact User Guide's own worked examples ("Copy package
* versions"), not assumed from the shared {@code PackageVersionError} error-code enum alone,
@@ -1253,26 +1270,31 @@ public class CodeArtifactService implements Resettable {
* has no upstream-ingestion path for any format (see {@code docs/services/codeartifact.md}'s
* Known limitations), so there is never a separate upstream repository to also search.
*
- * <p>A freshly copied version gets a new revision of its own ({@link #newRevision()}, never
- * the source's): the User Guide's own definition of "package version revision" is explicit
- * that "each time a package version is updated, a new package version revision is created,"
- * and landing a version in a repository it previously had no record in is such an update at
- * the destination — the same reason {@link #publishPackageVersion} always mints its own rather
- * than ever accepting a caller-supplied one. An identical-content no-op (see above) is
- * correctly the opposite case: nothing was updated at the destination, so its existing
- * revision, whatever it already was, is left untouched.
+ * <p>For {@code generic}, a freshly copied version gets a new revision of its own ({@link
+ * #newRevision()}, never the source's): the User Guide's own definition of "package version
+ * revision" is explicit that "each time a package version is updated, a new package version
+ * revision is created," and landing a version in a repository it previously had no record in
+ * is such an update at the destination — the same reason {@link #publishPackageVersion}
+ * always mints its own rather than ever accepting a caller-supplied one. An identical-content
+ * no-op (see above) is correctly the opposite case: nothing was updated at the destination, so
+ * its existing revision, whatever it already was, is left untouched. {@code maven}'s
+ * destination revision is instead {@link #synthesizeContainerBackedRevision}'s own stable,
+ * coordinate-derived value, the same one {@link #describeContainerBackedPackageVersion} and
+ * {@link #getContainerBackedPackageVersionAsset} already return for it: there is no
+ * "revision changes on update" concept for a container-backed format at all, an existing,
+ * documented simplification this does not invent a new exception to.
*
* <p>{@code synchronized} for the same reason every other package-mutating method here is: a
* concurrent publish or delete on either repository must never interleave with this method's
- * own read-then-write of the destination's {@code packageVersions} record.
+ * own read-then-write of the destination's {@code packageVersions} record, or, for {@code
+ * maven}, its sidecar's own backing storage.
*/
public synchronized CopyPackageVersionsResult copyPackageVersions(String region, String domain,
String domainOwner, String sourceRepository, String destinationRepository, String format,
String namespace, String packageName, List<String> versions, Map<String, String> versionRevisions,
boolean allowOverwrite, boolean includeFromUpstream) {
- if (!"generic".equals(format)) {
- throw validation("format must be 'generic'; CopyPackageVersions only supports the generic package "
- + "format.");
+ if (!"generic".equals(format) && !CONTAINER_BACKED_FORMATS.contains(format)) {
+ throw validation("format must be 'generic', 'maven', 'npm', 'pypi', or 'nuget'.");
}
boolean hasVersions = versions != null && !versions.isEmpty();
boolean hasRevisions = versionRevisions != null && !versionRevisions.isEmpty();
@@ -1323,6 +1345,12 @@ public class CodeArtifactService implements Resettable {
// is part of this action's documented error list (so it's a real possible response), but
// this codebase has no confirmed trigger for it on this action and does not guess one.
+ if (CONTAINER_BACKED_FORMATS.contains(format)) {
+ return copyContainerBackedPackageVersions(region, domain, owner, sourceRepository,
+ destinationRepository, format, namespace, packageName, requestedVersions, versionRevisions,
+ hasRevisions, allowOverwrite);
+ }
+
Map<String, PackageVersionCopyFailure> failures = new LinkedHashMap<>();
List<String> pendingCopies = new ArrayList<>();
Map<String, CodeArtifactPackageVersion> sourceByVersion = new LinkedHashMap<>();
@@ -1393,6 +1421,301 @@ public class CodeArtifactService implements Resettable {
return new CopyPackageVersionsResult(successes, Map.of());
}
+ /**
+ * {@link #copyPackageVersions}'s bridge for a container-backed format: the same NOT_FOUND /
+ * MISMATCHED_REVISION / identical-content-no-op / ALREADY_EXISTS / all-or-nothing-SKIPPED
+ * semantics as the {@code generic} path, built on the sidecar primitives {@link
+ * RepositorySidecarManager#listPackageVersionAssetNames}, {@link
+ * RepositorySidecarManager#fetchPackageVersionAsset}, {@link
+ * RepositorySidecarManager#storePackageVersionAsset}, and {@link
+ * RepositorySidecarManager#deletePackageVersionAsset} instead of the generic path's own {@code
+ * packageVersions} store. {@code requestedVersions} and {@code hasRevisions} are the caller's
+ * own already-validated, already-deduplicated values, not recomputed here.
+ *
+ * <p>Every container-backed format's {@link RepositorySidecarManager} overrides all four of
+ * these today. A future format whose sidecar manager does not would have its default throw
+ * {@link UnsupportedOperationException} from the first one reached, caught here and turned
+ * into a real, if deliberately blunt, {@code InternalServerException}: the same convention
+ * {@link #deleteContainerBackedPackageIfPresent} already uses for a sidecar capability not
+ * yet built, rather than a silent no-op or an unhandled 500.
+ *
+ * <p>There is no persisted hash to re-verify a container-backed asset's bytes against the way
+ * {@link #verifyAndReadSourceAssets} does for generic, so this only confirms an asset {@link
+ * RepositorySidecarManager#listPackageVersionAssetNames} just reported is still fetchable
+ * immediately afterward, failing the whole batch with {@code InternalServerException} if not
+ * (the same storage-integrity failure {@link #verifyAndReadSourceAssets} reports, just without
+ * a hash to compare).
+ *
+ * <p>{@code hasRevisions} can succeed here the same as for {@code generic}: {@link
+ * #synthesizeContainerBackedRevision} is truncated to {@link #MAX_REVISION_LENGTH} (50)
+ * characters specifically so a revision a caller obtained from {@code
+ * DescribePackageVersion}/{@code GetPackageVersionAsset} always fits back into {@code
+ * versionRevisions}' own 1-50 character value constraint and compares equal when it is in
+ * fact the current one.
+ */
+ private CopyPackageVersionsResult copyContainerBackedPackageVersions(String region, String domain, String owner,
+ String sourceRepository, String destinationRepository, String format, String namespace,
+ String packageName, List<String> requestedVersions, Map<String, String> versionRevisions,
+ boolean hasRevisions, boolean allowOverwrite) {
+ RepositorySidecarManager manager = sidecarRegistry.forFormat(format)
+ .orElseThrow(() -> new AwsException("InternalServerException", "Copying a " + format
+ + " package version is not yet supported by this emulator.", 500));
+ String sourceRepoId = ensureFormatContainerId(format, region, domain, owner, sourceRepository);
+ String destRepoId = ensureFormatContainerId(format, region, domain, owner, destinationRepository);
+
+ Map<String, PackageVersionCopyFailure> failures = new LinkedHashMap<>();
+ List<String> pendingCopies = new ArrayList<>();
+ Map<String, List<String>> sourceAssetNamesByVersion = new LinkedHashMap<>();
+ Map<String, List<String>> destAssetNamesByVersion = new LinkedHashMap<>();
+ try {
+ for (String version : requestedVersions) {
+ if (!manager.packageVersionExists(sourceRepoId, domain, sourceRepository, namespace, packageName,
+ version)) {
+ failures.put(version, new PackageVersionCopyFailure("NOT_FOUND", "Could not find version "
+ + version));
+ continue;
+ }
+ if (hasRevisions) {
+ String expectedRevision = versionRevisions.get(version);
+ String actualRevision = synthesizeContainerBackedRevision(sourceRepoId, namespace, packageName,
+ version);
+ if (!actualRevision.equals(expectedRevision)) {
+ failures.put(version, new PackageVersionCopyFailure("MISMATCHED_REVISION",
+ "current revision: " + actualRevision + ", expected revision: "
+ + expectedRevision));
+ continue;
+ }
+ }
+ List<String> sourceAssetNames = manager.listPackageVersionAssetNames(sourceRepoId, domain,
+ sourceRepository, namespace, packageName, version);
+ boolean destExists = manager.packageVersionExists(destRepoId, domain, destinationRepository,
+ namespace, packageName, version);
+ if (destExists) {
+ List<String> destAssetNames = manager.listPackageVersionAssetNames(destRepoId, domain,
+ destinationRepository, namespace, packageName, version);
+ if (containerBackedVersionContentMatches(manager, sourceRepoId, sourceRepository, destRepoId,
+ destinationRepository, domain, namespace, packageName, version, sourceAssetNames,
+ destAssetNames)) {
+ // Identical in both repositories already: the same already-successful,
+ // not-listed-anywhere no-op the generic path applies (see
+ // #copyPackageVersions's own javadoc).
+ continue;
+ }
+ if (!allowOverwrite) {
+ failures.put(version, new PackageVersionCopyFailure("ALREADY_EXISTS",
+ "Version " + version + " already exists"));
+ continue;
+ }
+ destAssetNamesByVersion.put(version, destAssetNames);
+ }
+ sourceAssetNamesByVersion.put(version, sourceAssetNames);
+ pendingCopies.add(version);
+ }
+ } catch (UnsupportedOperationException e) {
+ throw new AwsException("InternalServerException", "Copying a " + format + " package version is not "
+ + "yet supported by this emulator.", 500);
+ }
+
+ if (!failures.isEmpty()) {
+ for (String version : pendingCopies) {
+ failures.put(version, new PackageVersionCopyFailure("SKIPPED", "Version " + version
+ + " was skipped"));
+ }
+ return new CopyPackageVersionsResult(Map.of(), failures);
+ }
+
+ // Same verify-before-write ordering as the generic path's own two-pass split: every
+ // pending version's source assets are fetched and confirmed present before any version in
+ // this batch has anything written to the destination.
+ Map<String, Map<String, byte[]>> verifiedContentByVersion = new LinkedHashMap<>();
+ for (String version : pendingCopies) {
+ Map<String, byte[]> contentByAsset = new LinkedHashMap<>();
+ for (String assetName : sourceAssetNamesByVersion.get(version)) {
+ byte[] content = manager.fetchPackageVersionAsset(sourceRepoId, domain, sourceRepository, namespace,
+ packageName, version, assetName)
+ .orElseThrow(() -> new AwsException("InternalServerException", "Could not copy version '"
+ + version + "' of package '" + packageName + "': its asset '" + assetName
+ + "' disappeared from the source repository between listing and fetching it.",
+ 500));
+ contentByAsset.put(assetName, content);
+ }
+ verifiedContentByVersion.put(version, contentByAsset);
+ }
+
+ Map<String, PackageVersionCopyOutcome> successes = new LinkedHashMap<>();
+ for (String version : pendingCopies) {
+ List<String> destAssetNames = destAssetNamesByVersion.getOrDefault(version, List.of());
+ Map<String, byte[]> originalContent = new LinkedHashMap<>();
+ for (String destAssetName : destAssetNames) {
+ manager.fetchPackageVersionAsset(destRepoId, domain, destinationRepository, namespace, packageName,
+ version, destAssetName)
+ .ifPresent(content -> originalContent.put(destAssetName, content));
+ }
+ List<String> touchedAssetNames = new ArrayList<>();
+ // Snapshotted immediately before this version's own writes, the same way every other
+ // container-backed write path already takes its fence snapshot right before issuing
+ // the real write it will later report: recording this version's bytes must still
+ // reflect the latest live state even if an earlier version in this same batch call
+ // already changed it (there is no shared snapshot spanning the whole batch to go
+ // stale as later versions are processed).
+ long packageFenceSnapshot = currentContainerBackedPackageFence(region, domain, owner,
+ destinationRepository, format, namespace, packageName);
+ long bytesWritten = 0L;
+ try {
+ // Every asset this version already held at the destination is deleted first, in
+ // its own phase, before anything new is written: pypiserver's own delete call
+ // (confirmed live) removes every file sharing that exact package name and
+ // version, not just the one asset name passed to it, so deleting a same-named
+ // asset in the middle of a per-asset write loop would silently wipe a sibling
+ // asset (e.g. the wheel of a release also carrying an sdist) already rewritten
+ // earlier in that same loop. Clearing everything up front, before any of this
+ // version's new content exists to be collaterally wiped, is correct for every
+ // format: Reposilite/Verdaccio/BaGetter's own deletes are already scoped to
+ // exactly the asset (or, for npm/nuget, the single asset their formats ever hold
+ // per version) being removed, so doing them first changes nothing for them, and
+ // still satisfies Reposilite's own redeployment:false rejection of a plain PUT
+ // over differing existing content the same way the previous interleaved ordering
+ // did.
+ for (String destAssetName : destAssetNames) {
+ manager.deletePackageVersionAsset(destRepoId, domain, destinationRepository, namespace,
+ packageName, version, destAssetName);
+ touchedAssetNames.add(destAssetName);
+ }
+ for (Map.Entry<String, byte[]> entry : verifiedContentByVersion.get(version).entrySet()) {
+ String assetName = entry.getKey();
+ manager.copyPackageVersionAsset(sourceRepoId, domain, sourceRepository, destRepoId,
+ destinationRepository, namespace, packageName, version, assetName, entry.getValue());
+ if (!touchedAssetNames.contains(assetName)) {
+ touchedAssetNames.add(assetName);
+ }
+ bytesWritten += entry.getValue().length;
+ }
+ manager.recordVersionAvailable(destRepoId, domain, destinationRepository, namespace, packageName,
+ version);
+ } catch (RuntimeException e) {
+ rollbackContainerBackedVersionWrite(manager, destRepoId, domain, destinationRepository, namespace,
+ packageName, version, originalContent, touchedAssetNames);
+ throw e;
+ }
+ if (bytesWritten > 0) {
+ recordContainerBackedAssetBytes(region, domain, owner, destinationRepository, format, namespace,
+ packageName, bytesWritten, packageFenceSnapshot);
+ }
+ copyCapturedReadmeIfApplicable(region, domain, owner, sourceRepository, destinationRepository, format,
+ namespace, packageName, version);
+ String revision = synthesizeContainerBackedRevision(destRepoId, namespace, packageName, version);
+ successes.put(version, new PackageVersionCopyOutcome(revision, "Published"));
+ }
+ return new CopyPackageVersionsResult(successes, Map.of());
+ }
+
+ /**
+ * Propagates the source version's captured readme to the destination for {@code npm} and
+ * {@code pypi}, the only two formats {@link #getPackageVersionReadme} answers from a record
+ * captured at publish time rather than live from the sidecar (see that method's own javadoc
+ * for why neither sidecar can answer for a specific version after the fact). Without this, a
+ * copied npm or pypi version's assets would land correctly at the destination while {@code
+ * GetPackageVersionReadme} 404s on it there, even though the source genuinely has one: this
+ * bridge's own asset copy has no other way to reach that text, since it lives only in this
+ * service's own {@code packageVersionReadmes} map, never in the sidecar content itself.
+ *
+ * <p>{@code nuget} needs no equivalent call: {@link #getPackageVersionReadme} already answers
+ * it live against the sidecar, and the {@code .nupkg} this bridge already copied carries its
+ * own embedded readme/nuspec description with it. {@code maven} has no readme concept in
+ * Floci at all (absent from {@link #README_FORMATS}).
+ *
+ * <p>A missing source entry (no capture ever ran for that version, only possible for data
+ * from before this call existed) is silently skipped, not treated as a failure: there is
+ * nothing to propagate, the same way a version genuinely published with no readme field
+ * already records an empty string rather than nothing (see {@link
+ * #recordPublishedPackageVersionReadme}'s own callers). Any other failure here is logged and
+ * swallowed rather than thrown: this is the same best-effort side channel {@link
+ * #recordPublishedPackageVersionReadme}'s own javadoc already describes it as, so it must
+ * never turn a copy that otherwise fully succeeded against the real sidecar into a thrown
+ * exception over this alone.
+ */
+ private void copyCapturedReadmeIfApplicable(String region, String domain, String owner, String sourceRepository,
+ String destinationRepository, String format, String namespace, String packageName, String version) {
+ if (!"npm".equals(format) && !"pypi".equals(format)) {
+ return;
+ }
+ try {
+ String sourceKey = packageVersionKey(region, domain, sourceRepository, format, namespace,
+ accountingPackageName(format, packageName), version);
+ String readme = packageVersionReadmes.get(ownerScopedKey(owner, sourceKey));
+ if (readme == null) {
+ return;
+ }
+ long readmeFenceSnapshot = currentContainerBackedPackageFence(region, domain, owner,
+ destinationRepository, format, namespace, packageName);
+ recordPublishedPackageVersionReadme(region, domain, owner, destinationRepository, format, namespace,
+ packageName, version, readme, readmeFenceSnapshot);
+ } catch (RuntimeException e) {
+ LOG.warnv(e, "Could not copy {0}/{1} package ''{2}'' version ''{3}''''s readme to {4}; the copied "
+ + "version itself still succeeded.", domain, sourceRepository, packageName, version,
+ destinationRepository);
+ }
+ }
+
+ /**
+ * Best-effort compensating cleanup for one version's partially-applied destination writes
+ * after {@link #copyContainerBackedPackageVersions} hits a failure partway through them:
+ * every asset this call itself touched is restored to whatever it held before (if it
+ * pre-existed, from {@code originalContent}) or deleted outright (if it was new). Does not
+ * attempt to re-create a stale asset it had not yet gotten to deleting, or undo a successful
+ * {@link RepositorySidecarManager#recordVersionAvailable} call, since neither leaves the
+ * destination in a worse state than before this version's write began. A failure during the
+ * rollback itself is logged and swallowed, never thrown over the original failure that
+ * triggered it: a best-effort cleanup that cannot fully complete is still strictly no worse
+ * than not attempting one, and must never hide the real error behind a cleanup error instead.
+ */
+ private void rollbackContainerBackedVersionWrite(RepositorySidecarManager manager, String destRepoId,
+ String domain, String destinationRepository, String namespace, String packageName, String version,
+ Map<String, byte[]> originalContent, List<String> touchedAssetNames) {
+ for (String assetName : touchedAssetNames) {
+ try {
+ byte[] original = originalContent.get(assetName);
+ if (original != null) {
+ manager.storePackageVersionAsset(destRepoId, domain, destinationRepository, namespace,
+ packageName, version, assetName, original);
+ } else {
+ manager.deletePackageVersionAsset(destRepoId, domain, destinationRepository, namespace,
+ packageName, version, assetName);
+ }
+ } catch (RuntimeException rollbackFailure) {
+ LOG.warnv(rollbackFailure, "Best-effort rollback could not restore {0}/{1} package ''{2}'' "
+ + "version ''{3}'' asset ''{4}'' after a failed copy; the destination may still be "
+ + "left in a partially-copied state for this version.", domain, destinationRepository,
+ packageName, version, assetName);
+ }
+ }
+ }
+
+ /**
+ * {@code true} only when {@code source} and {@code dest} hold the exact same asset names for
+ * this version, each fetching to byte-identical content: the container-backed equivalent of
+ * {@link #packageVersionContentMatches}, which compares persisted hashes instead since generic
+ * assets have one and these don't.
+ */
+ private static boolean containerBackedVersionContentMatches(RepositorySidecarManager manager,
+ String sourceRepoId, String sourceRepository, String destRepoId, String destinationRepository,
+ String domain, String namespace, String packageName, String version, List<String> sourceAssetNames,
+ List<String> destAssetNames) {
+ if (!new LinkedHashSet<>(sourceAssetNames).equals(new LinkedHashSet<>(destAssetNames))) {
+ return false;
+ }
+ for (String assetName : sourceAssetNames) {
+ byte[] sourceContent = manager.fetchPackageVersionAsset(sourceRepoId, domain, sourceRepository,
+ namespace, packageName, version, assetName).orElse(null);
+ byte[] destContent = manager.fetchPackageVersionAsset(destRepoId, domain, destinationRepository,
+ namespace, packageName, version, assetName).orElse(null);
+ if (!Arrays.equals(sourceContent, destContent)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
/**
* Reads every one of {@code source}'s assets and confirms each one's actual bytes still hash
* to what its own persisted metadata claims, returning the verified bytes keyed by asset name.
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java
index 656545972d..b7db78dc59 100644
--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java
@@ -14,6 +14,7 @@ import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
+import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
@@ -159,6 +160,126 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {
}
}
+ /**
+ * Every filename pypiserver's own per-project JSON listing records for exactly {@code
+ * version}, for bridging {@code CopyPackageVersions} when there is no generic-format record
+ * to enumerate assets from. Reuses the same {@code GET /<project>/json} endpoint {@link
+ * #packageFiles} already does, this time keeping the filename itself rather than discarding
+ * it for the recovered raw name {@link #packageFiles} needs.
+ */
+ @Override
+ public List<String> listPackageVersionAssetNames(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version) {
+ String baseUrl = ensureReady(repositoryContainerId, null);
+ String normalized = normalizePackageName(packageName);
+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/" + SidecarUriUtils.encodeSegment(normalized)
+ + "/json");
+ HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(10)).GET().build();
+ HttpResponse<String> response;
+ try {
+ response = httpClient.send(request, BodyHandlers.ofString());
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not reach the pypiserver sidecar to list versions of "
+ + packageName, e);
+ }
+ if (response.statusCode() == 404) {
+ return List.of();
+ }
+ if (response.statusCode() != 200) {
+ throw new IllegalStateException("Could not list versions of " + packageName + " on the pypiserver "
+ + "sidecar: upstream returned " + response.statusCode());
+ }
+ JsonNode release;
+ try {
+ release = mapper.readTree(response.body()).path("releases").path(version);
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not parse pypiserver's version listing for " + packageName, e);
+ }
+ List<String> filenames = new ArrayList<>();
+ for (JsonNode file : release) {
+ String url = file.path("url").asText("");
+ String filename = url.substring(url.lastIndexOf('/') + 1);
+ if (!filename.isEmpty()) {
+ filenames.add(filename);
+ }
+ }
+ return filenames;
+ }
+
+ /**
+ * Uploads {@code content} as {@code assetName} the same real {@code twine upload} wire shape
+ * {@code CodeArtifactPypiController#upload} already forwards unmodified, confirmed against a
+ * live pypiserver container: a {@code multipart/form-data} {@code POST} to the repository
+ * root with a {@code :action=file_upload} field (pypiserver rejects the request outright
+ * without it, "Missing ':action' field!", even though neither twine's own real request nor
+ * this sidecar's existing upload-forwarding path ever has to name it explicitly), {@code
+ * name}/{@code version} fields, and the file itself as the {@code content} part. pypiserver
+ * indexes a package by parsing {@code assetName} itself (PEP 427/517 naming), not the
+ * {@code name} field, so a mismatched filename silently publishes under whatever name the
+ * filename itself implies instead of {@code packageName} — the caller is expected to pass a
+ * {@code version}-embedding {@code assetName} the same way {@link #fetchPackageVersionAsset}
+ * already requires one to read it back.
+ *
+ * <p>Rejected outright with a real {@code 409} ("already exists") if {@code assetName}
+ * already exists with different content, confirmed live: this container is started without
+ * pypiserver's own {@code --overwrite} flag, the same as production. The caller ({@code
+ * CodeArtifactService#copyContainerBackedPackageVersions}) is expected to have already
+ * deleted a conflicting existing asset first for an overwrite, the same reason {@code
+ * ReposiliteSidecarClient#storePackageVersionAsset} documents for Maven.
+ */
+ @Override
+ public void storePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName, byte[] content) {
+ String baseUrl = ensureReady(repositoryContainerId, null);
+ String boundary = "flociPypiCopyBoundary" + System.nanoTime();
+ byte[] head = ("--" + boundary + "\r\n"
+ + "Content-Disposition: form-data; name=\":action\"\r\n\r\nfile_upload\r\n"
+ + "--" + boundary + "\r\n"
+ + "Content-Disposition: form-data; name=\"name\"\r\n\r\n" + packageName + "\r\n"
+ + "--" + boundary + "\r\n"
+ + "Content-Disposition: form-data; name=\"version\"\r\n\r\n" + version + "\r\n"
+ + "--" + boundary + "\r\n"
+ + "Content-Disposition: form-data; name=\"content\"; filename=\"" + assetName + "\"\r\n"
+ + "Content-Type: application/octet-stream\r\n\r\n").getBytes(StandardCharsets.UTF_8);
+ byte[] tail = ("\r\n--" + boundary + "--\r\n").getBytes(StandardCharsets.UTF_8);
+ byte[] body = new byte[head.length + content.length + tail.length];
+ System.arraycopy(head, 0, body, 0, head.length);
+ System.arraycopy(content, 0, body, head.length, content.length);
+ System.arraycopy(tail, 0, body, head.length + content.length, tail.length);
+
+ HttpRequest request = HttpRequest.newBuilder(URI.create(baseUrl + "/"))
+ .timeout(Duration.ofSeconds(30))
+ .header("Content-Type", "multipart/form-data; boundary=" + boundary)
+ .POST(BodyPublishers.ofByteArray(body))
+ .build();
+ HttpResponse<String> response;
+ try {
+ response = httpClient.send(request, BodyHandlers.ofString());
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not reach the pypiserver sidecar to publish " + assetName, e);
+ }
+ if (response.statusCode() != 200 && response.statusCode() != 201) {
+ throw new IllegalStateException("Could not publish " + assetName + " to the pypiserver sidecar: "
+ + "upstream returned " + response.statusCode());
+ }
+ }
+
+ /**
+ * Removes one asset via pypiserver's own {@code remove_pkg} management call, confirmed live
+ * to delete by raw name/version rather than by filename: {@link #rawPkgname} recovers the
+ * exact unnormalized name {@code remove_pkg} needs from {@code assetName} itself, the same way
+ * {@link #deletePackage}'s own loop already does per file. A sibling file that happens to
+ * share the exact same raw name and version as {@code assetName} is removed in the same call
+ * (confirmed live for {@link #deletePackage}'s own multi-file case); pypiserver has no finer
+ * grain than that to ask for.
+ */
+ @Override
+ public void deletePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName) {
+ String baseUrl = ensureReady(repositoryContainerId, null);
+ removeVersion(baseUrl, rawPkgname(assetName, version), version);
+ }
+
private record PkgNameVersion(String name, String version) {}
private Set<PkgNameVersion> packageFiles(String baseUrl, String packageName) {
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.java
index cc8601ae44..fba3c2e587 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
@@ -4,6 +4,8 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.github.hectorvent.floci.core.common.XmlBuilder;
+import io.github.hectorvent.floci.core.common.XmlParser;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.jboss.logging.Logger;
@@ -17,8 +19,14 @@ import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
+import java.nio.charset.StandardCharsets;
import java.time.Duration;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
import java.util.Arrays;
+import java.util.List;
import java.util.Optional;
/**
@@ -36,6 +44,9 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
private static final String MAVEN_SETTINGS_PATH = "/api/settings/domain/maven";
private static final int REPOSITORY_READY_POLL_MAX_MS = 3_000;
private static final int REPOSITORY_READY_POLL_INTERVAL_MS = 50;
+ /** Real Maven metadata's own documented {@code lastUpdated} shape: UTC, {@code yyyyMMddHHmmss}. */
+ private static final DateTimeFormatter METADATA_TIMESTAMP = DateTimeFormatter.ofPattern("yyyyMMddHHmmss")
+ .withZone(ZoneOffset.UTC);
private final ReposiliteSidecarManager manager;
private final ObjectMapper mapper;
@@ -193,8 +204,7 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
public boolean packageVersionExists(String repositoryContainerId, String domain, String repository,
String namespace, String packageName, String version) {
String baseUrl = manager.ensureReady();
- String path = "/api/maven/details" + packageDirectoryPath(repositoryContainerId, namespace, packageName)
- + SidecarUriUtils.encodeSegment(version);
+ String path = versionDetailsPath(repositoryContainerId, namespace, packageName, version);
HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl), path))
.timeout(Duration.ofSeconds(30))
.header("Authorization", manager.basicAuthHeader())
@@ -211,6 +221,174 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
return true;
}
+ private static String versionDetailsPath(String repositoryContainerId, String namespace, String packageName,
+ String version) {
+ return "/api/maven/details" + packageDirectoryPath(repositoryContainerId, namespace, packageName)
+ + SidecarUriUtils.encodeSegment(version);
+ }
+
+ /**
+ * Reposilite's own details API, already relied on by {@link #packageVersionExists} to confirm
+ * a version directory exists, also lists every entry directly beneath it: this reads that same
+ * response's {@code files} array a second way, keeping only the {@code FILE} entries (never a
+ * subdirectory, though a plain Maven version directory never has one) and returning their
+ * names, for {@code CopyPackageVersions} to enumerate what it needs to fetch and copy without
+ * any generic-format {@code packageVersions} record to read an asset list from.
+ */
+ @Override
+ public List<String> listPackageVersionAssetNames(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version) {
+ String baseUrl = manager.ensureReady();
+ String path = versionDetailsPath(repositoryContainerId, namespace, packageName, version);
+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl), path))
+ .timeout(Duration.ofSeconds(30))
+ .header("Authorization", manager.basicAuthHeader())
+ .GET()
+ .build();
+ HttpResponse<String> response = send(request, BodyHandlers.ofString());
+ if (response.statusCode() == 404) {
+ return List.of();
+ }
+ if (response.statusCode() != 200) {
+ throw new IllegalStateException("Could not list " + packageName + " " + version + " on the Reposilite "
+ + "sidecar: upstream returned " + response.statusCode());
+ }
+ JsonNode details = readTree(response.body());
+ List<String> names = new ArrayList<>();
+ for (JsonNode entry : details.path("files")) {
+ if ("FILE".equals(entry.path("type").asText())) {
+ names.add(entry.path("name").asText());
+ }
+ }
+ return names;
+ }
+
+ /**
+ * Writes {@code content} straight to this version's {@code assetName} path, for {@code
+ * CopyPackageVersions}'s destination write. Unlike {@link #deployArtifact}, this never
+ * short-circuits on an existing byte-identical match and never leaves Reposilite's own {@code
+ * redeployment: false} rejection standing in the way of a differing overwrite: the caller
+ * ({@code CodeArtifactService#copyContainerBackedPackageVersions}) has already decided, from
+ * its own all-or-nothing batch semantics, exactly which versions get overwritten, and has
+ * already called {@link #deletePackageVersionAsset} first for any asset this would otherwise
+ * conflict with, so there is nothing left here to defer to Reposilite's own native-publish
+ * conflict rule for.
+ */
+ @Override
+ public void storePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName, byte[] content) {
+ ensureRepository(repositoryContainerId);
+ String baseUrl = manager.ensureReady();
+ String gav = versionGav(namespace, packageName, version, assetName);
+ HttpRequest request = authenticated(baseUrl, repositoryContainerId, gav)
+ .PUT(BodyPublishers.ofByteArray(content))
+ .build();
+ int status = send(request, BodyHandlers.discarding()).statusCode();
+ if (status != 200 && status != 201) {
+ throw new IllegalStateException("Could not copy " + packageName + " " + version + "'s asset "
+ + assetName + " to the Reposilite sidecar: upstream returned " + status);
+ }
+ }
+
+ /**
+ * Deletes one already-published asset outright, confirmed working for an arbitrarily deep path
+ * the same way {@link #deletePackage}'s own group/artifact-directory {@code DELETE} is already
+ * confirmed to work for a shallower one: Reposilite applies the same verb to whatever path it is
+ * given, file or directory. Only ever called by {@code CopyPackageVersions}'s overwrite path for
+ * an asset {@link #listPackageVersionAssetNames} already confirmed exists, so unlike {@link
+ * #deletePackage} this never has to special-case a never-existing path.
+ */
+ @Override
+ public void deletePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName) {
+ String baseUrl = manager.ensureReady();
+ String gav = versionGav(namespace, packageName, version, assetName);
+ HttpRequest request = authenticated(baseUrl, repositoryContainerId, gav).DELETE().build();
+ HttpResponse<Void> response = send(request, BodyHandlers.discarding());
+ if (response.statusCode() != 200) {
+ throw new IllegalStateException("Could not delete " + packageName + " " + version + "'s asset "
+ + assetName + " from the Reposilite sidecar: upstream returned " + response.statusCode());
+ }
+ }
+
+ /**
+ * The real Maven repository layout path for one asset of one package version:
+ * {@code <groupId-as-slashes>/<artifactId>/<version>/<filename>}, the same shape {@link
+ * #deployArtifact} and {@link #fetchArtifact} already take as their own {@code gav} parameter
+ * (and the inverse of what {@code CodeArtifactMavenController#parseNamespaceAndPackageName}
+ * builds back out of it).
+ */
+ private static String versionGav(String namespace, String packageName, String version, String assetName) {
+ return namespace.replace('.', '/') + "/" + packageName + "/" + version + "/" + assetName;
+ }
+
+ /**
+ * Merges {@code version} into the group/artifact-level {@code maven-metadata.xml} a real
+ * {@code mvn deploy} always also PUTs, separately from the version directory itself: without
+ * this, a version {@code CopyPackageVersions} lands straight in the version directory would
+ * never show up to a real client resolving "what versions does this artifact have" against
+ * the destination, the one thing this bridge's {@link #listPackageVersionAssetNames}/{@link
+ * #storePackageVersionAsset} pair, scoped to one version directory each, cannot reach.
+ *
+ * <p>Confirmed against a live Reposilite container, same as every other wire assumption in
+ * this class: unlike a release artifact, a metadata file is not subject to the repository's
+ * own {@code redeployment: false} setting, so {@link #deployArtifact} can PUT one with
+ * genuinely different content every time without the conflict a real artifact overwrite
+ * would hit.
+ *
+ * <p>{@code latest} is set to {@code version}: real Maven defines it as whichever version was
+ * most recently added, and this call existing at all means {@code version} just was. {@code
+ * release} only moves to {@code version} when it is not a {@code -SNAPSHOT}; a snapshot copy
+ * leaves whatever release version the metadata already named untouched. An existing
+ * {@code groupId}/{@code artifactId} already on the file is preserved verbatim rather than
+ * re-derived from {@code namespace}/{@code packageName}, since nothing here needs it to be;
+ * the already-published metadata is trusted over Floci's own request-path coordinates for
+ * these two fields specifically.
+ */
+ @Override
+ public void recordVersionAvailable(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version) {
+ ensureRepository(repositoryContainerId);
+ String gav = artifactMetadataGav(namespace, packageName);
+ Optional<FetchedArtifact> existing = fetchArtifact(repositoryContainerId, gav);
+ List<String> versions = new ArrayList<>();
+ String groupId = namespace;
+ String artifactId = packageName;
+ String release = null;
+ if (existing.isPresent()) {
+ String xml = new String(existing.get().content(), StandardCharsets.UTF_8);
+ versions.addAll(XmlParser.extractAll(xml, "version"));
+ groupId = XmlParser.extractFirst(xml, "groupId", namespace);
+ artifactId = XmlParser.extractFirst(xml, "artifactId", packageName);
+ release = XmlParser.extractFirst(xml, "release", null);
+ }
+ if (!versions.contains(version)) {
+ versions.add(version);
+ }
+ if (!version.endsWith("-SNAPSHOT")) {
+ release = version;
+ }
+ XmlBuilder metadata = new XmlBuilder().start("metadata")
+ .elem("groupId", groupId)
+ .elem("artifactId", artifactId)
+ .start("versioning")
+ .elem("latest", version)
+ .elem("release", release)
+ .start("versions");
+ for (String v : versions) {
+ metadata.elem("version", v);
+ }
+ metadata.end("versions")
+ .elem("lastUpdated", METADATA_TIMESTAMP.format(Instant.now()))
+ .end("versioning")
+ .end("metadata");
+ deployArtifact(repositoryContainerId, gav, metadata.build().getBytes(StandardCharsets.UTF_8));
+ }
+
+ private static String artifactMetadataGav(String namespace, String packageName) {
+ return namespace.replace('.', '/') + "/" + packageName + "/maven-metadata.xml";
+ }
+
/** Ensures a Reposilite repository named {@code repoId} exists, creating it if not. */
public void ensureRepository(String repoId) {
String baseUrl = manager.ensureReady();
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java
index 240afc62fe..d81a0631ce 100644
--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java
@@ -1,5 +1,6 @@
package io.github.hectorvent.floci.services.codeartifact;
+import java.util.List;
import java.util.Optional;
/**
@@ -113,4 +114,80 @@ public interface RepositorySidecarManager {
String namespace, String packageName, String version) {
return Optional.empty();
}
+
+ /**
+ * Lists the asset name of every file published under one package version, for bridging
+ * {@code CopyPackageVersions} when there is no generic-format record to enumerate assets from
+ * the way {@code CodeArtifactPackageVersion#getAssets} does. The default throws {@link
+ * UnsupportedOperationException}, the same convention {@link #deletePackage} already uses for
+ * a capability not every sidecar backs; every container-backed format's own client overrides
+ * this today.
+ */
+ default List<String> listPackageVersionAssetNames(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version) {
+ throw new UnsupportedOperationException(format() + " package versions cannot be listed through this "
+ + "sidecar");
+ }
+
+ /**
+ * Writes one named asset's bytes directly into this sidecar's own backing storage for the
+ * given package version, for bridging {@code CopyPackageVersions}'s destination write. The
+ * caller is expected to have already removed any conflicting content at this exact path first
+ * (see {@link #deletePackageVersionAsset}) when overwriting, since this is a direct admin-level
+ * write, not a replay of whatever conflict rule the sidecar's own native publish path enforces.
+ * The default throws {@link UnsupportedOperationException}.
+ */
+ default void storePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName, byte[] content) {
+ throw new UnsupportedOperationException(format() + " package versions cannot be copied through this "
+ + "sidecar");
+ }
+
+ /**
+ * {@code CopyPackageVersions}' own destination write, as opposed to a bare {@link
+ * #storePackageVersionAsset} call with no notion of a source: the default simply forwards to
+ * it, correct for a format whose version-level metadata is entirely recoverable from the
+ * asset bytes alone (Maven's POM/jar pair, pypi's sdist/wheel, nuget's one-file nupkg, none of
+ * which keep anything outside what {@code content} itself carries). {@code
+ * VerdaccioSidecarClient} overrides this: npm's packument carries fields ({@code
+ * dependencies}, {@code scripts}, {@code engines}, ...) on the version document itself, so
+ * building a fresh one from scratch the way {@link #storePackageVersionAsset} does on its own
+ * drops them; this instead reuses the source's own version entry verbatim, with only {@code
+ * dist.tarball}/{@code dist.shasum}/{@code dist.integrity} rewritten to point at the copy.
+ */
+ default void copyPackageVersionAsset(String sourceRepositoryContainerId, String domain, String sourceRepository,
+ String repositoryContainerId, String repository, String namespace, String packageName, String version,
+ String assetName, byte[] content) {
+ storePackageVersionAsset(repositoryContainerId, domain, repository, namespace, packageName, version,
+ assetName, content);
+ }
+
+ /**
+ * Deletes one already-confirmed-present named asset from this sidecar's own backing storage
+ * for the given package version, used by {@code CopyPackageVersions}'s overwrite path to drop
+ * an asset the destination version held that the source version no longer does, and to clear
+ * the way for {@link #storePackageVersionAsset} to replace an asset whose content differs. The
+ * default throws {@link UnsupportedOperationException}.
+ */
+ default void deletePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName) {
+ throw new UnsupportedOperationException(format() + " package version assets cannot be deleted through "
+ + "this sidecar");
+ }
+
+ /**
+ * Records that {@code version} now exists under this package, for whatever artifact-level
+ * version listing this format's sidecar keeps separately from the version directory itself
+ * (one {@link #storePackageVersionAsset}/{@link #deletePackageVersionAsset} call already
+ * writes to), so a real client resolving "what versions does this artifact have" sees it.
+ * The default is a no-op: most formats have no such separate listing, since their package
+ * document is derived live from the version directories those two methods already maintain.
+ * {@code ReposiliteSidecarClient} overrides this: Maven's group/artifact-level {@code
+ * maven-metadata.xml} is a distinct upload a real {@code mvn deploy} always also PUTs,
+ * outside the version directory {@link #listPackageVersionAssetNames} enumerates, so nothing
+ * else here ever touches it on {@code maven}'s behalf.
+ */
+ default void recordVersionAvailable(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version) {
+ }
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.java
index c2d18e22c0..71b37a9269 100644
--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.java
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClient.java
@@ -2,7 +2,9 @@ package io.github.hectorvent.floci.services.codeartifact;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.core.common.Digests;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
@@ -11,12 +13,14 @@ import java.io.InputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
+import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Duration;
import java.util.Base64;
+import java.util.List;
import java.util.Optional;
/**
@@ -227,17 +231,220 @@ public class VerdaccioSidecarClient implements RepositorySidecarManager {
}
private boolean versionHasAsset(String baseUrl, String packagePath, String version, String assetName) {
- Optional<JsonNode> document = packageDocument(baseUrl, packagePath);
- if (document.isEmpty()) {
- return false;
+ return assetName.equals(tarballFilenameFor(packageDocument(baseUrl, packagePath).orElse(null), version));
+ }
+
+ /**
+ * The tarball filename Verdaccio's own packument records for {@code version}, derived from
+ * {@code versions[version].dist.tarball}'s own last path segment the same way {@link
+ * #fetchPackageVersionAsset} already trusts it, rather than assuming a fixed {@code
+ * <packageName>-<version>.tgz} shape: real npm names it that way, but nothing here needs to
+ * assume so when the packument already states it outright. {@code null} when the document is
+ * absent, the version doesn't exist, or the version has no tarball recorded.
+ */
+ private static String tarballFilenameFor(JsonNode document, String version) {
+ if (document == null) {
+ return null;
}
- JsonNode versionNode = document.get().path("versions").path(version);
+ JsonNode versionNode = document.path("versions").path(version);
if (versionNode.isMissingNode()) {
- return false;
+ return null;
}
String tarballUrl = versionNode.path("dist").path("tarball").asText("");
String tarballFilename = tarballUrl.substring(tarballUrl.lastIndexOf('/') + 1);
- return assetName.equals(tarballFilename);
+ return tarballFilename.isEmpty() ? null : tarballFilename;
+ }
+
+ /**
+ * npm has exactly one asset per version, the tarball: unlike Maven's version directory, there
+ * is no separate checksum sidecar file or secondary artifact to enumerate. Empty when the
+ * package or version doesn't exist, or the existing version has no tarball recorded (should
+ * not happen for anything this emulator itself ever published, but a real registry can be
+ * imported from or hand-edited).
+ */
+ @Override
+ public List<String> listPackageVersionAssetNames(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version) {
+ String baseUrl = ensureReady(repositoryContainerId, publicUrl(domain, repository));
+ String filename = tarballFilenameFor(
+ packageDocument(baseUrl, packagePath(namespace, packageName)).orElse(null), version);
+ return filename == null ? List.of() : List.of(filename);
+ }
+
+ /**
+ * Publishes {@code version} straight to this sidecar's own packument, the real npm registry
+ * wire shape confirmed against a live Verdaccio container: a {@code PUT} to the package path
+ * carrying just the new version's metadata, its tarball as a base64 {@code _attachments}
+ * entry, and {@code dist-tags.latest} pointed at it. Verdaccio merges this into whatever
+ * {@code versions} the package already has rather than requiring the caller to resend them
+ * (also confirmed live), so this never needs to read the existing packument first the way
+ * {@link #deletePackageVersionAsset} does. Rejected outright (a real {@code 409}, "this
+ * package is already present") if {@code version} already exists, even if its content is
+ * identical: the caller ({@code CodeArtifactService#copyContainerBackedPackageVersions}) is
+ * expected to have already deleted a conflicting existing version first for an overwrite, the
+ * same reason {@code ReposiliteSidecarClient#storePackageVersionAsset} documents for Maven.
+ */
+ @Override
+ public void storePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName, byte[] content) {
+ storeVersion(repositoryContainerId, domain, repository, namespace, packageName, version, assetName, content,
+ null);
+ }
+
+ /**
+ * Reuses {@code sourceRepositoryContainerId}'s own version entry verbatim (the exact document
+ * its original publish wrote, including {@code dependencies}/{@code scripts}/{@code engines}
+ * and anything else npm's own protocol carries on a version), rather than building a fresh,
+ * minimal one from scratch the way {@link #storePackageVersionAsset} does on its own — only
+ * {@code dist} is overwritten, to point at the copy's own tarball/shasum/integrity. Confirmed
+ * live that a copy with no matching source version entry (should not happen for anything this
+ * emulator itself ever published, but defends the same way {@link #listPackageVersionAssetNames}
+ * already does for a hand-edited registry) falls back to the same minimal document {@link
+ * #storePackageVersionAsset} would have built.
+ */
+ @Override
+ public void copyPackageVersionAsset(String sourceRepositoryContainerId, String domain, String sourceRepository,
+ String repositoryContainerId, String repository, String namespace, String packageName, String version,
+ String assetName, byte[] content) {
+ String sourceBaseUrl = ensureReady(sourceRepositoryContainerId, publicUrl(domain, sourceRepository));
+ JsonNode sourceVersionDoc = packageDocument(sourceBaseUrl, packagePath(namespace, packageName))
+ .map(doc -> doc.path("versions").path(version))
+ .filter(node -> !node.isMissingNode() && !node.isNull())
+ .orElse(null);
+ storeVersion(repositoryContainerId, domain, repository, namespace, packageName, version, assetName, content,
+ sourceVersionDoc);
+ }
+
+ private void storeVersion(String repositoryContainerId, String domain, String repository, String namespace,
+ String packageName, String version, String assetName, byte[] content, JsonNode sourceVersionDoc) {
+ String baseUrl = ensureReady(repositoryContainerId, publicUrl(domain, repository));
+ String path = packagePath(namespace, packageName);
+ String npmName = npmPackageName(namespace, packageName);
+ String tarballUrl = baseUrl + "/" + path + "/-/" + assetName;
+
+ ObjectNode versionDoc = sourceVersionDoc != null ? sourceVersionDoc.deepCopy() : mapper.createObjectNode();
+ versionDoc.put("name", npmName);
+ versionDoc.put("version", version);
+ if (!versionDoc.has("description")) {
+ versionDoc.put("description", "");
+ }
+ ObjectNode dist = versionDoc.putObject("dist");
+ dist.put("shasum", Digests.sha1Hex(content));
+ dist.put("integrity", "sha512-" + Base64.getEncoder().encodeToString(sha512().digest(content)));
+ dist.put("tarball", tarballUrl);
+
+ ObjectNode body = mapper.createObjectNode();
+ body.put("_id", npmName);
+ body.put("name", npmName);
+ body.put("description", "");
+ body.putObject("dist-tags").put("latest", version);
+ body.putObject("versions").set(version, versionDoc);
+ ObjectNode attachment = body.putObject("_attachments").putObject(assetName);
+ attachment.put("content_type", "application/octet-stream");
+ attachment.put("data", Base64.getEncoder().encodeToString(content));
+ attachment.put("length", content.length);
+
+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl), "/" + path))
+ .timeout(Duration.ofSeconds(30))
+ .header("Content-Type", "application/json")
+ .PUT(BodyPublishers.ofByteArray(writeValue(body)))
+ .build();
+ HttpResponse<Void> response;
+ try {
+ response = httpClient.send(request, BodyHandlers.discarding());
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not reach the Verdaccio sidecar to publish " + npmName + "@"
+ + version, e);
+ }
+ if (response.statusCode() != 200 && response.statusCode() != 201) {
+ throw new IllegalStateException("Could not publish " + npmName + "@" + version + " to the Verdaccio "
+ + "sidecar: upstream returned " + response.statusCode());
+ }
+ }
+
+ /**
+ * Removes one version from this package the same two-step way the real npm CLI's single-
+ * version {@code npm unpublish <pkg>@<version>} does, both confirmed live against a Verdaccio
+ * container: first a {@code PUT} of the packument with that version deleted from {@code
+ * versions} (and {@code dist-tags.latest} cleared if it pointed at the removed version),
+ * carrying the package's current {@code _rev} in the path for Verdaccio's own optimistic-
+ * concurrency check; then, once that succeeds and the package has a fresh {@code _rev} of its
+ * own, a {@code DELETE} of the tarball itself. Both steps are required: removing the version
+ * from the packument alone leaves the tarball file in place on Verdaccio's own storage, which
+ * then makes a same-named {@link #storePackageVersionAsset} republish fail with the same
+ * {@code 409} as before, since Verdaccio checks the stored file, not just the packument.
+ */
+ @Override
+ public void deletePackageVersionAsset(String repositoryContainerId, String domain, String repository,
+ String namespace, String packageName, String version, String assetName) {
+ String baseUrl = ensureReady(repositoryContainerId, publicUrl(domain, repository));
+ String path = packagePath(namespace, packageName);
+ ObjectNode document = (ObjectNode) packageDocument(baseUrl, path)
+ .orElseThrow(() -> new IllegalStateException(packageName + " no longer exists on the Verdaccio "
+ + "sidecar"));
+ String revision = document.path("_rev").asText("");
+ ((ObjectNode) document.path("versions")).remove(version);
+ ObjectNode distTags = (ObjectNode) document.path("dist-tags");
+ if (version.equals(distTags.path("latest").asText(""))) {
+ distTags.remove("latest");
+ }
+ putPackument(baseUrl, path, revision, document, packageName, version);
+
+ String revisionAfterRemove = packageDocument(baseUrl, path)
+ .orElseThrow(() -> new IllegalStateException(packageName + " no longer exists on the Verdaccio "
+ + "sidecar"))
+ .path("_rev").asText("");
+ URI tarballUri = SidecarUriUtils.combine(URI.create(baseUrl), "/" + path + "/-/"
+ + SidecarUriUtils.encodeSegment(assetName) + "/-rev/" + SidecarUriUtils.encodeSegment(
+ revisionAfterRemove));
+ HttpRequest deleteRequest = HttpRequest.newBuilder(tarballUri).timeout(Duration.ofSeconds(10)).DELETE()
+ .build();
+ HttpResponse<Void> deleteResponse;
+ try {
+ deleteResponse = httpClient.send(deleteRequest, BodyHandlers.discarding());
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not reach the Verdaccio sidecar to delete " + packageName + "@"
+ + version + "'s asset " + assetName, e);
+ }
+ if (deleteResponse.statusCode() != 200 && deleteResponse.statusCode() != 201) {
+ throw new IllegalStateException("Could not delete " + packageName + "@" + version + "'s asset "
+ + assetName + " from the Verdaccio sidecar: upstream returned " + deleteResponse.statusCode());
+ }
+ }
+
+ private void putPackument(String baseUrl, String path, String revision, ObjectNode document, String packageName,
+ String version) {
+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/" + path + "/-rev/"
+ + SidecarUriUtils.encodeSegment(revision));
+ HttpRequest request = HttpRequest.newBuilder(uri)
+ .timeout(Duration.ofSeconds(10))
+ .header("Content-Type", "application/json")
+ .PUT(BodyPublishers.ofByteArray(writeValue(document)))
+ .build();
+ HttpResponse<Void> response;
+ try {
+ response = httpClient.send(request, BodyHandlers.discarding());
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not reach the Verdaccio sidecar to update " + packageName + "@"
+ + version, e);
+ }
+ if (response.statusCode() != 200 && response.statusCode() != 201) {
+ throw new IllegalStateException("Could not update " + packageName + "@" + version + " on the "
+ + "Verdaccio sidecar: upstream returned " + response.statusCode());
+ }
+ }
+
+ /** The real npm package name, {@code @namespace/packageName} for a scoped package. */
+ private static String npmPackageName(String namespace, String packageName) {
+ return namespace == null ? packageName : "@" + namespace + "/" + packageName;
+ }
+
+ private byte[] writeValue(ObjectNode value) {
+ try {
+ return mapper.writeValueAsBytes(value);
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not serialize a Verdaccio request body", e);
+ }
}
private static MessageDigest sha512() {
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.java
index 9a431c2422..e7cfece17e 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
@@ -460,6 +460,91 @@ class CodeArtifactMavenDockerIntegrationTest {
.then().statusCode(404);
}
+ /**
+ * The real-world gap this closes: {@code CopyPackageVersions} used to only support the
+ * generic format, since Maven, npm, pypi, and nuget all keep their published assets straight
+ * in their own sidecar rather than a {@code packageVersions} record. Confirms the bridge
+ * reads every asset from the real Reposilite sidecar (not a mock) and writes them to the
+ * destination repository's own Reposilite path, byte for byte. {@code other-repo} is the
+ * empty repository {@link #repositoriesAreIsolatedFromEachOther} already created and never
+ * published to.
+ */
+ @Test
+ @Order(18)
+ void copyPackageVersionsBridgesToTheRealReposiliteSidecar() {
+ byte[] jarBytes = "copy-me-jar-bytes".getBytes(StandardCharsets.UTF_8);
+ byte[] pomBytes = "copy-me-pom-bytes".getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", "Bearer " + bearerToken).body(jarBytes)
+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/copyme/1.0.0/copyme-1.0.0.jar")
+ .then().statusCode(200);
+ given().header("Authorization", "Bearer " + bearerToken).body(pomBytes)
+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/copyme/1.0.0/copyme-1.0.0.pom")
+ .then().statusCode(200);
+
+ String revision = given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"]}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=maven&namespace=com.example&package=copyme")
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0))
+ .extract().jsonPath().getString("successfulVersions.'1.0.0'.revision");
+ assertTrue(revision != null && !revision.isBlank());
+
+ byte[] copiedJar = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/maven/" + DOMAIN + "/other-repo/com/example/copyme/1.0.0/copyme-1.0.0.jar")
+ .then().statusCode(200)
+ .extract().asByteArray();
+ byte[] copiedPom = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/maven/" + DOMAIN + "/other-repo/com/example/copyme/1.0.0/copyme-1.0.0.pom")
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("copy-me-jar-bytes", new String(copiedJar, StandardCharsets.UTF_8));
+ assertEquals("copy-me-pom-bytes", new String(copiedPom, StandardCharsets.UTF_8));
+
+ String metadata = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/maven/" + DOMAIN + "/other-repo/com/example/copyme/maven-metadata.xml")
+ .then().statusCode(200)
+ .extract().asString();
+ assertTrue(metadata.contains("<version>1.0.0</version>"), metadata);
+ assertTrue(metadata.contains("<latest>1.0.0</latest>"), metadata);
+ assertTrue(metadata.contains("<release>1.0.0</release>"), metadata);
+ }
+
+ /**
+ * The real-world bug this closes: the destination already had {@code copyme-overwrite-1.0.0.jar}
+ * under the exact same name with different bytes, and Reposilite's own {@code
+ * redeployment: false} setting (confirmed live against this same container earlier in this
+ * class) rejects a plain PUT over it. Without deleting the old one first, this copy's PUT
+ * would come back {@code 409} even though {@code allowOverwrite} was set.
+ */
+ @Test
+ @Order(19)
+ void copyPackageVersionsOverwritesASameNamedAssetWithDifferentContentAtTheRealSidecar() {
+ byte[] oldJarBytes = "old-overwrite-jar-bytes".getBytes(StandardCharsets.UTF_8);
+ byte[] newJarBytes = "new-overwrite-jar-bytes".getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", "Bearer " + bearerToken).body(oldJarBytes)
+ .put("/codeartifact/maven/" + DOMAIN + "/other-repo/com/example/copyover/1.0.0/copyover-1.0.0.jar")
+ .then().statusCode(200);
+ given().header("Authorization", "Bearer " + bearerToken).body(newJarBytes)
+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/copyover/1.0.0/copyover-1.0.0.jar")
+ .then().statusCode(200);
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"],\"allowOverwrite\":true}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=maven&namespace=com.example&package=copyover")
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copied = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/maven/" + DOMAIN + "/other-repo/com/example/copyover/1.0.0/copyover-1.0.0.jar")
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("new-overwrite-jar-bytes", new String(copied, StandardCharsets.UTF_8));
+ }
+
/**
* A throwaway groupId/artifactId, not {@link #GAV}: deleting it exercises Reposilite's real
* directory delete (confirmed live before this was built: a single {@code DELETE} on the
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java
index ca85b37175..b2337c1658 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java
@@ -612,6 +612,138 @@ class CodeArtifactNpmDockerIntegrationTest {
.body("version", equalTo("1.0.0"));
}
+ /**
+ * The real-world gap this closes: {@code CopyPackageVersions} used to only support the
+ * generic and maven formats; npm keeps its published versions straight in Verdaccio's own
+ * packument rather than a {@code packageVersions} record. Confirms the bridge reads the
+ * tarball from the real sidecar (not a mock) and republishes it to the destination
+ * repository's own Verdaccio instance, byte for byte. {@code other-repo} is the empty
+ * repository {@link #repositoriesAreIsolatedFromEachOther} already created.
+ */
+ @Test
+ @Order(17)
+ void copyPackageVersionsBridgesToTheRealVerdaccioSidecar() {
+ String packageName = "copyme-npm-pkg";
+ byte[] tarball = "copy-me-npm-tarball-bytes".getBytes(StandardCharsets.UTF_8);
+ String envelope = "{\"name\":\"" + packageName + "\",\"versions\":{\"1.0.0\":{\"name\":\"" + packageName
+ + "\",\"version\":\"1.0.0\",\"readme\":\"# Copy Me Readme\",\"dist\":{\"tarball\":\"http://ignored/"
+ + packageName + "-1.0.0.tgz\"}}},\"_attachments\":{\"" + packageName + "-1.0.0.tgz\":{"
+ + "\"content_type\":\"application/octet-stream\",\"data\":\""
+ + Base64.getEncoder().encodeToString(tarball) + "\",\"length\":" + tarball.length + "}}}";
+ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json").body(envelope)
+ .put("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + packageName)
+ .then().statusCode(anyOf201Or200());
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"]}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=npm&package=" + packageName)
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copied = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/npm/" + DOMAIN + "/other-repo/" + packageName + "/-/" + packageName
+ + "-1.0.0.tgz")
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("copy-me-npm-tarball-bytes", new String(copied, StandardCharsets.UTF_8));
+
+ // The real-world gap this proves closed: Verdaccio's own packument never echoes a
+ // per-version readme back (see GetPackageVersionReadme's own javadoc), so this bridge has
+ // no way to read it from the destination sidecar after copying the tarball; it must be
+ // propagated from this service's own captured-at-publish-time record instead.
+ given().header("Authorization", AUTH)
+ .get("/v1/package/version/readme?domain=" + DOMAIN + "&repository=other-repo&format=npm&package="
+ + packageName + "&version=1.0.0")
+ .then().statusCode(200).body("readme", equalTo("# Copy Me Readme"));
+ }
+
+ /**
+ * The real-world bug this would otherwise hit: Verdaccio rejects a plain republish of an
+ * already-published version outright (a real {@code 409}, confirmed live), even after its
+ * packument entry alone is removed, since the tarball file itself is still on disk. Confirms
+ * the bridge's delete-then-republish sequence (packument entry, then the tarball file, both
+ * confirmed live) actually clears the way for the new content.
+ */
+ @Test
+ @Order(18)
+ void copyPackageVersionsOverwritesAnExistingNpmVersionWithDifferentContentAtTheRealSidecar() {
+ String packageName = "copyover-npm-pkg";
+ byte[] oldTarball = "old-overwrite-npm-tarball".getBytes(StandardCharsets.UTF_8);
+ byte[] newTarball = "new-overwrite-npm-tarball".getBytes(StandardCharsets.UTF_8);
+ String oldEnvelope = "{\"name\":\"" + packageName + "\",\"versions\":{\"1.0.0\":{\"name\":\"" + packageName
+ + "\",\"version\":\"1.0.0\",\"dist\":{\"tarball\":\"http://ignored/" + packageName
+ + "-1.0.0.tgz\"}}},\"_attachments\":{\"" + packageName + "-1.0.0.tgz\":{\"content_type\":"
+ + "\"application/octet-stream\",\"data\":\"" + Base64.getEncoder().encodeToString(oldTarball)
+ + "\",\"length\":" + oldTarball.length + "}}}";
+ String newEnvelope = oldEnvelope.replace(
+ Base64.getEncoder().encodeToString(oldTarball), Base64.getEncoder().encodeToString(newTarball))
+ .replace(String.valueOf(oldTarball.length), String.valueOf(newTarball.length));
+ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json").body(oldEnvelope)
+ .put("/codeartifact/npm/" + DOMAIN + "/other-repo/" + packageName)
+ .then().statusCode(anyOf201Or200());
+ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json").body(newEnvelope)
+ .put("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + packageName)
+ .then().statusCode(anyOf201Or200());
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"],\"allowOverwrite\":true}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=npm&package=" + packageName)
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copied = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/npm/" + DOMAIN + "/other-repo/" + packageName + "/-/" + packageName
+ + "-1.0.0.tgz")
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("new-overwrite-npm-tarball", new String(copied, StandardCharsets.UTF_8));
+ }
+
+ /**
+ * The real-world bug this would otherwise hit: the bridge used to build the copied version's
+ * packument entry from scratch (just {@code name}/{@code version}/{@code dist}), dropping
+ * {@code dependencies} and anything else the source's own version document carried. A real
+ * {@code npm install} against the copied destination would resolve zero dependencies for this
+ * version instead of what the project actually declares.
+ */
+ @Test
+ @Order(19)
+ void copyPackageVersionsPreservesTheSourceVersionsDependenciesAtTheRealSidecar() throws IOException {
+ String packageName = "copydeps-npm-pkg";
+ byte[] tarball = "copy-deps-npm-tarball-bytes".getBytes(StandardCharsets.UTF_8);
+ String envelope = "{\"name\":\"" + packageName + "\",\"versions\":{\"1.0.0\":{\"name\":\"" + packageName
+ + "\",\"version\":\"1.0.0\",\"dependencies\":{\"left-pad\":\"^1.3.0\"},\"dist\":{\"tarball\":"
+ + "\"http://ignored/" + packageName + "-1.0.0.tgz\"}}},\"_attachments\":{\"" + packageName
+ + "-1.0.0.tgz\":{\"content_type\":\"application/octet-stream\",\"data\":\""
+ + Base64.getEncoder().encodeToString(tarball) + "\",\"length\":" + tarball.length + "}}}";
+ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json").body(envelope)
+ .put("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + packageName)
+ .then().statusCode(anyOf201Or200());
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"]}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=npm&package=" + packageName)
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ String metadataBody = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/npm/" + DOMAIN + "/other-repo/" + packageName)
+ .then().statusCode(200)
+ .extract().asString();
+ JsonNode copiedVersion = new ObjectMapper().readTree(metadataBody).path("versions").path("1.0.0");
+ assertEquals("^1.3.0", copiedVersion.path("dependencies").path("left-pad").asText());
+ // dist must still point at the copy's own tarball, not the source's.
+ assertTrue(copiedVersion.path("dist").path("tarball").asText().contains("other-repo"),
+ "copied dist.tarball must point back at the destination repository, was: "
+ + copiedVersion.path("dist").path("tarball").asText());
+ }
+
/**
* Proves the actual mechanism, not just that {@code VerdaccioSidecarManager} has a method
* named right: {@code ContainerTeardowns.stopAll} runs every {@code ContainerTeardown} on
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNuGetDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNuGetDockerIntegrationTest.java
index e0a9635a4e..861971451a 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNuGetDockerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNuGetDockerIntegrationTest.java
@@ -12,6 +12,7 @@ import org.junit.jupiter.api.TestMethodOrder;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
+import java.util.Locale;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
@@ -343,6 +344,85 @@ class CodeArtifactNuGetDockerIntegrationTest {
.then().statusCode(201);
}
+ /**
+ * The real-world gap this closes: {@code CopyPackageVersions} used to support only generic
+ * and maven; nuget keeps its pushed packages straight on BaGetter's own flat storage rather
+ * than a {@code packageVersions} record. Confirms the bridge reads the {@code .nupkg} from
+ * the real sidecar (not a mock) and republishes it to the destination repository's own
+ * BaGetter instance, byte for byte. {@code other-nuget-repo} is the empty repository {@link
+ * #repositoriesAreIsolatedFromEachOther} already created.
+ */
+ @Test
+ @Order(13)
+ void copyPackageVersionsBridgesToTheRealBagetterSidecar() {
+ String packageId = "CopyMe.Package";
+ byte[] nupkg = buildNupkg(packageId, VERSION, "copy-me nuget package", null, null);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(pushBody("boundary123", nupkg))
+ .put("/codeartifact/nuget/" + DOMAIN + "/" + REPO + "/api/v2/package")
+ .then().statusCode(201);
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"" + VERSION + "\"]}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-nuget-repo&format=nuget&package=" + packageId)
+ .then().statusCode(200)
+ .body("successfulVersions.'" + VERSION + "'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copied = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/nuget/" + DOMAIN + "/other-nuget-repo/v3/package/"
+ + packageId.toLowerCase(Locale.ROOT) + "/" + VERSION + "/"
+ + packageId.toLowerCase(Locale.ROOT) + "." + VERSION + ".nupkg")
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertArrayEquals(nupkg, copied);
+ }
+
+ /**
+ * The real-world bug this would otherwise hit: BaGetter rejects a plain re-push of an
+ * already-pushed id/version outright (a real {@code 409}, confirmed live and already proven
+ * by {@code repushingTheSameCoordinatesWithDifferentContentIsRejectedAndTheOriginalSurvives}
+ * for the native push path), even for an id/version whose packument entry alone was removed,
+ * since BaGetter's storage is content-addressed by id/version. Confirms the bridge's own
+ * delete-then-republish ({@code DELETE /api/v2/package/<id>/<version>}, then push, both
+ * confirmed live) actually clears the way for different content.
+ */
+ @Test
+ @Order(14)
+ void copyPackageVersionsOverwritesAnExistingNuGetVersionWithDifferentContentAtTheRealSidecar() {
+ String packageId = "CopyOver.Package";
+ String lowerId = packageId.toLowerCase(Locale.ROOT);
+ byte[] oldNupkg = buildNupkg(packageId, VERSION, "old overwrite content", null, null);
+ byte[] newNupkg = buildNupkg(packageId, VERSION, "new overwrite content", null, null);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(pushBody("boundary123", oldNupkg))
+ .put("/codeartifact/nuget/" + DOMAIN + "/other-nuget-repo/api/v2/package")
+ .then().statusCode(201);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(pushBody("boundary123", newNupkg))
+ .put("/codeartifact/nuget/" + DOMAIN + "/" + REPO + "/api/v2/package")
+ .then().statusCode(201);
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"" + VERSION + "\"],\"allowOverwrite\":true}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-nuget-repo&format=nuget&package=" + packageId)
+ .then().statusCode(200)
+ .body("successfulVersions.'" + VERSION + "'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copied = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/nuget/" + DOMAIN + "/other-nuget-repo/v3/package/" + lowerId + "/" + VERSION
+ + "/" + lowerId + "." + VERSION + ".nupkg")
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertArrayEquals(newNupkg, copied);
+ }
+
private static long describeDomainAssetSizeBytes() {
return given().header("Authorization", AUTH)
.get("/v1/domain?domain=" + DOMAIN)
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java
index def19ff616..53bdc59458 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java
@@ -470,6 +470,151 @@ class CodeArtifactPypiDockerIntegrationTest {
.body("version", equalTo("1.0.0"));
}
+ /**
+ * The real-world gap this closes: {@code CopyPackageVersions} used to support only generic
+ * and maven; pypi keeps its uploaded files straight on pypiserver's own flat storage rather
+ * than a {@code packageVersions} record. Confirms the bridge reads the file from the real
+ * sidecar (not a mock) and republishes it to the destination repository's own pypiserver
+ * instance, byte for byte. {@code other-repo} is the empty repository {@link
+ * #repositoriesAreIsolatedFromEachOther} already created.
+ */
+ @Test
+ @Order(15)
+ void copyPackageVersionsBridgesToTheRealPypiserverSidecar() {
+ String packageName = "copyme-pypi-pkg";
+ String filename = "copyme_pypi_pkg-1.0.0.tar.gz";
+ byte[] content = "copy-me-pypi-sdist-bytes".getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(twineUploadBody("boundary123", packageName, filename, content, "Copy me description"))
+ .post("/codeartifact/pypi/" + DOMAIN + "/" + REPO + "/")
+ .then().statusCode(200);
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"]}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=pypi&package=" + packageName)
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copied = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/pypi/" + DOMAIN + "/other-repo/packages/" + filename)
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("copy-me-pypi-sdist-bytes", new String(copied, StandardCharsets.UTF_8));
+
+ // The real-world gap this proves closed: pypiserver parses only a distribution's
+ // filename, never its embedded description (see GetPackageVersionReadme's own javadoc),
+ // so this bridge has no way to read it from the destination sidecar after copying the
+ // file; it must be propagated from this service's own captured-at-upload-time record.
+ given().header("Authorization", AUTH)
+ .get("/v1/package/version/readme?domain=" + DOMAIN + "&repository=other-repo&format=pypi&package="
+ + packageName + "&version=1.0.0")
+ .then().statusCode(200).body("readme", equalTo("Copy me description"));
+ }
+
+ /**
+ * The real-world bug this would otherwise hit: pypiserver rejects a plain republish of an
+ * already-uploaded filename with a real {@code 409} (confirmed live, this container is
+ * started without pypiserver's own {@code --overwrite} flag, same as production), even though
+ * {@code reuploadingTheSameFileIsRejectedAndTheOriginalContentSurvives} already proves that
+ * for the native upload path; this confirms the bridge's own delete-then-republish ({@code
+ * remove_pkg}, then re-upload, both confirmed live) actually clears the way.
+ */
+ @Test
+ @Order(16)
+ void copyPackageVersionsOverwritesAnExistingPypiFileWithDifferentContentAtTheRealSidecar() {
+ String packageName = "copyover-pypi-pkg";
+ String filename = "copyover_pypi_pkg-1.0.0.tar.gz";
+ byte[] oldContent = "old-overwrite-pypi-sdist".getBytes(StandardCharsets.UTF_8);
+ byte[] newContent = "new-overwrite-pypi-sdist".getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(twineUploadBody("boundary123", packageName, filename, oldContent))
+ .post("/codeartifact/pypi/" + DOMAIN + "/other-repo/")
+ .then().statusCode(200);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(twineUploadBody("boundary123", packageName, filename, newContent))
+ .post("/codeartifact/pypi/" + DOMAIN + "/" + REPO + "/")
+ .then().statusCode(200);
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"],\"allowOverwrite\":true}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=pypi&package=" + packageName)
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copied = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/pypi/" + DOMAIN + "/other-repo/packages/" + filename)
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("new-overwrite-pypi-sdist", new String(copied, StandardCharsets.UTF_8));
+ }
+
+ /**
+ * The real-world bug this would otherwise hit: pypiserver's own {@code remove_pkg} management
+ * call (confirmed live) deletes every file sharing a release's exact name and version, not just
+ * the one filename it was asked to delete, so a copy that deletes-then-rewrites one asset at a
+ * time mid-loop would wipe a sibling asset of the same release already rewritten earlier in
+ * that same loop — losing it even though the copy as a whole reported success. A real pypi
+ * release commonly carries both an sdist and a wheel for the exact same version, so this is not
+ * a contrived edge case.
+ */
+ @Test
+ @Order(17)
+ void copyPackageVersionsOverwriteKeepsEveryAssetWhenAPypiReleaseHasBothAnSdistAndAWheel() {
+ String packageName = "copyover-multi-pypi-pkg";
+ String sdistFilename = "copyover_multi_pypi_pkg-1.0.0.tar.gz";
+ String wheelFilename = "copyover_multi_pypi_pkg-1.0.0-py3-none-any.whl";
+ byte[] oldSdist = "old-multi-pypi-sdist".getBytes(StandardCharsets.UTF_8);
+ byte[] newSdist = "new-multi-pypi-sdist".getBytes(StandardCharsets.UTF_8);
+ byte[] newWheel = "new-multi-pypi-wheel".getBytes(StandardCharsets.UTF_8);
+
+ // The destination already holds this version (just the sdist, enough to make this a real
+ // overwrite rather than a fresh publish) so the copy below has to delete-and-replace it.
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(twineUploadBody("boundary123", packageName, sdistFilename, oldSdist))
+ .post("/codeartifact/pypi/" + DOMAIN + "/other-repo/")
+ .then().statusCode(200);
+
+ // The source carries both files for this same release, exactly as a real `twine upload
+ // dist/*` would have left it.
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(twineUploadBody("boundary123", packageName, sdistFilename, newSdist))
+ .post("/codeartifact/pypi/" + DOMAIN + "/" + REPO + "/")
+ .then().statusCode(200);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(twineUploadBody("boundary123", packageName, wheelFilename, newWheel))
+ .post("/codeartifact/pypi/" + DOMAIN + "/" + REPO + "/")
+ .then().statusCode(200);
+
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{\"versions\":[\"1.0.0\"],\"allowOverwrite\":true}")
+ .post("/v1/package/versions/copy?domain=" + DOMAIN + "&source-repository=" + REPO
+ + "&destination-repository=other-repo&format=pypi&package=" + packageName)
+ .then().statusCode(200)
+ .body("successfulVersions.'1.0.0'.status", equalTo("Published"))
+ .body("failedVersions.size()", equalTo(0));
+
+ byte[] copiedSdist = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/pypi/" + DOMAIN + "/other-repo/packages/" + sdistFilename)
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("new-multi-pypi-sdist", new String(copiedSdist, StandardCharsets.UTF_8));
+ byte[] copiedWheel = given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/pypi/" + DOMAIN + "/other-repo/packages/" + wheelFilename)
+ .then().statusCode(200)
+ .extract().asByteArray();
+ assertEquals("new-multi-pypi-wheel", new String(copiedWheel, StandardCharsets.UTF_8));
+ }
+
/**
* Proves the actual mechanism, not just that {@code PypiserverSidecarManager} has a method
* named right: {@code ContainerTeardowns.stopAll} runs every {@code ContainerTeardown} on
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java
index 721af75d19..8258a6efcd 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java
@@ -18,6 +18,7 @@ import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactReposi
import io.github.hectorvent.floci.services.codeartifact.model.PackageOriginConfig;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.mockito.InOrder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
@@ -41,6 +42,7 @@ import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@@ -1429,8 +1431,8 @@ class CodeArtifactServiceTest {
assertEquals("my-artifact", pv.getPackageName());
assertEquals("1.0.0", pv.getVersion());
assertEquals("Published", pv.getStatus());
- assertEquals(Digests.sha256Hex((repoId + "/com.example/my-artifact/1.0.0").getBytes(StandardCharsets.UTF_8)),
- pv.getRevision());
+ assertEquals(Digests.sha256Hex((repoId + "/com.example/my-artifact/1.0.0").getBytes(StandardCharsets.UTF_8))
+ .substring(0, 50), pv.getRevision());
}
@Test
@@ -2174,16 +2176,462 @@ class CodeArtifactServiceTest {
}
@Test
- void copyPackageVersionsRejectsANonGenericFormat() {
+ void copyPackageVersionsRejectsAFormatThatIsNeitherGenericNorContainerBacked() {
service.createDomain(REGION, "dom", null, Map.of());
service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
AwsException e = assertThrows(AwsException.class, () -> service.copyPackageVersions(REGION, "dom", null,
- "src", "dst", "npm", null, "my-pkg", List.of("1.0.0"), null, false, false));
+ "src", "dst", "swift", null, "my-pkg", List.of("1.0.0"), null, false, false));
assertEquals("ValidationException", e.getErrorCode());
}
+ /**
+ * npm, pypi, and nuget are now bridged the same as maven (each sidecar's own real wire
+ * protocol, confirmed against a live container in the respective {@code
+ * CodeArtifact*DockerIntegrationTest} class); the shared orchestration this test file already
+ * exercises thoroughly against the maven mock (NOT_FOUND, MISMATCHED_REVISION, the
+ * identical-content no-op, ALREADY_EXISTS, overwrite, rollback, byte accounting) is format-
+ * agnostic, so it is not re-duplicated here per format. This just confirms the format gate
+ * itself routes a container-backed format to the bridge rather than rejecting it outright.
+ */
+ @Test
+ void copyPackageVersionsRoutesEveryContainerBackedFormatToTheSidecarBridge() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+
+ for (String format : List.of("npm", "pypi", "nuget")) {
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", format, null, "my-pkg", List.of("1.0.0"), null, false, false);
+ assertEquals("NOT_FOUND", result.failedVersions().get("1.0.0").errorCode());
+ }
+ }
+
+ /**
+ * The real-world gap this closes: {@code GetPackageVersionReadme} answers npm and pypi only
+ * from a record captured at publish time (see its own javadoc for why neither sidecar can
+ * answer for a specific version after the fact), which this bridge's own asset copy has no
+ * other way to reach. Without propagating it, a copied npm version's assets would land
+ * correctly while {@code GetPackageVersionReadme} 404s on it at the destination, even though
+ * the source genuinely has one.
+ */
+ @Test
+ void copyPackageVersionsPropagatesTheSourceVersionsCapturedReadmeForNpm() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("npm");
+ String dstRepoId = dst.getSidecarContainerIds().get("npm");
+ byte[] tarball = "tarball-bytes".getBytes(StandardCharsets.UTF_8);
+ when(verdaccioClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), isNull(), eq("my-pkg"),
+ eq("1.0.0"))).thenReturn(true);
+ when(verdaccioClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), isNull(), eq("my-pkg"),
+ eq("1.0.0"))).thenReturn(false);
+ when(verdaccioClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), isNull(),
+ eq("my-pkg"), eq("1.0.0"))).thenReturn(List.of("my-pkg-1.0.0.tgz"));
+ when(verdaccioClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), isNull(), eq("my-pkg"),
+ eq("1.0.0"), eq("my-pkg-1.0.0.tgz"))).thenReturn(Optional.of(tarball));
+ recordReadme("dom", "src", "npm", null, "my-pkg", "1.0.0", "# Real Readme");
+
+ service.copyPackageVersions(REGION, "dom", null, "src", "dst", "npm", null, "my-pkg", List.of("1.0.0"),
+ null, false, false);
+
+ CodeArtifactService.PackageVersionReadmeResult readme = service.getPackageVersionReadme(REGION, "dom",
+ null, "dst", "npm", null, "my-pkg", "1.0.0");
+ assertEquals("# Real Readme", readme.readme());
+ }
+
+ /** Same propagation as npm's own, confirmed separately since pypi captures readmes independently. */
+ @Test
+ void copyPackageVersionsPropagatesTheSourceVersionsCapturedReadmeForPypi() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("pypi");
+ String dstRepoId = dst.getSidecarContainerIds().get("pypi");
+ byte[] sdist = "sdist-bytes".getBytes(StandardCharsets.UTF_8);
+ when(pypiserverClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), isNull(), eq("my-pkg"),
+ eq("1.0.0"))).thenReturn(true);
+ when(pypiserverClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), isNull(), eq("my-pkg"),
+ eq("1.0.0"))).thenReturn(false);
+ when(pypiserverClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), isNull(),
+ eq("my-pkg"), eq("1.0.0"))).thenReturn(List.of("my_pkg-1.0.0.tar.gz"));
+ when(pypiserverClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), isNull(), eq("my-pkg"),
+ eq("1.0.0"), eq("my_pkg-1.0.0.tar.gz"))).thenReturn(Optional.of(sdist));
+ recordReadme("dom", "src", "pypi", null, "my-pkg", "1.0.0", "A pypi description");
+
+ service.copyPackageVersions(REGION, "dom", null, "src", "dst", "pypi", null, "my-pkg", List.of("1.0.0"),
+ null, false, false);
+
+ CodeArtifactService.PackageVersionReadmeResult readme = service.getPackageVersionReadme(REGION, "dom",
+ null, "dst", "pypi", null, "my-pkg", "1.0.0");
+ assertEquals("A pypi description", readme.readme());
+ }
+
+ @Test
+ void copyPackageVersionsBridgesToReposiliteForMavenCopyingEveryListedAsset() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] jarBytes = "jar-bytes".getBytes(StandardCharsets.UTF_8);
+ byte[] pomBytes = "pom-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(false);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar", "a-1.0.pom"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(jarBytes));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.pom"))).thenReturn(Optional.of(pomBytes));
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0"), null, false, false);
+
+ assertTrue(result.failedVersions().isEmpty());
+ assertEquals("Published", result.successfulVersions().get("1.0").status());
+ assertFalse(result.successfulVersions().get("1.0").revision().isBlank());
+ verify(reposiliteClient).copyPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq(dstRepoId),
+ eq("dst"), eq("com.example"), eq("a"), eq("1.0"), eq("a-1.0.jar"), eq(jarBytes));
+ verify(reposiliteClient).copyPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq(dstRepoId),
+ eq("dst"), eq("com.example"), eq("a"), eq("1.0"), eq("a-1.0.pom"), eq(pomBytes));
+ verify(reposiliteClient, never()).deletePackageVersionAsset(any(), any(), any(), any(), any(), any(),
+ any());
+ }
+
+ @Test
+ void copyPackageVersionsFailsNotFoundForAMavenVersionMissingFromTheSource() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0"), null, false, false);
+
+ assertEquals("NOT_FOUND", result.failedVersions().get("1.0").errorCode());
+ assertTrue(result.successfulVersions().isEmpty());
+ }
+
+ @Test
+ void copyPackageVersionsSkipsAMavenVersionThatWouldHaveSucceededWhenASiblingIsNotFound() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("2.0"))).thenReturn(false);
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0", "2.0"), null, false, false);
+
+ assertTrue(result.successfulVersions().isEmpty());
+ assertEquals("SKIPPED", result.failedVersions().get("1.0").errorCode());
+ assertEquals("NOT_FOUND", result.failedVersions().get("2.0").errorCode());
+ verify(reposiliteClient, never()).copyPackageVersionAsset(any(), any(), any(), any(), any(), any(), any(),
+ any(), any(), any());
+ }
+
+ @Test
+ void copyPackageVersionsTreatsAByteIdenticalMavenVersionAsANoOpNotListedEitherWay() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] jarBytes = "jar-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.listPackageVersionAssetNames(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(jarBytes));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(jarBytes.clone()));
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0"), null, false, false);
+
+ assertTrue(result.successfulVersions().isEmpty());
+ assertTrue(result.failedVersions().isEmpty());
+ verify(reposiliteClient, never()).copyPackageVersionAsset(any(), any(), any(), any(), any(), any(), any(),
+ any(), any(), any());
+ }
+
+ @Test
+ void copyPackageVersionsFailsAlreadyExistsForADifferentMavenVersionWithoutAllowOverwrite() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.listPackageVersionAssetNames(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar")))
+ .thenReturn(Optional.of("source-bytes".getBytes(StandardCharsets.UTF_8)));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar")))
+ .thenReturn(Optional.of("different-bytes".getBytes(StandardCharsets.UTF_8)));
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0"), null, false, false);
+
+ assertEquals("ALREADY_EXISTS", result.failedVersions().get("1.0").errorCode());
+ }
+
+ @Test
+ void copyPackageVersionsOverwritesADifferentMavenVersionAndRemovesAStaleAssetWhenAllowOverwriteIsTrue() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] newJarBytes = "new-jar-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.listPackageVersionAssetNames(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar", "stale-readme.txt"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(newJarBytes));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar")))
+ .thenReturn(Optional.of("old-jar-bytes".getBytes(StandardCharsets.UTF_8)));
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0"), null, true, false);
+
+ assertTrue(result.failedVersions().isEmpty());
+ assertEquals("Published", result.successfulVersions().get("1.0").status());
+ // a-1.0.jar already exists at the destination with different content: Reposilite's own
+ // redeployment:false setting would reject a plain PUT over it (confirmed against a live
+ // container), so the old one must be deleted immediately before the new one is stored,
+ // never written straight over the existing path.
+ InOrder order = inOrder(reposiliteClient);
+ order.verify(reposiliteClient).deletePackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"),
+ eq("com.example"), eq("a"), eq("1.0"), eq("a-1.0.jar"));
+ order.verify(reposiliteClient).copyPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq(dstRepoId),
+ eq("dst"), eq("com.example"), eq("a"), eq("1.0"), eq("a-1.0.jar"), eq(newJarBytes));
+ verify(reposiliteClient).deletePackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("stale-readme.txt"));
+ }
+
+ /**
+ * A later asset in the same version failing to write must not leave an earlier, otherwise
+ * successful asset of that same version sitting in a brand-new, half-copied state at the
+ * destination: the jar never existed there before this call, so the best-effort rollback
+ * deletes it outright rather than attempting to restore nonexistent prior content. The
+ * original {@code IllegalStateException} from the sidecar propagates unchanged, not masked
+ * by a rollback-time error.
+ */
+ @Test
+ void copyPackageVersionsForMavenRollsBackANewlyWrittenAssetWhenALaterAssetInTheSameVersionFailsToWrite() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] jarBytes = "jar-bytes".getBytes(StandardCharsets.UTF_8);
+ byte[] pomBytes = "pom-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(false);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar", "a-1.0.pom"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(jarBytes));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.pom"))).thenReturn(Optional.of(pomBytes));
+ doThrow(new IllegalStateException("sidecar unreachable")).when(reposiliteClient).copyPackageVersionAsset(
+ eq(srcRepoId), eq("dom"), eq("src"), eq(dstRepoId), eq("dst"), eq("com.example"), eq("a"), eq("1.0"),
+ eq("a-1.0.pom"), eq(pomBytes));
+
+ assertThrows(IllegalStateException.class, () -> service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0"), null, false, false));
+
+ verify(reposiliteClient).copyPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq(dstRepoId),
+ eq("dst"), eq("com.example"), eq("a"), eq("1.0"), eq("a-1.0.jar"), eq(jarBytes));
+ verify(reposiliteClient).deletePackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"));
+ }
+
+ /**
+ * An overwritten asset that already existed at the destination must come back as it was, not
+ * get deleted outright, when a later asset in the same version fails: rollback distinguishes
+ * "newly created, so delete it" from "previously existed, so restore it" per asset.
+ */
+ @Test
+ void copyPackageVersionsForMavenRestoresAnOverwrittenAssetsOriginalContentWhenALaterAssetFailsToWrite() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] newJarBytes = "new-jar-bytes".getBytes(StandardCharsets.UTF_8);
+ byte[] oldJarBytes = "old-jar-bytes".getBytes(StandardCharsets.UTF_8);
+ byte[] newPomBytes = "new-pom-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar", "a-1.0.pom"));
+ when(reposiliteClient.listPackageVersionAssetNames(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(newJarBytes));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.pom"))).thenReturn(Optional.of(newPomBytes));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(oldJarBytes));
+ doThrow(new IllegalStateException("sidecar unreachable")).when(reposiliteClient).copyPackageVersionAsset(
+ eq(srcRepoId), eq("dom"), eq("src"), eq(dstRepoId), eq("dst"), eq("com.example"), eq("a"), eq("1.0"),
+ eq("a-1.0.pom"), eq(newPomBytes));
+
+ assertThrows(IllegalStateException.class, () -> service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", List.of("1.0"), null, true, false));
+
+ verify(reposiliteClient).storePackageVersionAsset(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"), eq(oldJarBytes));
+ }
+
+ @Test
+ void copyPackageVersionsForMavenRecordsTheNewVersionInTheDestinationsArtifactMetadata() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] jarBytes = "jar-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(false);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(jarBytes));
+
+ service.copyPackageVersions(REGION, "dom", null, "src", "dst", "maven", "com.example", "a",
+ List.of("1.0"), null, false, false);
+
+ verify(reposiliteClient).recordVersionAvailable(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"));
+ }
+
+ @Test
+ void copyPackageVersionsForMavenIncreasesDescribeDomainsAssetSizeBytesByWhatWasCopied() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] jarBytes = "jar-bytes".getBytes(StandardCharsets.UTF_8);
+ byte[] pomBytes = "pom-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(false);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar", "a-1.0.pom"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(jarBytes));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.pom"))).thenReturn(Optional.of(pomBytes));
+
+ long before = service.describeDomain(REGION, "dom", null).assetSizeBytes();
+ service.copyPackageVersions(REGION, "dom", null, "src", "dst", "maven", "com.example", "a",
+ List.of("1.0"), null, false, false);
+ long after = service.describeDomain(REGION, "dom", null).assetSizeBytes();
+
+ assertEquals(before + jarBytes.length + pomBytes.length, after);
+ }
+
+ @Test
+ void copyPackageVersionsFailsMismatchedRevisionForMavenWhenTheVersionRevisionsEntryDoesNotMatch() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", null, Map.of("1.0", "wrong-revision"), false, false);
+
+ assertEquals("MISMATCHED_REVISION", result.failedVersions().get("1.0").errorCode());
+ }
+
+ @Test
+ void copyPackageVersionsFailsMismatchedRevisionForMavenOnAShapeValidButWrongValue() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", null, Map.of("1.0", "a-shape-valid-revision"), false,
+ false);
+
+ assertEquals("MISMATCHED_REVISION", result.failedVersions().get("1.0").errorCode());
+ }
+
+ /**
+ * {@link CodeArtifactService#synthesizeContainerBackedRevision} is truncated to 50 hex
+ * characters specifically so a revision a caller obtained from {@code DescribePackageVersion}
+ * can be handed straight back into {@code versionRevisions} and actually match: confirms a
+ * real round trip through both APIs, not just that the two happen to be the same length.
+ */
+ @Test
+ void copyPackageVersionsSucceedsForMavenWhenTheVersionRevisionsEntryIsTheOneDescribePackageVersionReturned() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository src = service.createRepository(REGION, "dom", null, "src", null, null, Map.of());
+ CodeArtifactRepository dst = service.createRepository(REGION, "dom", null, "dst", null, null, Map.of());
+ String srcRepoId = src.getSidecarContainerIds().get("maven");
+ String dstRepoId = dst.getSidecarContainerIds().get("maven");
+ byte[] jarBytes = "jar-bytes".getBytes(StandardCharsets.UTF_8);
+ when(reposiliteClient.packageVersionExists(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(true);
+ when(reposiliteClient.packageVersionExists(eq(dstRepoId), eq("dom"), eq("dst"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(false);
+ when(reposiliteClient.listPackageVersionAssetNames(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"))).thenReturn(List.of("a-1.0.jar"));
+ when(reposiliteClient.fetchPackageVersionAsset(eq(srcRepoId), eq("dom"), eq("src"), eq("com.example"),
+ eq("a"), eq("1.0"), eq("a-1.0.jar"))).thenReturn(Optional.of(jarBytes));
+
+ String describedRevision = service.describePackageVersion(REGION, "dom", null, "src", "maven",
+ "com.example", "a", "1.0").getRevision();
+ assertTrue(describedRevision.length() <= 50);
+
+ CodeArtifactService.CopyPackageVersionsResult result = service.copyPackageVersions(REGION, "dom", null,
+ "src", "dst", "maven", "com.example", "a", null, Map.of("1.0", describedRevision), false, false);
+
+ assertTrue(result.failedVersions().isEmpty());
+ assertEquals("Published", result.successfulVersions().get("1.0").status());
+ }
+
@Test
void copyPackageVersionsFailsNotFoundForAVersionMissingFromTheSourceRepository() {
service.createDomain(REGION, "dom", null, Map.of());
@@ -2536,8 +2984,8 @@ class CodeArtifactServiceTest {
"com.example", "my-artifact", "1.0.0", "my-artifact-1.0.0.jar", null);
assertEquals("jar bytes", new String(result.asset().getContent(), StandardCharsets.UTF_8));
- assertEquals(Digests.sha256Hex((repoId + "/com.example/my-artifact/1.0.0").getBytes(StandardCharsets.UTF_8)),
- result.packageVersionRevision());
+ assertEquals(Digests.sha256Hex((repoId + "/com.example/my-artifact/1.0.0").getBytes(StandardCharsets.UTF_8))
+ .substring(0, 50), result.packageVersionRevision());
}
@Test
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.java
index 47e5f595ad..c091d7a92a 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
@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
+import io.github.hectorvent.floci.core.common.XmlParser;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -27,6 +28,7 @@ import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -605,6 +607,165 @@ class ReposiliteSidecarClientTest {
"com.example", "weird"));
}
+ @Test
+ void listPackageVersionAssetNamesReturnsOnlyTheFileEntriesFromTheVersionDirectory() {
+ server.createContext("/api/maven/details/dom--repo/com/example/a/1.0",
+ exchange -> respond(exchange, 200, "{\"name\":\"1.0\",\"type\":\"DIRECTORY\",\"files\":["
+ + "{\"name\":\"a-1.0.jar\",\"type\":\"FILE\"},"
+ + "{\"name\":\"a-1.0.pom\",\"type\":\"FILE\"}]}"));
+
+ List<String> names = client.listPackageVersionAssetNames("dom--repo", "dom", "repo", "com.example", "a",
+ "1.0");
+
+ assertThat(names, equalTo(List.of("a-1.0.jar", "a-1.0.pom")));
+ }
+
+ @Test
+ void listPackageVersionAssetNamesIsEmptyForAMissingVersion() {
+ server.createContext("/api/maven/details/dom--repo/com/example/a/9.9",
+ exchange -> respond(exchange, 404, "{\"status\":404,\"message\":\"File not found\"}"));
+
+ assertThat(client.listPackageVersionAssetNames("dom--repo", "dom", "repo", "com.example", "a", "9.9"),
+ equalTo(List.of()));
+ }
+
+ @Test
+ void listPackageVersionAssetNamesThrowsOnAnUnexpectedStatus() {
+ server.createContext("/api/maven/details/dom--repo/com/example/a/1.0",
+ exchange -> respond(exchange, 500, "{\"status\":500,\"message\":\"internal error\"}"));
+
+ assertThrows(IllegalStateException.class,
+ () -> client.listPackageVersionAssetNames("dom--repo", "dom", "repo", "com.example", "a", "1.0"));
+ }
+
+ @Test
+ void storePackageVersionAssetPutsTheBytesDirectlyEvenWhenDifferingContentAlreadyExists() throws Exception {
+ // deployArtifact's own redeployment:false preflight would refuse this; storePackageVersionAsset
+ // never GETs first and must PUT unconditionally, the way CopyPackageVersions' own
+ // delete-then-store overwrite sequence relies on.
+ settingsBody.set("{\"repositories\":[{\"id\":\"dom--repo\",\"visibility\":\"PUBLIC\",\"redeployment\":false}]}");
+ server.createContext("/api/settings/domain/maven", exchange -> respond(exchange, 200, settingsBody.get()));
+ List<String> methodsSeen = new CopyOnWriteArrayList<>();
+ AtomicReference<byte[]> putBody = new AtomicReference<>();
+ server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> {
+ methodsSeen.add(exchange.getRequestMethod());
+ putBody.set(exchange.getRequestBody().readAllBytes());
+ respond(exchange, 200, "");
+ });
+
+ client.storePackageVersionAsset("dom--repo", "dom", "repo", "com.example", "a", "1.0", "a-1.0.jar",
+ "hello".getBytes(StandardCharsets.UTF_8));
+
+ assertThat(methodsSeen, equalTo(List.of("PUT")));
+ assertArrayEquals("hello".getBytes(StandardCharsets.UTF_8), putBody.get());
+ }
+
+ @Test
+ void storePackageVersionAssetThrowsOnAnUnexpectedStatus() {
+ settingsBody.set("{\"repositories\":[{\"id\":\"dom--repo\",\"visibility\":\"PUBLIC\",\"redeployment\":false}]}");
+ server.createContext("/api/settings/domain/maven", exchange -> respond(exchange, 200, settingsBody.get()));
+ server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> respond(exchange, 500, ""));
+
+ assertThrows(IllegalStateException.class, () -> client.storePackageVersionAsset("dom--repo", "dom", "repo",
+ "com.example", "a", "1.0", "a-1.0.jar", "hello".getBytes(StandardCharsets.UTF_8)));
+ }
+
+ @Test
+ void deletePackageVersionAssetDeletesTheExactGavPath() {
+ AtomicReference<String> deletedMethod = new AtomicReference<>();
+ server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> {
+ deletedMethod.set(exchange.getRequestMethod());
+ respond(exchange, 200, "");
+ });
+
+ client.deletePackageVersionAsset("dom--repo", "dom", "repo", "com.example", "a", "1.0", "a-1.0.jar");
+
+ assertThat(deletedMethod.get(), equalTo("DELETE"));
+ }
+
+ @Test
+ void deletePackageVersionAssetThrowsOnAnUnexpectedStatus() {
+ server.createContext("/dom--repo/com/example/a/1.0/a-1.0.jar", exchange -> respond(exchange, 500, ""));
+
+ assertThrows(IllegalStateException.class, () -> client.deletePackageVersionAsset("dom--repo", "dom", "repo",
+ "com.example", "a", "1.0", "a-1.0.jar"));
+ }
+
+ @Test
+ void recordVersionAvailableCreatesANewMetadataFileWhenNoneExists() {
+ settingsBody.set("{\"repositories\":[{\"id\":\"dom--repo\",\"visibility\":\"PUBLIC\",\"redeployment\":false}]}");
+ server.createContext("/api/settings/domain/maven", exchange -> respond(exchange, 200, settingsBody.get()));
+ AtomicReference<byte[]> putBody = new AtomicReference<>();
+ server.createContext("/dom--repo/com/example/a/maven-metadata.xml", exchange -> {
+ if ("GET".equals(exchange.getRequestMethod())) {
+ respond(exchange, 404, "");
+ } else {
+ putBody.set(exchange.getRequestBody().readAllBytes());
+ respond(exchange, 200, "");
+ }
+ });
+
+ client.recordVersionAvailable("dom--repo", "dom", "repo", "com.example", "a", "1.0");
+
+ String xml = new String(putBody.get(), StandardCharsets.UTF_8);
+ assertEquals("com.example", XmlParser.extractFirst(xml, "groupId", null));
+ assertEquals("a", XmlParser.extractFirst(xml, "artifactId", null));
+ assertEquals("1.0", XmlParser.extractFirst(xml, "latest", null));
+ assertEquals("1.0", XmlParser.extractFirst(xml, "release", null));
+ assertEquals(List.of("1.0"), XmlParser.extractAll(xml, "version"));
+ assertTrue(XmlParser.extractFirst(xml, "lastUpdated", "").matches("\\d{14}"));
+ }
+
+ @Test
+ void recordVersionAvailableAppendsToExistingVersionsAndAdvancesReleaseForANonSnapshot() {
+ settingsBody.set("{\"repositories\":[{\"id\":\"dom--repo\",\"visibility\":\"PUBLIC\",\"redeployment\":false}]}");
+ server.createContext("/api/settings/domain/maven", exchange -> respond(exchange, 200, settingsBody.get()));
+ String existing = "<metadata><groupId>com.example</groupId><artifactId>a</artifactId><versioning>"
+ + "<latest>1.0</latest><release>1.0</release><versions><version>1.0</version></versions>"
+ + "<lastUpdated>20260101000000</lastUpdated></versioning></metadata>";
+ AtomicReference<byte[]> putBody = new AtomicReference<>();
+ server.createContext("/dom--repo/com/example/a/maven-metadata.xml", exchange -> {
+ if ("GET".equals(exchange.getRequestMethod())) {
+ respond(exchange, 200, existing);
+ } else {
+ putBody.set(exchange.getRequestBody().readAllBytes());
+ respond(exchange, 200, "");
+ }
+ });
+
+ client.recordVersionAvailable("dom--repo", "dom", "repo", "com.example", "a", "2.0");
+
+ String xml = new String(putBody.get(), StandardCharsets.UTF_8);
+ assertEquals(List.of("1.0", "2.0"), XmlParser.extractAll(xml, "version"));
+ assertEquals("2.0", XmlParser.extractFirst(xml, "latest", null));
+ assertEquals("2.0", XmlParser.extractFirst(xml, "release", null));
+ }
+
+ @Test
+ void recordVersionAvailableLeavesTheExistingReleaseUntouchedForASnapshotVersion() {
+ settingsBody.set("{\"repositories\":[{\"id\":\"dom--repo\",\"visibility\":\"PUBLIC\",\"redeployment\":false}]}");
+ server.createContext("/api/settings/domain/maven", exchange -> respond(exchange, 200, settingsBody.get()));
+ String existing = "<metadata><groupId>com.example</groupId><artifactId>a</artifactId><versioning>"
+ + "<latest>1.0</latest><release>1.0</release><versions><version>1.0</version></versions>"
+ + "<lastUpdated>20260101000000</lastUpdated></versioning></metadata>";
+ AtomicReference<byte[]> putBody = new AtomicReference<>();
+ server.createContext("/dom--repo/com/example/a/maven-metadata.xml", exchange -> {
+ if ("GET".equals(exchange.getRequestMethod())) {
+ respond(exchange, 200, existing);
+ } else {
+ putBody.set(exchange.getRequestBody().readAllBytes());
+ respond(exchange, 200, "");
+ }
+ });
+
+ client.recordVersionAvailable("dom--repo", "dom", "repo", "com.example", "a", "2.0-SNAPSHOT");
+
+ String xml = new String(putBody.get(), StandardCharsets.UTF_8);
+ assertEquals(List.of("1.0", "2.0-SNAPSHOT"), XmlParser.extractAll(xml, "version"));
+ assertEquals("2.0-SNAPSHOT", XmlParser.extractFirst(xml, "latest", null));
+ assertEquals("1.0", XmlParser.extractFirst(xml, "release", null));
+ }
+
private static void respond(HttpExchange exchange, int status, String body) throws IOException {
byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
exchange.sendResponseHeaders(status, bytes.length);