Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(codeartifact): add DeletePackage for all package formats (#5320)

Priamo Germosenceab47e78593
diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.md
index a0f0bebf72..80d0e05cf6 100644
--- a/docs/services/codeartifact.md
+++ b/docs/services/codeartifact.md
@@ -39,6 +39,7 @@ the remaining formats (NuGet, etc.) have no real proxy behind them yet.
| `DisassociateExternalConnection` | Removes a repository's external connection. |
| `PublishPackageVersion` | Uploads a generic-format asset, creating or extending a package version; requires `x-amz-content-sha256` and verifies it against the real hash of the bytes received. |
| `DescribePackage` | Returns a package's format, namespace, name, and origin controls (`publish` and `upstream` restrictions). |
+| `DeletePackage` | Deletes a package and every one of its versions; `ResourceNotFoundException` for one that does not exist. |
| `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. |
| `TagResource` | Adds or updates tags on a domain or repository ARN. |
diff --git a/docs/services/index.md b/docs/services/index.md
index ee17d17718..8a409d704b 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -121,7 +121,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac
| [AWS Backup](backup.md) | `/backup-vaults/*`, `/backup/plans/*`, `/backup-jobs/*`, `/supported-resource-types` | REST JSON | 20 |
| [AWS FIS](fis.md) | `/experimentTemplates/*`, `/experiments/*`, `/actions/*`, `/targetResourceTypes/*`, `/safetyLevers/*`, `/tags/*` | REST JSON | 26 |
| [CodeGuru Reviewer](codegurureviewer.md) | `/associations`, `/associations/{associationArn}`, `/tags/*` | REST JSON | 7 |
-| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package`, `/v1/package/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*`, `/codeartifact/npm/*`, `/codeartifact/pypi/*` | REST JSON | 27 |
+| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package`, `/v1/package/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*`, `/codeartifact/npm/*`, `/codeartifact/pypi/*` | REST JSON | 28 |
| [CloudFront](cloudfront.md) | `/2020-05-31/distribution/*`, `/2020-05-31/cache-policy/*`, `/2020-05-31/function/*` | REST XML | 50 |
| [Route53](route53.md) | `/2013-04-01/hostedzone/*`, `/2013-04-01/healthcheck/*`, `/2013-04-01/change/*` | REST XML | 27 |
| [Route 53 Resolver](route53resolver.md) | `POST /` + `X-Amz-Target: Route53Resolver.*` | JSON 1.1 | 18 |
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java
index 116bc34c45..9ea8b5d5c5 100644
--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java
@@ -342,6 +342,20 @@ public class CodeArtifactController {
return ok(single("package", packageDescription(described)));
}
+ @DELETE
+ @Path("/v1/package")
+ public Response deletePackage(@Context HttpHeaders headers, @QueryParam("domain") String domain,
+ @QueryParam("domain-owner") String domainOwner,
+ @QueryParam("repository") String repository,
+ @QueryParam("format") String format,
+ @QueryParam("namespace") String namespace,
+ @QueryParam("package") String packageName) {
+ String region = regionResolver.resolveRegion(headers);
+ CodeArtifactService.PackageDescription deleted = service.deletePackage(region, domain, domainOwner,
+ repository, format, namespace, packageName);
+ return ok(single("deletedPackage", deletedPackageDescription(deleted)));
+ }
+
@GET
@Path("/v1/package/version")
public Response describePackageVersion(@Context HttpHeaders headers, @QueryParam("domain") String domain,
@@ -511,6 +525,25 @@ public class CodeArtifactController {
return node;
}
+ /**
+ * {@code PackageSummary}, real AWS's response type for {@code deletedPackage}, names the
+ * package's name field {@code package}, not {@code name}: a different field name than
+ * {@code PackageDescription} uses for the same data in {@code DescribePackage}'s response,
+ * confirmed against the API reference.
+ */
+ private ObjectNode deletedPackageDescription(CodeArtifactService.PackageDescription described) {
+ ObjectNode node = objectMapper.createObjectNode();
+ node.put("format", described.format());
+ if (described.namespace() != null) {
+ node.put("namespace", described.namespace());
+ }
+ node.put("package", described.packageName());
+ ObjectNode restrictions = node.putObject("originConfiguration").putObject("restrictions");
+ restrictions.put("publish", described.publishRestriction());
+ restrictions.put("upstream", described.upstreamRestriction());
+ return node;
+ }
+
private ObjectNode packageVersionDescription(CodeArtifactPackageVersion pv) {
ObjectNode node = objectMapper.createObjectNode();
node.put("format", pv.getFormat());
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 4791418cc3..2c8d9549fc 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
@@ -712,12 +712,121 @@ public class CodeArtifactService implements Resettable {
private boolean genericPackageExists(String region, String domain, String owner, String repository,
String format, String namespace, String packageName) {
+ return !genericPackageVersions(region, domain, owner, repository, format, namespace, packageName).isEmpty();
+ }
+
+ private List<CodeArtifactPackageVersion> genericPackageVersions(String region, String domain, String owner,
+ String repository, String format, String namespace, String packageName) {
String prefix = packageVersionKey(region, domain, repository, format, namespace, packageName, "");
String wantedNamespace = namespace == null ? "" : namespace;
return packageVersions.scanForAccount(owner, key -> key.startsWith(prefix)).stream()
- .anyMatch(pv -> format.equals(pv.getFormat())
+ .filter(pv -> format.equals(pv.getFormat())
&& packageName.equals(pv.getPackageName())
- && wantedNamespace.equals(pv.getNamespace() == null ? "" : pv.getNamespace()));
+ && wantedNamespace.equals(pv.getNamespace() == null ? "" : pv.getNamespace()))
+ .toList();
+ }
+
+ /**
+ * Deletes a package and every one of its versions. A deleted package cannot be restored,
+ * matching the real API's own documented behavior. Existence is checked where the package
+ * actually lives, the same way {@link #describePackage} checks it, so a nonexistent package
+ * answers {@code ResourceNotFoundException} rather than silently succeeding.
+ *
+ * <p>{@code synchronized} for the same reason {@link #publishPackageVersion} is: without a
+ * shared lock, a publish and a delete racing the same generic package could interleave (a
+ * version restored after its asset bytes are already gone, or a version published mid-scan
+ * silently surviving or being dropped).
+ */
+ public synchronized PackageDescription deletePackage(String region, String domain, String domainOwner,
+ String repository, String format, String namespace, String packageName) {
+ if (format == null || !PACKAGE_FORMATS.contains(format)) {
+ throw validation("format must be one of " + PACKAGE_FORMATS + ".");
+ }
+ validatePackageToken("package", packageName);
+ if (namespace != null) {
+ validatePackageToken("namespace", namespace);
+ }
+ // Same boundary as describePackage's own namespace rules (see its comment there for the
+ // API reference citation): a missing generic/maven namespace would delete under a
+ // null-namespace key nothing real ever publishes to, and a supplied pypi namespace would
+ // be silently ignored by the sidecar's existence check rather than rejected.
+ if (("maven".equals(format) || "generic".equals(format)) && (namespace == null || namespace.isBlank())) {
+ throw validation("namespace is required when deleting a " + format + " package.");
+ }
+ if ("pypi".equals(format) && namespace != null) {
+ throw validation("pypi packages do not have a namespace.");
+ }
+ requireNonBlank(domain, "domain");
+ requireNonBlank(repository, "repository");
+ String owner = effectiveOwner(domainOwner);
+ requireRepository(owner, repositoryKey(region, domain, repository), repository);
+ if (CONTAINER_BACKED_FORMATS.contains(format)) {
+ deleteContainerBackedPackage(region, domain, owner, repository, format, namespace, packageName);
+ } else {
+ List<CodeArtifactPackageVersion> versions = genericPackageVersions(region, domain, owner, repository,
+ format, namespace, packageName);
+ if (versions.isEmpty()) {
+ throw notFound("Package '" + packageName + "' was not found.", packageName, "package");
+ }
+ for (CodeArtifactPackageVersion pv : versions) {
+ String versionKey = packageVersionKey(region, domain, repository, format, namespace, packageName,
+ pv.getVersion());
+ // Metadata goes first: once the version record is gone, no caller can reach a
+ // deleted asset's bytes through it regardless of whether the cleanup below
+ // succeeds. Deleting bytes first and metadata last, if a later asset in the same
+ // version failed to delete, would leave a surviving record pointing at bytes
+ // already gone.
+ packageVersions.deleteForAccount(owner, versionKey);
+ for (PackageAsset asset : pv.getAssets().values()) {
+ try {
+ deleteAssetContent(owner, versionKey, asset.getName());
+ } catch (UncheckedIOException e) {
+ LOG.warnv(e, "Could not delete CodeArtifact asset file for {0}/{1}: {2}", versionKey,
+ asset.getName(), e.getMessage());
+ }
+ }
+ }
+ }
+ return new PackageDescription(format, namespace, packageName, "ALLOW", "BLOCK");
+ }
+
+ /**
+ * Each sidecar's delete capability differs enough that there is no honest shared implementation:
+ * Verdaccio and Reposilite remove a whole package in one call, while pypiserver's own management
+ * endpoint only deletes one exact name/version pair per call, so {@code PypiserverSidecarClient}
+ * lists every file first and removes each one in turn; all three are confirmed against live
+ * containers. {@link RepositorySidecarManager#deletePackage}'s default still throws
+ * {@link UnsupportedOperationException} for a sidecar that genuinely cannot do this, rather than
+ * silently leaving the package in place or claiming a success it cannot back up; that becomes a
+ * real, if deliberately blunt, AWS error here instead of an unhandled 500.
+ */
+ private void deleteContainerBackedPackage(String region, String domain, String owner, String repository,
+ String format, String namespace, String packageName) {
+ String repoId = ensureFormatContainerId(format, region, domain, owner, repository);
+ RepositorySidecarManager manager = sidecarRegistry.forFormat(format)
+ .orElseThrow(() -> notFound("Package '" + packageName + "' was not found.", packageName, "package"));
+ if (!manager.packageExists(repoId, domain, repository, namespace, packageName)) {
+ throw notFound("Package '" + packageName + "' was not found.", packageName, "package");
+ }
+ try {
+ manager.deletePackage(repoId, domain, repository, namespace, packageName);
+ } catch (UnsupportedOperationException e) {
+ throw new AwsException("InternalServerException",
+ "Deleting a " + format + " package is not yet supported by this emulator.", 500);
+ }
+ }
+
+ private void deleteAssetContent(String owner, String packageVersionKey, String assetName) {
+ if (inMemory) {
+ memoryAssetStore.remove(assetStoreKey(owner, packageVersionKey, assetName));
+ return;
+ }
+ Path filePath = resolveAssetPath(owner, packageVersionKey, assetName);
+ try {
+ Files.deleteIfExists(filePath);
+ } catch (IOException e) {
+ throw new UncheckedIOException("Failed to delete CodeArtifact asset file: " + filePath, e);
+ }
}
public PackageVersionAssetResult getPackageVersionAsset(String region, String domain, String domainOwner,
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 ab2ea7359c..5307300dbb 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
@@ -1,17 +1,25 @@
package io.github.hectorvent.floci.services.codeartifact;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.net.URI;
+import java.net.URLEncoder;
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;
import java.time.Duration;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
+import java.util.Map;
import java.util.Optional;
+import java.util.Set;
import java.util.regex.Pattern;
/**
@@ -25,15 +33,17 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {
private static final Pattern SIMPLE_INDEX_HREF = Pattern.compile("href=\"([^\"]*)\"");
private final PypiserverSidecarManager manager;
+ private final ObjectMapper mapper;
private final HttpClient httpClient;
@Inject
- public PypiserverSidecarClient(PypiserverSidecarManager manager) {
- this(manager, HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build());
+ public PypiserverSidecarClient(PypiserverSidecarManager manager, ObjectMapper mapper) {
+ this(manager, mapper, HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build());
}
- PypiserverSidecarClient(PypiserverSidecarManager manager, HttpClient httpClient) {
+ PypiserverSidecarClient(PypiserverSidecarManager manager, ObjectMapper mapper, HttpClient httpClient) {
this.manager = manager;
+ this.mapper = mapper;
this.httpClient = httpClient;
}
@@ -112,6 +122,111 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {
return simpleIndex(baseUrl, packageName).isPresent();
}
+ /**
+ * Removes a whole package, every version at once, confirmed against a live container: the pinned
+ * image's management endpoint ({@code POST /} with {@code :action=remove_pkg}) deletes one exact
+ * {@code name}/{@code version} pair per call rather than a whole package or project at once, so
+ * every file is first listed from the same PyPI JSON API endpoint this image also serves
+ * ({@code GET /<project>/json}, grouped by the same normalized project the simple index uses),
+ * then each one removed in turn.
+ *
+ * <p>{@code name} for each call is recovered from the filename that endpoint listed, not from the
+ * caller's {@code packageName}: {@code remove_pkg} matches against the literal, unnormalized name
+ * the server itself derived when that file was uploaded, and an sdist and a wheel of the very same
+ * release can legitimately differ there (a hyphen in one, an underscore in the other), so deleting
+ * by one filename's recovered name alone can silently leave the other file behind.
+ */
+ @Override
+ public void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,
+ String packageName) {
+ String baseUrl = ensureReady(repositoryContainerId, null);
+ for (PkgNameVersion file : packageFiles(baseUrl, packageName)) {
+ removeVersion(baseUrl, file.name(), file.version());
+ }
+ }
+
+ private record PkgNameVersion(String name, String version) {}
+
+ private Set<PkgNameVersion> packageFiles(String baseUrl, String packageName) {
+ 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 Set.of();
+ }
+ if (response.statusCode() != 200) {
+ throw new IllegalStateException("Could not list versions of " + packageName + " on the pypiserver "
+ + "sidecar: upstream returned " + response.statusCode());
+ }
+ JsonNode releases;
+ try {
+ releases = mapper.readTree(response.body()).path("releases");
+ } catch (Exception e) {
+ throw new IllegalStateException("Could not parse pypiserver's version listing for " + packageName, e);
+ }
+ Set<PkgNameVersion> files = new LinkedHashSet<>();
+ for (Map.Entry<String, JsonNode> release : releases.properties()) {
+ String version = release.getKey();
+ for (JsonNode file : release.getValue()) {
+ String url = file.path("url").asText("");
+ String filename = url.substring(url.lastIndexOf('/') + 1);
+ files.add(new PkgNameVersion(rawPkgname(filename, version), version));
+ }
+ }
+ return files;
+ }
+
+ /**
+ * The exact, unnormalized name pypiserver's own {@code remove_pkg} needs for {@code filename}, at
+ * known version {@code version}: the text of {@code filename} up to (but not including) the
+ * {@code -<version>} marker that {@link #versionBoundaryEndsAt} confirms really ends the version
+ * field there, the same boundary {@link #filenameEmbedsVersion} already relies on. Falls back to
+ * the whole filename in the (not expected in practice) case nothing satisfies that boundary: a
+ * harmless no-op for {@code remove_pkg}, since no file was ever uploaded under that literal name.
+ */
+ private static String rawPkgname(String filename, String version) {
+ String marker = "-" + version;
+ for (int idx = filename.indexOf(marker); idx >= 0; idx = filename.indexOf(marker, idx + 1)) {
+ if (versionBoundaryEndsAt(filename, idx + marker.length())) {
+ return filename.substring(0, idx);
+ }
+ }
+ return filename;
+ }
+
+ private void removeVersion(String baseUrl, String pkgname, String version) {
+ String body = "%3Aaction=remove_pkg"
+ + "&name=" + URLEncoder.encode(pkgname, StandardCharsets.UTF_8)
+ + "&version=" + URLEncoder.encode(version, StandardCharsets.UTF_8);
+ HttpRequest request = HttpRequest.newBuilder(URI.create(baseUrl))
+ .timeout(Duration.ofSeconds(10))
+ .header("Content-Type", "application/x-www-form-urlencoded")
+ .POST(BodyPublishers.ofString(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 delete " + pkgname + " "
+ + version, e);
+ }
+ // 404 means remove_pkg found nothing for this exact name/version: already removed by an
+ // earlier call in this same loop for a sibling file that happened to share it, not a real
+ // failure.
+ if (response.statusCode() != 200 && response.statusCode() != 404) {
+ throw new IllegalStateException("Could not delete " + pkgname + " " + version + " from the "
+ + "pypiserver sidecar: upstream returned " + response.statusCode());
+ }
+ }
+
private Optional<String> simpleIndex(String baseUrl, String packageName) {
String normalized = normalizePackageName(packageName);
URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/simple/" + SidecarUriUtils.encodeSegment(normalized)
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 d2c0172a9a..18f4e8ffde 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
@@ -131,12 +131,8 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
public boolean packageExists(String repositoryContainerId, String domain, String repository, String namespace,
String packageName) {
String baseUrl = manager.ensureReady();
- StringBuilder path = new StringBuilder("/").append(SidecarUriUtils.encodeSegment(repositoryContainerId));
- for (String namespacePart : namespace.split("\\.", -1)) {
- path.append('/').append(SidecarUriUtils.encodeSegment(namespacePart));
- }
- path.append('/').append(SidecarUriUtils.encodeSegment(packageName)).append('/');
- HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl), path.toString()))
+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl),
+ packageDirectoryPath(repositoryContainerId, namespace, packageName)))
.timeout(Duration.ofSeconds(30))
.header("Authorization", manager.basicAuthHeader())
.GET()
@@ -152,6 +148,39 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
return true;
}
+ /**
+ * Removes a whole package, every version at once: a single {@code DELETE} on the group/artifact
+ * directory. Confirmed against a live Reposilite container: it recursively removes everything
+ * beneath that path in one call. {@link #packageExists} is checked by the caller first, since
+ * Reposilite answers a confusing HTTP 500 for a {@code DELETE} on a path that was never there,
+ * not a 404.
+ */
+ @Override
+ public void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,
+ String packageName) {
+ String baseUrl = manager.ensureReady();
+ HttpRequest request = HttpRequest.newBuilder(SidecarUriUtils.combine(URI.create(baseUrl),
+ packageDirectoryPath(repositoryContainerId, namespace, packageName)))
+ .timeout(Duration.ofSeconds(30))
+ .header("Authorization", manager.basicAuthHeader())
+ .DELETE()
+ .build();
+ HttpResponse<Void> response = send(request, BodyHandlers.discarding());
+ if (response.statusCode() != 200) {
+ throw new IllegalStateException("Could not delete " + packageName
+ + " from the Reposilite sidecar: upstream returned " + response.statusCode());
+ }
+ }
+
+ private static String packageDirectoryPath(String repositoryContainerId, String namespace, String packageName) {
+ StringBuilder path = new StringBuilder("/").append(SidecarUriUtils.encodeSegment(repositoryContainerId));
+ for (String namespacePart : namespace.split("\\.", -1)) {
+ path.append('/').append(SidecarUriUtils.encodeSegment(namespacePart));
+ }
+ path.append('/').append(SidecarUriUtils.encodeSegment(packageName)).append('/');
+ return path.toString();
+ }
+
/** 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 293a2f37a7..4d5f38ae6c 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
@@ -64,4 +64,16 @@ public interface RepositorySidecarManager {
*/
boolean packageExists(String repositoryContainerId, String domain, String repository, String namespace,
String packageName);
+
+ /**
+ * Deletes every version of the named package from this sidecar's own backing storage. Every
+ * sidecar Floci currently backs (Reposilite, Verdaccio, pypiserver) can do this; the default
+ * throws {@link UnsupportedOperationException} rather than silently leaving the package in place
+ * or claiming a success it cannot back up, for a future format whose sidecar genuinely cannot. An
+ * implementation that can delete overrides this.
+ */
+ default void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,
+ String packageName) {
+ throw new UnsupportedOperationException(format() + " packages cannot be deleted through this sidecar");
+ }
}
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 859c1095dd..8c4139f27a 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
@@ -100,6 +100,36 @@ public class VerdaccioSidecarClient implements RepositorySidecarManager {
return fetchPackageDocument(baseUrl, namespace, packageName).isPresent();
}
+ /**
+ * Removes a whole package, every version at once, the same way the real npm CLI's final
+ * unpublish step does: fetch the packument for its current {@code _rev}, then {@code DELETE} the
+ * package path with that revision appended as {@code /-rev/<rev>}. Confirmed against a live
+ * Verdaccio container: a bare {@code DELETE} with no revision is not a route at all (404
+ * "Cannot DELETE"), and the revisioned form removes every version and tarball in one call.
+ */
+ @Override
+ public void deletePackage(String repositoryContainerId, String domain, String repository, String namespace,
+ String packageName) {
+ String baseUrl = ensureReady(repositoryContainerId, publicUrl(domain, repository));
+ String revision = fetchPackageDocument(baseUrl, namespace, packageName)
+ .orElseThrow(() -> new IllegalStateException(packageName + " no longer exists on the Verdaccio "
+ + "sidecar"))
+ .path("_rev").asText("");
+ URI uri = SidecarUriUtils.combine(URI.create(baseUrl), "/" + packagePath(namespace, packageName)
+ + "/-rev/" + SidecarUriUtils.encodeSegment(revision));
+ 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 Verdaccio sidecar to delete " + packageName, e);
+ }
+ if (response.statusCode() != 200 && response.statusCode() != 201) {
+ throw new IllegalStateException("Could not delete " + packageName
+ + " from the Verdaccio sidecar: upstream returned " + response.statusCode());
+ }
+ }
+
/** One tarball by its filename, from a backend already made ready by {@link #ensureReady}. */
public Optional<byte[]> fetchTarball(String baseUrl, String namespace, String packageName, String assetName) {
HttpRequest request = tarballRequest(baseUrl, namespace, packageName, assetName);
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java
index 92f1e8b141..d2d473b060 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java
@@ -17,11 +17,14 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.IOException;
+import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.AccessDeniedException;
+import java.nio.file.DirectoryNotEmptyException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.Map;
@@ -355,6 +358,63 @@ class CodeArtifactAssetPersistenceTest {
assertEquals("a.txt", e.getExtendedData().get("resourceId"));
}
+ /**
+ * {@code deletePackage} removes a version's metadata record before it attempts to clean up
+ * that version's asset bytes, specifically so a cleanup failure on one asset never leaves the
+ * record in place pointing at bytes that may now be missing. A {@link DirectoryNotEmptyException}
+ * forced on one asset's path stands in for the failure here, since it is deterministic and
+ * platform-independent (unlike a permission trick, which a root-run CI container would ignore).
+ * The other asset in the same version must still get cleaned up, and the failure must be logged
+ * rather than silently swallowed, the same way {@code republishingWithMatchingContentRepairsAnUnreadableBackingFileAndLogsAWarning}
+ * above asserts on the real log record rather than trusting that the behavior exists.
+ */
+ @Test
+ void deletingAnAssetsBytesFailingStillRemovesTheVersionRecordAndCleansUpTheOtherAsset(@TempDir Path dir)
+ throws IOException {
+ CodeArtifactService service = newService(dir);
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());
+ byte[] contentA = "content of a".getBytes(StandardCharsets.UTF_8);
+ byte[] contentB = "content of b".getBytes(StandardCharsets.UTF_8);
+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt",
+ sha256Hex(contentA), "true", contentA);
+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "b.txt",
+ sha256Hex(contentB), "true", contentB);
+
+ Path assetFileA;
+ Path assetFileB;
+ try (Stream<Path> paths = Files.walk(dir.resolve("codeartifact-assets"))) {
+ List<Path> files = paths.filter(Files::isRegularFile).toList();
+ assetFileA = files.stream().filter(p -> matchesContent(p, contentA)).findFirst().orElseThrow();
+ assetFileB = files.stream().filter(p -> matchesContent(p, contentB)).findFirst().orElseThrow();
+ }
+ Files.delete(assetFileB);
+ Files.createDirectory(assetFileB);
+ Files.createFile(assetFileB.resolve("not-empty"));
+
+ List<LogRecord> records = LogCapture.capture(CodeArtifactService.class, () ->
+ service.deletePackage(REGION, "dom", null, "repo", "generic", "ns", "my-pkg"));
+
+ assertTrue(records.stream().anyMatch(r -> r.getMessage() != null
+ && r.getMessage().contains("Could not delete CodeArtifact asset file")
+ && r.getThrown() instanceof UncheckedIOException
+ && r.getThrown().getCause() instanceof DirectoryNotEmptyException),
+ "expected a warning logging the failed asset cleanup, got: " + records);
+ assertFalse(Files.exists(assetFileA), "the other asset's bytes must still be cleaned up");
+
+ AwsException gone = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION, "dom",
+ null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt", null));
+ assertEquals("ResourceNotFoundException", gone.getErrorCode());
+ }
+
+ private static boolean matchesContent(Path file, byte[] expected) {
+ try {
+ return Arrays.equals(Files.readAllBytes(file), expected);
+ } catch (IOException e) {
+ return false;
+ }
+ }
+
@Test
void distinctAssetNamesNeverCollideOnDisk(@TempDir Path dir) {
CodeArtifactService service = newService(dir);
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java
index c5ee800a99..d6e72f1867 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java
@@ -211,6 +211,45 @@ class CodeArtifactIntegrationTest {
.then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));
}
+ @Test
+ void deletePackageUsesThePackageFieldNameAndRemovesEveryVersion() {
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{}").post("/v1/domain?domain=delete-domain").then().statusCode(200);
+ given().contentType("application/json").header("Authorization", AUTH)
+ .body("{}").post("/v1/repository?domain=delete-domain&repository=repo").then().statusCode(200);
+ byte[] content = "delete-me".getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", AUTH).header("x-amz-content-sha256", sha256Hex(content))
+ .contentType("application/octet-stream").body(content)
+ .post("/v1/package/version/publish?domain=delete-domain&repository=repo&format=generic"
+ + "&namespace=ns&package=my-pkg&version=1.0.0&asset=a.txt")
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .delete("/v1/package?domain=delete-domain&repository=repo&format=generic&namespace=ns"
+ + "&package=my-pkg")
+ .then().statusCode(200)
+ .body("deletedPackage.format", equalTo("generic"))
+ .body("deletedPackage.namespace", equalTo("ns"))
+ .body("deletedPackage.package", equalTo("my-pkg"))
+ .body("deletedPackage.originConfiguration.restrictions.publish", equalTo("ALLOW"))
+ .body("deletedPackage.originConfiguration.restrictions.upstream", equalTo("BLOCK"));
+
+ given().header("Authorization", AUTH)
+ .get("/v1/package?domain=delete-domain&repository=repo&format=generic&namespace=ns"
+ + "&package=my-pkg")
+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));
+
+ given().header("Authorization", AUTH)
+ .get("/v1/package/version/asset?domain=delete-domain&repository=repo&format=generic&namespace=ns"
+ + "&package=my-pkg&version=1.0.0&asset=a.txt")
+ .then().statusCode(404);
+
+ given().header("Authorization", AUTH)
+ .delete("/v1/package?domain=delete-domain&repository=repo&format=generic&namespace=ns"
+ + "&package=my-pkg")
+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));
+ }
+
@Test
void unfinishedPublishKeepsVersionOpenForMoreAssets() {
given().contentType("application/json").header("Authorization", AUTH)
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 1741a4a189..26db2d46c2 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
@@ -409,6 +409,35 @@ class CodeArtifactMavenDockerIntegrationTest {
.then().statusCode(404);
}
+ /**
+ * 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
+ * group/artifact path removes everything beneath it), and must not disturb the artifact every
+ * other test in this class shares.
+ */
+ @Test
+ @Order(13)
+ void deletePackageRemovesTheWholeReposiliteArtifactDirectory() {
+ byte[] content = "delete-me-bytes".getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", "Bearer " + bearerToken).body(content)
+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/deleteme/1.0.0/deleteme-1.0.0.jar")
+ .then().statusCode(200);
+
+ given().header("Authorization", AUTH)
+ .delete("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=maven"
+ + "&namespace=com.example&package=deleteme")
+ .then().statusCode(200).body("deletedPackage.package", equalTo("deleteme"));
+
+ given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/deleteme/1.0.0/deleteme-1.0.0.jar")
+ .then().statusCode(404);
+
+ given().header("Authorization", AUTH)
+ .get("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=maven"
+ + "&namespace=com.example&package=deleteme")
+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));
+ }
+
/**
* Reads the real Reposilite instance's own {@code maven} settings domain directly (the same
* shared container {@link ReposiliteSidecarManager} started for every test in this class).
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 1a2924b13f..615df40cc9 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
@@ -339,6 +339,40 @@ class CodeArtifactNpmDockerIntegrationTest {
.then().statusCode(404);
}
+ /**
+ * A throwaway package, not {@link #PACKAGE_NAME}: deleting it exercises the real Verdaccio
+ * unpublish-whole-package mechanism (GET the packument's own {@code _rev}, then {@code DELETE}
+ * with that revision), confirmed live before this was built, and must not disturb the package
+ * every other test in this class shares.
+ */
+ @Test
+ @Order(11)
+ void deletePackageRemovesTheWholeVerdaccioPackage() {
+ String packageName = "delete-me-pkg";
+ byte[] tarball = "throwaway tarball".getBytes(StandardCharsets.UTF_8);
+ String envelope = "{\"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(tarball) + "\",\"length\":" + tarball.length + "}}}";
+
+ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json").body(envelope)
+ .put("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + packageName)
+ .then().statusCode(anyOf201Or200());
+
+ given().header("Authorization", AUTH)
+ .delete("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=npm&package=" + packageName)
+ .then().statusCode(200).body("deletedPackage.package", equalTo(packageName));
+
+ given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + packageName)
+ .then().statusCode(404);
+
+ given().header("Authorization", AUTH)
+ .get("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=npm&package=" + packageName)
+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));
+ }
+
/**
* 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/CodeArtifactPypiDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java
index 90a5b2c390..6c34820347 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
@@ -356,6 +356,36 @@ class CodeArtifactPypiDockerIntegrationTest {
.then().statusCode(404);
}
+ /**
+ * pypiserver has no single whole-package delete route the way Verdaccio and Reposilite do, but
+ * its own management endpoint ({@code POST /} with {@code :action=remove_pkg}) does delete a
+ * named version for real, confirmed live: {@code DeletePackage} lists every version through
+ * that same container and removes each one, so this asserts the real removal rather than a
+ * refusal, and that the file this class's earlier tests uploaded is genuinely gone afterward.
+ */
+ @Test
+ @Order(13)
+ void deletePackageRemovesTheFileFromTheRealPypiserverSidecar() {
+ given().header("Authorization", AUTH)
+ .delete("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=pypi&package="
+ + PACKAGE_NAME)
+ .then().statusCode(200).body("deletedPackage.package", equalTo(PACKAGE_NAME));
+
+ given().header("Authorization", "Bearer " + bearerToken)
+ .get("/codeartifact/pypi/" + DOMAIN + "/" + REPO + "/simple/" + PACKAGE_NAME + "/")
+ .then().statusCode(404);
+
+ given().header("Authorization", AUTH)
+ .get("/v1/package/version/asset?domain=" + DOMAIN + "&repository=" + REPO + "&format=pypi"
+ + "&package=" + PACKAGE_NAME + "&version=1.0.0&asset=" + FILENAME)
+ .then().statusCode(404);
+
+ given().header("Authorization", AUTH)
+ .get("/v1/package?domain=" + DOMAIN + "&repository=" + REPO + "&format=pypi&package="
+ + PACKAGE_NAME)
+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));
+ }
+
/**
* 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 db4ed3ad6d..5ddc798bcb 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
@@ -1104,6 +1104,144 @@ class CodeArtifactServiceTest {
assertEquals("ValidationException", e.getErrorCode());
}
+ @Test
+ void deletePackageRemovesEveryVersionAndAssetButLeavesOtherPackagesAlone() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());
+ byte[] content = "x".getBytes(StandardCharsets.UTF_8);
+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt",
+ sha256Hex(content), "false", content);
+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "2.0.0", "a.txt",
+ sha256Hex(content), "false", content);
+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "other-pkg", "1.0.0", "a.txt",
+ sha256Hex(content), "false", content);
+
+ CodeArtifactService.PackageDescription deleted = service.deletePackage(REGION, "dom", null, "repo",
+ "generic", "ns", "my-pkg");
+ assertEquals("generic", deleted.format());
+ assertEquals("ns", deleted.namespace());
+ assertEquals("my-pkg", deleted.packageName());
+
+ AwsException goneAsPackage = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom",
+ null, "repo", "generic", "ns", "my-pkg"));
+ assertEquals("ResourceNotFoundException", goneAsPackage.getErrorCode());
+ AwsException goneVersionOne = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION,
+ "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt", null));
+ assertEquals("ResourceNotFoundException", goneVersionOne.getErrorCode());
+ AwsException goneVersionTwo = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION,
+ "dom", null, "repo", "generic", "ns", "my-pkg", "2.0.0", "a.txt", null));
+ assertEquals("ResourceNotFoundException", goneVersionTwo.getErrorCode());
+
+ CodeArtifactService.PackageDescription stillThere = service.describePackage(REGION, "dom", null, "repo",
+ "generic", "ns", "other-pkg");
+ assertEquals("other-pkg", stillThere.packageName());
+
+ AwsException alreadyDeleted = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom",
+ null, "repo", "generic", "ns", "my-pkg"));
+ assertEquals("ResourceNotFoundException", alreadyDeleted.getErrorCode());
+
+ AwsException unknown = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null,
+ "repo", "generic", "ns", "no-such-package"));
+ assertEquals("ResourceNotFoundException", unknown.getErrorCode());
+ }
+
+ @Test
+ void deletePackageBridgesToReposiliteForMavenAfterConfirmingItExists() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ CodeArtifactRepository created =
+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());
+ String repoId = created.getSidecarContainerIds().get("maven");
+ when(reposiliteClient.packageExists(eq(repoId), eq("dom"), eq("repo"), eq("com.example"),
+ eq("my-artifact"))).thenReturn(true);
+
+ CodeArtifactService.PackageDescription deleted = service.deletePackage(REGION, "dom", null, "repo", "maven",
+ "com.example", "my-artifact");
+
+ assertEquals("maven", deleted.format());
+ verify(reposiliteClient).deletePackage(repoId, "dom", "repo", "com.example", "my-artifact");
+ }
+
+ @Test
+ void deletePackageReportsNotFoundForAContainerBackedPackageThatDoesNotExistRatherThanDeletingAnything() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());
+ when(verdaccioClient.packageExists(anyString(), eq("dom"), eq("repo"), isNull(), eq("my-pkg")))
+ .thenReturn(false);
+
+ AwsException e = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null, "repo",
+ "npm", null, "my-pkg"));
+ assertEquals("ResourceNotFoundException", e.getErrorCode());
+ verify(verdaccioClient, never()).deletePackage(any(), any(), any(), any(), any());
+ }
+
+ /**
+ * {@link RepositorySidecarManager#deletePackage}'s default throws
+ * {@link UnsupportedOperationException} for a sidecar that genuinely cannot delete (every sidecar
+ * Floci actually backs can, but the service must still handle one that can't, present or future);
+ * this stubs that default's own throw straight onto the mock to exercise it without needing a
+ * real sidecar that refuses. The service must not let it propagate as an unhandled 500: it
+ * becomes a real, if deliberately blunt, documented AWS error instead.
+ */
+ @Test
+ void deletePackageTranslatesAnUnsupportedSidecarDeleteIntoAnInternalServerException() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());
+ when(pypiserverClient.packageExists(anyString(), eq("dom"), eq("repo"), isNull(), eq("my-pkg")))
+ .thenReturn(true);
+ doThrow(new UnsupportedOperationException("pypi packages cannot be deleted through this sidecar"))
+ .when(pypiserverClient).deletePackage(anyString(), eq("dom"), eq("repo"), isNull(), eq("my-pkg"));
+
+ AwsException e = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null, "repo",
+ "pypi", null, "my-pkg"));
+ assertEquals("InternalServerException", e.getErrorCode());
+ }
+
+ /**
+ * Mirrors describePackage's own boundary-validation test: deletePackage must reject the same
+ * malformed coordinates before touching repository state, not just the single maven-namespace
+ * check it had before this test existed.
+ */
+ @Test
+ void deletePackageValidatesPackageAndNamespaceShapeBeforeTouchingRepositoryState() {
+ AwsException badPackageName = assertThrows(AwsException.class, () -> service.deletePackage(REGION,
+ "no-such-domain", null, "repo", "generic", "ns", "has/slash"));
+ assertEquals("ValidationException", badPackageName.getErrorCode());
+
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());
+
+ AwsException badNamespace = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom",
+ null, "repo", "generic", "has#hash", "my-pkg"));
+ assertEquals("ValidationException", badNamespace.getErrorCode());
+
+ AwsException missingNamespaceForGeneric = assertThrows(AwsException.class, () -> service.deletePackage(
+ REGION, "dom", null, "repo", "generic", null, "my-pkg"));
+ assertEquals("ValidationException", missingNamespaceForGeneric.getErrorCode());
+
+ AwsException missingNamespaceForMaven = assertThrows(AwsException.class, () -> service.deletePackage(
+ REGION, "dom", null, "repo", "maven", null, "my-artifact"));
+ assertEquals("ValidationException", missingNamespaceForMaven.getErrorCode());
+ }
+
+ /**
+ * pypi packages have no namespace at all (same API-reference fact describePackage's own test
+ * documents). Without this rejection, a caller-supplied namespace would be silently ignored by
+ * the sidecar's existence check below and the real package would be deleted anyway, as if the
+ * namespace the caller specified had actually been honored.
+ */
+ @Test
+ void deletePackageRejectsANamespaceSuppliedForPypiRatherThanDeletingTheRealPackageAnyway() {
+ service.createDomain(REGION, "dom", null, Map.of());
+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());
+ when(pypiserverClient.packageExists(anyString(), eq("dom"), eq("repo"), isNull(), eq("real-pkg")))
+ .thenReturn(true);
+
+ AwsException e = assertThrows(AwsException.class, () -> service.deletePackage(REGION, "dom", null, "repo",
+ "pypi", "bogus-namespace", "real-pkg"));
+ assertEquals("ValidationException", e.getErrorCode());
+ verify(pypiserverClient, never()).deletePackage(any(), any(), any(), any(), any());
+ }
+
@Test
void getPackageVersionAssetReturnsExactBytesAndValidatesRevision() {
service.createDomain(REGION, "dom", null, Map.of());
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.java
index 69cfa66527..2fef9e662b 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClientTest.java
@@ -1,5 +1,6 @@
package io.github.hectorvent.floci.services.codeartifact;
+import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.net.httpserver.HttpServer;
import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;
@@ -13,8 +14,11 @@ import java.lang.reflect.Field;
import java.net.InetSocketAddress;
import java.net.http.HttpClient;
import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicReference;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -374,6 +378,128 @@ class PypiserverSidecarClientTest {
assertEquals("/simple/a%2F-%2Fb/", observedRawPath.get());
}
+ /**
+ * Confirmed live: pypiserver's own management endpoint ({@code POST /} with
+ * {@code :action=remove_pkg}) only deletes one exact name/version pair per call, matched
+ * against the literal, unnormalized name it derived from the uploaded filename, not the PEP 503
+ * normalized form the simple index uses. An sdist and a wheel of the very same release can
+ * legitimately differ there ({@code demo-pkg} versus {@code demo_pkg}), so this proves
+ * {@code deletePackage} recovers each file's own name from the JSON listing and removes both,
+ * rather than deleting by one shared name and silently leaving the other file behind.
+ */
+ @Test
+ void deletePackageRemovesEveryFileUnderItsOwnRecoveredNameNotOneSharedName() throws Exception {
+ PypiserverSidecarManager manager = manager();
+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);
+ respondWithJsonReleases("demo-pkg",
+ Map.of("1.0.0", List.of("demo-pkg-1.0.0.tar.gz", "demo_pkg-1.0.0-py3-none-any.whl")));
+ List<String> removeBodies = new CopyOnWriteArrayList<>();
+ backend.createContext("/", exchange -> {
+ removeBodies.add(new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8));
+ exchange.sendResponseHeaders(200, -1);
+ exchange.close();
+ });
+
+ client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg");
+
+ assertEquals(2, removeBodies.size());
+ assertTrue(removeBodies.stream().anyMatch(b -> b.contains("name=demo-pkg") && b.contains("version=1.0.0")),
+ "expected a remove_pkg call for the sdist's own name: " + removeBodies);
+ assertTrue(removeBodies.stream().anyMatch(b -> b.contains("name=demo_pkg") && b.contains("version=1.0.0")),
+ "expected a remove_pkg call for the wheel's own name: " + removeBodies);
+ }
+
+ /**
+ * A 404 from {@code remove_pkg} means it matched nothing for that exact name/version, which
+ * happens for real when an earlier call in the same {@code deletePackage} loop already removed
+ * every file sharing it; {@code deletePackage} must treat that as already done, not a failure.
+ */
+ @Test
+ void deletePackageToleratesANotFoundResponseFromRemovePkgAsAlreadyRemoved() throws Exception {
+ PypiserverSidecarManager manager = manager();
+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);
+ respondWithJsonReleases("demo-pkg", Map.of("1.0.0", List.of("demo-pkg-1.0.0.tar.gz")));
+ backend.createContext("/", exchange -> {
+ exchange.sendResponseHeaders(404, -1);
+ exchange.close();
+ });
+
+ client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg");
+ }
+
+ /** A package with no releases at all deletes nothing and does not fail. */
+ @Test
+ void deletePackageIsANoOpForAPackageThatWasNeverUploaded() throws Exception {
+ PypiserverSidecarManager manager = manager();
+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);
+ backend.createContext("/demo-pkg/json", exchange -> {
+ exchange.sendResponseHeaders(404, -1);
+ exchange.close();
+ });
+ backend.createContext("/", exchange -> {
+ exchange.sendResponseHeaders(500, -1);
+ exchange.close();
+ });
+
+ client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg");
+ }
+
+ @Test
+ void deletePackageThrowsRatherThanReportingNotFoundWhenListingVersionsFails() throws Exception {
+ PypiserverSidecarManager manager = manager();
+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);
+ backend.createContext("/demo-pkg/json", exchange -> {
+ exchange.sendResponseHeaders(500, -1);
+ exchange.close();
+ });
+
+ assertThrows(IllegalStateException.class,
+ () -> client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg"));
+ }
+
+ @Test
+ void deletePackageThrowsRatherThanReportingNotFoundOnARemovePkgServerError() throws Exception {
+ PypiserverSidecarManager manager = manager();
+ seedPooledContainer(manager, "pypi-repo-1", "tracked-pypiserver-1", backendUrl);
+ respondWithJsonReleases("demo-pkg", Map.of("1.0.0", List.of("demo-pkg-1.0.0.tar.gz")));
+ backend.createContext("/", exchange -> {
+ exchange.sendResponseHeaders(500, -1);
+ exchange.close();
+ });
+
+ assertThrows(IllegalStateException.class,
+ () -> client(manager).deletePackage("pypi-repo-1", "dom", "repo", null, "demo-pkg"));
+ }
+
+ private void respondWithJsonReleases(String packageName, Map<String, List<String>> releases) {
+ StringBuilder json = new StringBuilder("{\"info\":{\"version\":\"\"},\"releases\":{");
+ boolean firstVersion = true;
+ for (Map.Entry<String, List<String>> release : releases.entrySet()) {
+ if (!firstVersion) {
+ json.append(',');
+ }
+ firstVersion = false;
+ json.append('"').append(release.getKey()).append("\":[");
+ boolean firstFile = true;
+ for (String filename : release.getValue()) {
+ if (!firstFile) {
+ json.append(',');
+ }
+ firstFile = false;
+ json.append("{\"url\":\"/packages/").append(filename).append("\"}");
+ }
+ json.append(']');
+ }
+ json.append("}}");
+ byte[] bytes = json.toString().getBytes(StandardCharsets.UTF_8);
+ backend.createContext("/" + packageName + "/json", exchange -> {
+ exchange.getResponseHeaders().set("Content-Type", "application/json");
+ exchange.sendResponseHeaders(200, bytes.length);
+ exchange.getResponseBody().write(bytes);
+ exchange.close();
+ });
+ }
+
private void respondWithSimpleIndex(String packageName, String filename) {
String html = "<a href=\"/packages/" + filename + "\">" + filename + "</a>";
backend.createContext("/simple/" + packageName + "/", exchange -> {
@@ -390,7 +516,7 @@ class PypiserverSidecarClientTest {
}
private PypiserverSidecarClient client(PypiserverSidecarManager manager) {
- return new PypiserverSidecarClient(manager, HttpClient.newHttpClient());
+ return new PypiserverSidecarClient(manager, new ObjectMapper(), HttpClient.newHttpClient());
}
@SuppressWarnings("unchecked")
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 275a4a0c45..2209619551 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
@@ -578,6 +578,27 @@ class ReposiliteSidecarClientTest {
"com.example", "broken"));
}
+ @Test
+ void deletePackageSendsADeleteToTheGroupArtifactDirectory() {
+ AtomicReference<String> deletedPath = new AtomicReference<>();
+ server.createContext("/dom--repo/com/example/gone/", exchange -> {
+ deletedPath.set(exchange.getRequestURI().toString());
+ respond(exchange, 200, "");
+ });
+
+ client.deletePackage("dom--repo", "dom", "repo", "com.example", "gone");
+
+ assertThat(deletedPath.get(), equalTo("/dom--repo/com/example/gone/"));
+ }
+
+ @Test
+ void deletePackageThrowsWhenTheSidecarAnswersWithAnUnexpectedStatus() {
+ server.createContext("/dom--repo/com/example/weird/", exchange -> respond(exchange, 500, ""));
+
+ assertThrows(IllegalStateException.class, () -> client.deletePackage("dom--repo", "dom", "repo",
+ "com.example", "weird"));
+ }
+
private static void respond(HttpExchange exchange, int status, String body) throws IOException {
byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
exchange.sendResponseHeaders(status, bytes.length);
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.java
index 999e3d4571..b03cb4bdb4 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarClientTest.java
@@ -197,6 +197,54 @@ class VerdaccioSidecarClientTest {
assertEquals("/%2E%2E", observedRawPath.get());
}
+ /**
+ * Mirrors the real npm unpublish mechanism, confirmed against a live Verdaccio container: GET
+ * the packument for its {@code _rev}, then {@code DELETE} the package path with that revision
+ * appended as {@code /-rev/<rev>}.
+ */
+ @Test
+ void deletePackageFetchesTheRevisionThenDeletesWithIt() throws Exception {
+ VerdaccioSidecarManager manager = manager();
+ seedPooledContainer(manager, "npm-repo-1", "tracked-verdaccio-1", backendUrl);
+ backend.createContext("/demo-pkg", exchange -> {
+ byte[] bytes = "{\"_rev\":\"3-abc123\"}".getBytes(StandardCharsets.UTF_8);
+ exchange.getResponseHeaders().set("Content-Type", "application/json");
+ exchange.sendResponseHeaders(200, bytes.length);
+ exchange.getResponseBody().write(bytes);
+ exchange.close();
+ });
+ AtomicReference<String> deletePath = new AtomicReference<>();
+ backend.createContext("/demo-pkg/-rev/3-abc123", exchange -> {
+ deletePath.set(exchange.getRequestURI().toString());
+ exchange.sendResponseHeaders(201, -1);
+ exchange.close();
+ });
+
+ client(manager).deletePackage("npm-repo-1", "dom", "repo", null, "demo-pkg");
+
+ assertEquals("/demo-pkg/-rev/3-abc123", deletePath.get());
+ }
+
+ @Test
+ void deletePackageThrowsWhenTheSidecarRejectsTheDelete() throws Exception {
+ VerdaccioSidecarManager manager = manager();
+ seedPooledContainer(manager, "npm-repo-1", "tracked-verdaccio-1", backendUrl);
+ backend.createContext("/demo-pkg", exchange -> {
+ byte[] bytes = "{\"_rev\":\"3-abc123\"}".getBytes(StandardCharsets.UTF_8);
+ exchange.getResponseHeaders().set("Content-Type", "application/json");
+ exchange.sendResponseHeaders(200, bytes.length);
+ exchange.getResponseBody().write(bytes);
+ exchange.close();
+ });
+ backend.createContext("/demo-pkg/-rev/3-abc123", exchange -> {
+ exchange.sendResponseHeaders(409, -1);
+ exchange.close();
+ });
+
+ assertThrows(IllegalStateException.class, () -> client(manager).deletePackage("npm-repo-1", "dom", "repo",
+ null, "demo-pkg"));
+ }
+
private void respondWithMetadata(String packagePath, String version, String tarballPath) {
String body = "{\"versions\":{\"" + version + "\":{\"dist\":{\"tarball\":\"http://ignored" + tarballPath
+ "\"}}}}";