Light, fluffy, and always free - The AWS Local Emulator alternative
feat(codeartifact): serve the npm format through a real Verdaccio proxy (#4336)
Priamo Germosen3e6c7a34721a
diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.mdindex 3fddd9ec19..7508b94b96 100644--- a/docs/services/codeartifact.md+++ b/docs/services/codeartifact.md@@ -7,10 +7,10 @@Floci supports the CodeArtifact control plane: domains, repositories, resource policies, tags,and public upstream (external) connections. Package publish/fetch through the CodeArtifact APIitself is implemented for the `generic` format only, matching AWS's own restriction that-`PublishPackageVersion` accepts only `generic`. The `maven` format is served through its own real-package-manager-protocol proxy (`mvn`/Gradle publish and resolve both work against the URL-`GetRepositoryEndpoint` returns); the remaining formats (npm, PyPI, NuGet, etc.) have no real-proxy behind them yet.+`PublishPackageVersion` accepts only `generic`. The `maven` and `npm` formats are each served+through their own real package-manager-protocol proxy (`mvn`/Gradle and `npm`/`yarn`/`pnpm`+publish and resolve all work against the URL `GetRepositoryEndpoint` returns); the remaining+formats (PyPI, NuGet, etc.) have no real proxy behind them yet.## Supported Actions@@ -21,7 +21,7 @@ proxy behind them yet.| `DeleteDomain` | Deletes a domain; fails with `ConflictException` while it still contains repositories, and with `ResourceNotFoundException` for a missing domain (as AWS does, although the API reference does not list it). || `DescribeDomain` | Returns a domain's full description, including its repository count. || `ListDomains` | Lists domain summaries for the account and Region, paginated. |-| `GetAuthorizationToken` | Issues a bearer token scoped to a domain, valid for 0 (12 hours) or 900-43200 seconds, required by the `maven` repository endpoint. |+| `GetAuthorizationToken` | Issues a bearer token scoped to a domain, valid for 0 (12 hours) or 900-43200 seconds, required by the `maven` and `npm` repository endpoints. || `PutDomainPermissionsPolicy` | Attaches or replaces a domain's resource policy, versioned by `policyRevision`. || `GetDomainPermissionsPolicy` | Returns a domain's current resource policy and revision. || `DeleteDomainPermissionsPolicy` | Removes a domain's resource policy, optionally checked against `policyRevision`. |@@ -95,6 +95,31 @@ shared settings list. Two config knobs,image version or point at an already-running instance and skip container management, matching thepattern used elsewhere in Floci for sidecars.+## The npm repository endpoint++`GetRepositoryEndpoint` for `format=npm` returns `http://localhost:4566/codeartifact/npm/<domain>/<repository>/`.+Real npm clients (`npm publish`, `npm install`, and their `yarn`/`pnpm` equivalents) can publish to+and resolve from that URL directly; it speaks the real npm registry protocol (package metadata,+tarball fetch, publish), proxied straight through to a real [Verdaccio](https://verdaccio.org)+instance rather than reimplemented. Every request needs `Authorization: Bearer <token>`, using a+token from `GetAuthorizationToken` scoped to the domain being accessed; npm's own credential+configuration (`.npmrc`'s `//<registry-host>/<path>/:_authToken=...`) sets this the same way it+would against real AWS, and always as Bearer (unlike Maven's HTTP Basic). A missing, invalid,+expired, or wrong-domain token gets a 401 challenging `Bearer`.++Unlike Reposilite, which has a native concept of multiple named repositories inside one instance,+Verdaccio does not: each CodeArtifact repository gets its own Verdaccio container instead of+sharing one, started lazily on first use and identified internally by a fresh id generated at+`CreateRepository` time, so a repository deleted and recreated under the same name never inherits+the previous one's packages. `DeleteRepository` stops and removes that repository's container+immediately (the Maven proxy releases its own storage the same way, just through Reposilite's+settings API instead of a container stop, since Reposilite is one shared instance). Each container is+started with `VERDACCIO_PUBLIC_URL` set to that repository's own proxy URL, so package metadata it+returns (`dist.tarball`) points back through Floci instead of the container's own internal,+client-unreachable address; without this, `npm install` would try to fetch the tarball directly+from an address it cannot reach. One config knob, `FLOCI_SERVICES_CODEARTIFACT_NPM_IMAGE`, pins+the image version.+## AWS-compatible failuresDomain and repository names, tags, pagination, duplicate names, missing upstreams, policy-revision@@ -135,24 +160,28 @@ state.runs. The rejection (`ServiceQuotaExceededException` from `PublishPackageVersion`, HTTP 413 fromthe Maven endpoint) is correct for anything that does fit in memory; it is not itself a streamingsize limit.-- **Maven artifacts do not survive a Floci restart, even under persistent storage.** The Reposilite- sidecar container has no volume attached and is removed on shutdown along with everything- published to it. CodeArtifact repository/domain metadata (including the stored sidecar container- id) survives a restart the same way any other Floci state does under persistent storage mode;- the artifacts themselves do not, so the first Maven request after a restart- re-provisions an empty Reposilite repository and returns 404 for anything published before the- restart.+- **Maven artifacts and npm packages do not survive a Floci restart, even under persistent+ storage.** The Reposilite instance and every per-repository Verdaccio container have no volume+ attached and are removed on shutdown along with everything published to them. CodeArtifact+ repository/domain metadata (including each format's stored sidecar container id) survives a+ restart the same way any other Floci state does under persistent storage mode; the artifacts and+ packages themselves do not, so the first request after a restart re-provisions empty storage and+ returns 404 for anything published before the restart.- **`GetAuthorizationToken` tokens are not revocable and are not tied to any IAM identity.** RealCodeArtifact tokens are scoped to the calling principal's permissions; Floci's are scoped only tothe domain named in the request; anyone who obtains one keeps the same domain-scoped access forits full lifetime.-- **The Maven repository endpoint does not resolve through upstream repositories or external- connections.** On real CodeArtifact, a repository with another repository configured as an- upstream (`UpdateRepository`'s `upstreams`) or with an `AssociateExternalConnection` to a public- repository (`public:maven-central`, etc.) serves packages from those sources too, not just its- own. Floci's Maven proxy only ever looks up the repository's own backing storage: a package that- exists solely in an upstream, or only through an external connection, returns 404 through a- repository that has it configured as one.+- **Neither the Maven nor the npm repository endpoint resolves through upstream repositories or+ external connections.** On real CodeArtifact, a repository with another repository configured as+ an upstream (`UpdateRepository`'s `upstreams`) or with an `AssociateExternalConnection` to a+ public repository (`public:maven-central`, `public:npmjs`, etc.) serves packages from those+ sources too, not just its own. Floci's proxies only ever look up the repository's own backing+ storage: a package that exists solely in an upstream, or only through an external connection,+ returns 404 through a repository that has it configured as one.+- **The npm repository endpoint does not enforce the 5 GB asset size quota.** Unlike+ `PublishPackageVersion` and the Maven endpoint, it streams the request straight through to the+ backing Verdaccio container rather than buffering it first, so there is nowhere in the request+ path to check a byte count against the quota before forwarding it.See the [CodeArtifact API Reference](https://docs.aws.amazon.com/codeartifact/latest/APIReference/Welcome.html).@@ -164,3 +193,4 @@ See the [CodeArtifact API Reference](https://docs.aws.amazon.com/codeartifact/la| `FLOCI_SERVICES_CODEARTIFACT_MAVEN_IMAGE` | `dzikoysk/reposilite:3.6.3` | Reposilite image used to serve the `maven` format || `FLOCI_SERVICES_CODEARTIFACT_MAVEN_URL` | unset | When set, use this URL and skip Reposilite container management || `FLOCI_SERVICES_CODEARTIFACT_MAVEN_TOKEN` | unset | `name:secret` access token for a pre-configured `MAVEN_URL` |+| `FLOCI_SERVICES_CODEARTIFACT_NPM_IMAGE` | `verdaccio/verdaccio:6.10.4` | Verdaccio image used to serve the `npm` format |diff --git a/docs/services/index.md b/docs/services/index.mdindex c088351a4d..a8e3105d5d 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/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*` | REST JSON | 26 |+| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*`, `/codeartifact/npm/*` | REST JSON | 26 || [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 | 25 || [Route 53 Resolver](route53resolver.md) | `POST /` + `X-Amz-Target: Route53Resolver.*` | JSON 1.1 | 18 |diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex ac79543541..a8558cbf5d 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -825,6 +825,15 @@ public interface EmulatorConfig {@WithDefault("dzikoysk/reposilite:3.6.3")String mavenImage();++ /**+ * Image used for the per-repository Verdaccio container backing the {@code npm} format.+ * No URL/token override like {@link #mavenUrl()}: unlike Reposilite's one shared instance,+ * npm gets one container per CodeArtifact repository, so there is no single external+ * instance to point at.+ */+ @WithDefault("verdaccio/verdaccio:6.10.4")+ String npmImage();}interface ConnectServiceConfig {diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/PerKeyContainerPool.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/PerKeyContainerPool.javanew file mode 100644index 0000000000..ef637b8864--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/PerKeyContainerPool.java@@ -0,0 +1,112 @@+package io.github.hectorvent.floci.core.common.docker;++import org.jboss.logging.Logger;++import java.util.concurrent.ConcurrentHashMap;++/**+ * Lazily starts, health-checks, and reuses one container per arbitrary key. Pulled out of+ * {@code VerdaccioSidecarManager} (one Verdaccio container per CodeArtifact npm repository) since+ * that lifecycle logic (map of running containers, per-key start lock so concurrent first-use of+ * two different keys never blocks on each other, health poll, restart-on-unhealthy, stop-all on+ * shutdown) has nothing Verdaccio-specific in it; only how to actually build and start a container+ * for a given key does. A future per-repository sidecar (pypiserver, BaGet) can reuse this+ * directly instead of re-deriving the same map/lock/poll skeleton.+ *+ * <p>Callers own the health-check path and the actual container creation (image, config, env),+ * supplied per call since those are exactly the format-specific parts.+ */+public class PerKeyContainerPool {++ private static final Logger LOG = Logger.getLogger(PerKeyContainerPool.class);++ /** What a {@link Starter} hands back once its container is created and started. */+ public record StartedContainer(String containerId, String baseUrl) {}++ /** Builds and starts a fresh container for the key {@link #ensureReady} was called with. */+ @FunctionalInterface+ public interface Starter {+ StartedContainer start();+ }++ private final ContainerLifecycleManager lifecycleManager;+ private final String healthPath;+ private final ConcurrentHashMap<String, StartedContainer> containers = new ConcurrentHashMap<>();+ private final ConcurrentHashMap<String, Object> startLocks = new ConcurrentHashMap<>();++ /**+ * @param healthPath path (e.g. {@code /-/ping}) appended to a container's base URL to probe+ * readiness; expected to return HTTP 200 once the container can serve+ */+ public PerKeyContainerPool(ContainerLifecycleManager lifecycleManager, String healthPath) {+ this.lifecycleManager = lifecycleManager;+ this.healthPath = healthPath;+ }++ /**+ * Base URL of a ready container for {@code key}, starting one via {@code starter} if this is+ * the first use or the previous container is no longer healthy. Concurrent calls for+ * different keys never block on each other; concurrent calls for the same key serialize so+ * only one container is ever started for it.+ */+ public String ensureReady(String key, Starter starter) {+ StartedContainer existing = containers.get(key);+ if (existing != null && SidecarHealthHelper.probeHealth(existing.baseUrl(), healthPath)) {+ return existing.baseUrl();+ }+ Object lock = startLocks.computeIfAbsent(key, k -> new Object());+ synchronized (lock) {+ existing = containers.get(key);+ if (existing != null && SidecarHealthHelper.probeHealth(existing.baseUrl(), healthPath)) {+ return existing.baseUrl();+ }+ if (existing != null) {+ LOG.warnv("Sidecar container for key {0} is no longer healthy; restarting it", key);+ lifecycleManager.stopAndRemove(existing.containerId(), null);+ }+ StartedContainer started = starter.start();+ // Tracked before the health wait, not after: a timeout below must not stop+ // stopContainer()/stopAll() from ever finding this already-running container again.+ containers.put(key, started);+ SidecarHealthHelper.waitForHealth(started.baseUrl(), healthPath);+ return started.baseUrl();+ }+ }++ /**+ * Stops and removes the container for one key, if one was ever started. No-op otherwise.+ * Shares {@link #ensureReady}'s per-key lock so a stop racing a concurrent first-use of the+ * same key serializes against it, instead of running between the moment that start commits to+ * a container and the moment it becomes visible here: without the shared lock, a stop that+ * finds nothing to remove could be immediately followed by that start's own container+ * registration, orphaning it since nothing calls stop for the key again.+ */+ public void stopContainer(String key) {+ if (key == null) {+ return;+ }+ Object lock = startLocks.computeIfAbsent(key, k -> new Object());+ synchronized (lock) {+ StartedContainer container = containers.remove(key);+ if (container != null) {+ lifecycleManager.stopAndRemove(container.containerId(), null);+ }+ }+ }++ /** Stops and removes every container this pool has started, then forgets them all. */+ public void stopAll() {+ if (containers.isEmpty()) {+ return;+ }+ LOG.infov("Stopping {0} pooled sidecar container(s)", containers.size());+ containers.forEach((key, container) -> {+ try {+ lifecycleManager.stopAndRemove(container.containerId(), null);+ } catch (Exception e) {+ LOG.debugv(e, "Failed to stop pooled sidecar container for key {0}", key);+ }+ });+ containers.clear();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/docker/SidecarHealthHelper.java b/src/main/java/io/github/hectorvent/floci/core/common/docker/SidecarHealthHelper.javanew file mode 100644index 0000000000..7a9d6f67ae--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/docker/SidecarHealthHelper.java@@ -0,0 +1,58 @@+package io.github.hectorvent.floci.core.common.docker;++import org.jboss.logging.Logger;++import java.io.IOException;+import java.net.HttpURLConnection;+import java.net.URI;++/**+ * A single HTTP GET health probe, and a bounded poll built on it, shared by every sidecar manager+ * that waits for its own container to come up: {@link PerKeyContainerPool} and+ * {@code ReposiliteSidecarManager} both had their own copy of this before it moved here.+ */+public final class SidecarHealthHelper {++ private static final Logger LOG = Logger.getLogger(SidecarHealthHelper.class);+ private static final int HEALTH_POLL_MAX_MS = 30_000;+ private static final int HEALTH_POLL_INTERVAL_MS = 500;+ private static final int PROBE_TIMEOUT_MS = 500;++ private SidecarHealthHelper() {+ }++ /** {@code true} once a GET to {@code baseUrl + healthPath} returns HTTP 200. */+ public static boolean probeHealth(String baseUrl, String healthPath) {+ try {+ HttpURLConnection connection = (HttpURLConnection) URI.create(baseUrl + healthPath).toURL()+ .openConnection();+ connection.setConnectTimeout(PROBE_TIMEOUT_MS);+ connection.setReadTimeout(PROBE_TIMEOUT_MS);+ return connection.getResponseCode() == 200;+ } catch (IOException e) {+ LOG.debugv(e, "Sidecar health probe failed for {0}", baseUrl);+ return false;+ }+ }++ /**+ * Polls {@link #probeHealth} every {@value #HEALTH_POLL_INTERVAL_MS} ms until it succeeds or+ * {@value #HEALTH_POLL_MAX_MS} ms have passed, in which case this throws.+ */+ public static void waitForHealth(String baseUrl, String healthPath) {+ long deadline = System.currentTimeMillis() + HEALTH_POLL_MAX_MS;+ while (System.currentTimeMillis() < deadline) {+ if (probeHealth(baseUrl, healthPath)) {+ return;+ }+ try {+ Thread.sleep(HEALTH_POLL_INTERVAL_MS);+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new IllegalStateException("Interrupted while waiting for sidecar container", e);+ }+ }+ throw new IllegalStateException("Sidecar container at " + baseUrl + " did not become healthy within "+ + HEALTH_POLL_MAX_MS + " ms");+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDataPlane.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDataPlane.javanew file mode 100644index 0000000000..0c8846391b--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDataPlane.java@@ -0,0 +1,214 @@+package io.github.hectorvent.floci.services.codeartifact;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.AuthorizationTokenScope;+import io.vertx.core.Vertx;+import io.vertx.core.http.HttpClient;+import io.vertx.core.http.HttpClientOptions;+import io.vertx.core.http.HttpClientRequest;+import io.vertx.core.http.HttpClientResponse;+import io.vertx.core.http.HttpMethod;+import io.vertx.core.http.RequestOptions;+import io.vertx.ext.web.Router;+import io.vertx.ext.web.RoutingContext;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.event.Observes;+import jakarta.inject.Inject;++import java.net.URI;+import java.util.Optional;+import java.util.Set;++/**+ * Proxies the real npm registry protocol through Floci to the per-repository Verdaccio container+ * backing {@code GetRepositoryEndpoint}'s {@code npm} format+ * ({@code /codeartifact/npm/<domain>/<repository>/}). A raw streaming proxy, not a JAX-RS+ * controller, since npm's wire protocol has no fixed path shape (package metadata, scoped+ * packages with an encoded slash, tarball downloads, publish) the way Maven's GAV layout does;+ * Verdaccio already speaks that protocol correctly, so this only needs to authenticate the+ * request and forward it.+ *+ * <p>Real CodeArtifact npm auth is {@code Authorization: Bearer <token>} (npm's own+ * {@code _authToken} config always sends Bearer, unlike Maven's HTTP wagon), so unlike+ * {@code CodeArtifactMavenController} there is no Basic-auth form to also accept here.+ */+@ApplicationScoped+public class CodeArtifactNpmDataPlane {++ private static final String PREFIX = "/codeartifact/npm/";+ private static final String SERVICE_KEY = "codeartifact";+ private static final String BEARER_PREFIX = "Bearer ";+ private static final Set<String> HOP_BY_HOP_HEADERS = Set.of(+ "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",+ "te", "trailers", "transfer-encoding", "upgrade", "authorization", "host");++ private final CodeArtifactService service;+ private final VerdaccioSidecarManager verdaccioManager;+ private final ServiceConfigAccess serviceConfigAccess;+ private final EmulatorConfig config;+ private final Vertx vertx;+ private final HttpClient proxyClient;++ @Inject+ public CodeArtifactNpmDataPlane(CodeArtifactService service, VerdaccioSidecarManager verdaccioManager,+ ServiceConfigAccess serviceConfigAccess, EmulatorConfig config, Vertx vertx) {+ this.service = service;+ this.verdaccioManager = verdaccioManager;+ this.serviceConfigAccess = serviceConfigAccess;+ this.config = config;+ this.vertx = vertx;+ this.proxyClient = vertx.createHttpClient(new HttpClientOptions()+ .setConnectTimeout(5_000)+ .setKeepAlive(true));+ }++ void register(@Observes Router router) {+ router.route(PREFIX + "*").handler(this::handle);+ }++ /**+ * A raw Vert.x route, unlike {@code CodeArtifactMavenController}, never passes through+ * {@code ServiceEnabledFilter} (a JAX-RS {@code ContainerRequestFilter}), so a disabled+ * {@code codeartifact} service has to be checked here explicitly or this route would keep+ * serving npm reads and publishes regardless.+ */+ private void handle(RoutingContext context) {+ if (!serviceConfigAccess.isEnabled(SERVICE_KEY)) {+ context.next();+ return;+ }+ Optional<NpmRequest> request = requestFor(context.request().path());+ if (request.isEmpty()) {+ context.next();+ return;+ }+ NpmRequest npmRequest = request.get();++ String token = extractToken(context);+ Optional<AuthorizationTokenScope> scope =+ token == null ? Optional.empty() : service.resolveAuthorizationToken(token, npmRequest.domain());+ if (scope.isEmpty()) {+ context.response().putHeader("WWW-Authenticate", "Bearer").setStatusCode(401).end();+ return;+ }++ String npmRepositoryId;+ try {+ npmRepositoryId = service.ensureFormatContainerId("npm", scope.get().region(), npmRequest.domain(),+ scope.get().owner(), npmRequest.repository());+ } catch (AwsException e) {+ context.response().setStatusCode(404).end();+ return;+ }++ context.request().pause();+ String publicUrl = config.effectiveBaseUrl() + PREFIX + npmRequest.domain() + "/" + npmRequest.repository()+ + "/";+ String repoId = npmRepositoryId;+ vertx.<String>executeBlocking(promise -> promise.complete(verdaccioManager.ensureReady(repoId, publicUrl)))+ .onComplete(result -> {+ if (result.failed()) {+ context.request().resume();+ context.response().setStatusCode(503).end();+ return;+ }+ proxy(context, result.result(), npmRequest.rest() + querySuffix(context));+ });+ }++ private void proxy(RoutingContext context, String backendBaseUrl, String backendPath) {+ URI backend = URI.create(backendBaseUrl);+ RequestOptions options = new RequestOptions()+ .setHost(backend.getHost())+ .setPort(backend.getPort())+ .setURI(backendPath)+ .setMethod(context.request().method());+ proxyClient.request(options).onComplete(upstreamRequest -> {+ if (upstreamRequest.failed()) {+ context.request().resume();+ context.response().setStatusCode(503).end();+ return;+ }+ HttpClientRequest clientReq = upstreamRequest.result();+ copyRequestHeaders(context, clientReq);+ clientReq.response().onComplete(upstreamResponse -> {+ if (upstreamResponse.failed()) {+ if (!context.response().ended()) {+ context.response().setStatusCode(502).end();+ }+ return;+ }+ copyResponseHeaders(context, upstreamResponse.result());+ upstreamResponse.result().pipeTo(context.response());+ });+ clientReq.send(context.request()).onFailure(ignored -> {+ if (!context.response().ended()) {+ context.response().setStatusCode(502).end();+ }+ });+ context.request().resume();+ });+ }++ private static void copyRequestHeaders(RoutingContext context, HttpClientRequest upstream) {+ context.request().headers().forEach(header -> {+ if (!HOP_BY_HOP_HEADERS.contains(header.getKey().toLowerCase())) {+ upstream.putHeader(header.getKey(), header.getValue());+ }+ });+ if (context.request().getHeader("Content-Length") == null+ && ("chunked".equalsIgnoreCase(context.request().getHeader("Transfer-Encoding"))+ || context.request().method() == HttpMethod.POST+ || context.request().method() == HttpMethod.PUT+ || context.request().method() == HttpMethod.PATCH)) {+ upstream.setChunked(true);+ }+ }++ /**+ * Skips {@code Content-Length} and always streams chunked, rather than copying the upstream+ * length through: Quarkus's own response filters can commit this response to chunked framing+ * before this handler ever runs, and a Content-Length header set after that point makes Vert.x+ * throw on the first {@code pipeTo} write instead of silently doing the right thing.+ */+ private static void copyResponseHeaders(RoutingContext context, HttpClientResponse upstream) {+ context.response().setStatusCode(upstream.statusCode());+ upstream.headers().forEach(header -> {+ if (!HOP_BY_HOP_HEADERS.contains(header.getKey().toLowerCase())+ && !"content-length".equalsIgnoreCase(header.getKey())) {+ context.response().putHeader(header.getKey(), header.getValue());+ }+ });+ context.response().setChunked(true);+ }++ private static String extractToken(RoutingContext context) {+ String authorization = context.request().getHeader("Authorization");+ if (authorization == null || !authorization.startsWith(BEARER_PREFIX)) {+ return null;+ }+ return authorization.substring(BEARER_PREFIX.length());+ }++ private static String querySuffix(RoutingContext context) {+ String query = context.request().query();+ return query == null || query.isEmpty() ? "" : "?" + query;+ }++ static Optional<NpmRequest> requestFor(String path) {+ if (path == null || !path.startsWith(PREFIX)) {+ return Optional.empty();+ }+ String remainder = path.substring(PREFIX.length());+ String[] segments = remainder.split("/", 3);+ if (segments.length < 2 || segments[0].isEmpty() || segments[1].isEmpty()) {+ return Optional.empty();+ }+ String rest = segments.length == 3 ? "/" + segments[2] : "/";+ return Optional.of(new NpmRequest(segments[0], segments[1], rest));+ }++ record NpmRequest(String domain, String repository, String rest) {}+}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.javaindex 9aa6c2a8ac..0c9881a87a 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@@ -71,7 +71,7 @@ public class CodeArtifactService implements Resettable {* and the backfill in {@link #ensureFormatContainerId} already handle it, including for* repositories created before that format's proxy existed.*/- private static final List<String> CONTAINER_BACKED_FORMATS = List.of("maven");+ private static final List<String> CONTAINER_BACKED_FORMATS = List.of("maven", "npm");private static final Logger LOG = Logger.getLogger(CodeArtifactService.class);@@ -313,16 +313,26 @@ public class CodeArtifactService implements Resettable {String key = repositoryKey(region, domain, repository);CodeArtifactRepository r = requireRepository(owner, key, repository);repositories.deleteForAccount(owner, key);- // Generic over whatever formats this repository actually has sidecar ids for: adding the- // next format's sidecar needs no change here, only a new RepositorySidecarManager- // implementation that CodeArtifactSidecarRegistry discovers.- //// Best-effort: the metadata delete above already committed, matching real CodeArtifact's// own DeleteRepository (synchronous and always succeeds once the repository exists; actual// content cleanup is an internal detail never exposed to the caller). A sidecar that is// unreachable when this runs must not turn an already-successful delete into a 500, and// must not leave the repository stuck: a retry would just 404, since the record above is// already gone.+ releaseSidecarStorage(r, domain, repository);+ return r;+ }++ /**+ * Generic over whatever formats a repository actually has sidecar ids for: adding the next+ * format's sidecar needs no change here, only a new {@link RepositorySidecarManager}+ * implementation that {@link CodeArtifactSidecarRegistry} discovers. Shared by+ * {@link #deleteRepository} and {@link #beforeReset}, both of which forget the repository's+ * record right after calling this and so must not leave its sidecar storage (a Docker+ * container, for a per-repository sidecar such as Verdaccio) running with nothing left able to+ * ever release it again.+ */+ private void releaseSidecarStorage(CodeArtifactRepository r, String domain, String repository) {r.getSidecarContainerIds().forEach((format, containerId) ->sidecarRegistry.forFormat(format).ifPresent(manager -> {try {@@ -332,7 +342,6 @@ public class CodeArtifactService implements Resettable {format, domain, repository, e.getMessage());}}));- return r;}public CodeArtifactRepository describeRepository(String region, String domain, String domainOwner,@@ -750,6 +759,18 @@ public class CodeArtifactService implements Resettable {ref.repository()).getTags();}+ /**+ * Releases every repository's sidecar storage before {@link #clear} wipes the records that+ * name it. Without this, an emulator reset forgets which sidecar container backs a repository+ * without ever stopping it: harmless for Maven's one shared Reposilite instance, but a real+ * Docker container leak for a per-repository sidecar such as Verdaccio, one abandoned+ * container per repository that existed at reset time.+ */+ @Override+ public void beforeReset() {+ repositories.scanAllAccounts().forEach(r -> releaseSidecarStorage(r, r.getDomainName(), r.getName()));+ }+@Overridepublic void clear() {domains.clear();diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarManager.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarManager.javaindex 665568ddbb..89c488d481 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarManager.java@@ -7,15 +7,13 @@ import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.Cimport io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;import io.github.hectorvent.floci.core.common.docker.ContainerSpec;import io.github.hectorvent.floci.core.common.docker.ContainerStorageHelper;+import io.github.hectorvent.floci.core.common.docker.SidecarHealthHelper;import io.quarkus.runtime.ShutdownEvent;import jakarta.enterprise.context.ApplicationScoped;import jakarta.enterprise.event.Observes;import jakarta.inject.Inject;import org.jboss.logging.Logger;-import java.io.IOException;-import java.net.HttpURLConnection;-import java.net.URI;import java.nio.charset.StandardCharsets;import java.security.SecureRandom;import java.util.Base64;@@ -42,8 +40,7 @@ public class ReposiliteSidecarManager {private static final Logger LOG = Logger.getLogger(ReposiliteSidecarManager.class);private static final String CONTAINER_NAME = "floci-reposilite";private static final int REPOSILITE_PORT = 8080;- private static final int HEALTH_POLL_MAX_MS = 30_000;- private static final int HEALTH_POLL_INTERVAL_MS = 500;+ private static final String HEALTH_PATH = "/api/status/health";private static final int GENERATED_SECRET_BYTES = 24;private final ContainerBuilder containerBuilder;@@ -93,7 +90,7 @@ public class ReposiliteSidecarManager {/** Base URL of a ready Reposilite instance, starting the managed container if needed. */public synchronized String ensureReady() {if (resolvedUrl != null) {- if (containerId == null || probeHealth(resolvedUrl)) {+ if (containerId == null || SidecarHealthHelper.probeHealth(resolvedUrl, HEALTH_PATH)) {return resolvedUrl;}discardStaleManagedEndpoint();@@ -109,7 +106,7 @@ public class ReposiliteSidecarManager {}resolvedTokenName = token.substring(0, separator);resolvedTokenSecret = token.substring(separator + 1);- probeHealth(url);+ SidecarHealthHelper.probeHealth(url, HEALTH_PATH);resolvedUrl = url;LOG.infov("Using pre-configured Reposilite sidecar URL: {0}", resolvedUrl);return resolvedUrl;@@ -159,41 +156,11 @@ public class ReposiliteSidecarManager {resolvedTokenName = MANAGED_TOKEN_NAME;resolvedTokenSecret = managedSecret;String url = "http://" + endpoint;- waitForHealth(url);+ SidecarHealthHelper.waitForHealth(url, HEALTH_PATH);resolvedUrl = url;LOG.infov("Reposilite sidecar is ready at {0}", resolvedUrl);}- private boolean probeHealth(String baseUrl) {- try {- HttpURLConnection connection = (HttpURLConnection) URI.create(baseUrl + "/api/status/health").toURL()- .openConnection();- connection.setConnectTimeout(500);- connection.setReadTimeout(500);- return connection.getResponseCode() == 200;- } catch (IOException e) {- LOG.debugv(e, "Reposilite sidecar health probe failed for {0}", baseUrl);- return false;- }- }-- private void waitForHealth(String baseUrl) {- long deadline = System.currentTimeMillis() + HEALTH_POLL_MAX_MS;- while (System.currentTimeMillis() < deadline) {- if (probeHealth(baseUrl)) {- return;- }- try {- Thread.sleep(HEALTH_POLL_INTERVAL_MS);- } catch (InterruptedException e) {- Thread.currentThread().interrupt();- throw new IllegalStateException("Interrupted while waiting for Reposilite sidecar", e);- }- }- throw new IllegalStateException("Reposilite sidecar did not become healthy within " + HEALTH_POLL_MAX_MS- + " ms");- }-void onStop(@Observes ShutdownEvent event) {if (containerId == null) {return;diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarManager.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarManager.javanew file mode 100644index 0000000000..f1967e0594--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/VerdaccioSidecarManager.java@@ -0,0 +1,177 @@+package io.github.hectorvent.floci.services.codeartifact;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.ContainerInfo;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager.EndpointInfo;+import io.github.hectorvent.floci.core.common.docker.ContainerSpec;+import io.github.hectorvent.floci.core.common.docker.ContainerStorageHelper;+import io.github.hectorvent.floci.core.common.docker.PerKeyContainerPool;+import io.quarkus.runtime.ShutdownEvent;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.event.Observes;+import jakarta.inject.Inject;+import org.apache.commons.compress.archivers.tar.TarArchiveEntry;+import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;+import org.jboss.logging.Logger;++import java.io.ByteArrayInputStream;+import java.io.ByteArrayOutputStream;+import java.io.IOException;+import java.nio.charset.StandardCharsets;++/**+ * Lazily starts and manages one Verdaccio container per CodeArtifact repository backing the+ * {@code npm} format. Unlike Reposilite (Maven), Verdaccio has no native concept of multiple+ * named repositories inside one instance, so npm repositories each get their own container+ * instead of sharing one the way {@link ReposiliteSidecarManager} does. The actual per-key+ * container lifecycle (map of running containers, per-key start lock, health poll,+ * restart-on-unhealthy, stop-all on shutdown) is generic and lives in+ * {@link PerKeyContainerPool}; this class only knows how to build and configure a Verdaccio+ * container specifically.+ *+ * <p>Each container is configured with open access (no auth, no upstream proxying) since the+ * real CodeArtifact authorization check happens once at Floci's proxy layer+ * ({@code CodeArtifactNpmDataPlane}), before a request ever reaches the container; the container+ * itself is never reachable directly by a client.+ */+@ApplicationScoped+public class VerdaccioSidecarManager implements RepositorySidecarManager {++ private static final Logger LOG = Logger.getLogger(VerdaccioSidecarManager.class);+ private static final String FORMAT = "npm";+ private static final int VERDACCIO_PORT = 4873;+ private static final String HEALTH_PATH = "/-/ping";+ private static final String CONFIG_REMOTE_DIR = "/verdaccio/conf";+ private static final String CONFIG_FILE_NAME = "config.yaml";++ /**+ * Open access for both read and publish (real CodeArtifact auth is already enforced before a+ * request reaches this container) and no uplinks, matching the Maven proxy's own deliberate+ * choice not to resolve upstream repositories or external connections.+ */+ private static final String CONFIG_YAML = """+ storage: /verdaccio/storage/data+ plugins: /verdaccio/plugins+ auth:+ htpasswd:+ file: /verdaccio/storage/htpasswd+ uplinks: {}+ packages:+ '**':+ access: $all+ publish: $all+ unpublish: $all+ listen: 0.0.0.0:4873+ log:+ type: stdout+ format: pretty+ level: warn+ """;++ private final ContainerBuilder containerBuilder;+ private final ContainerLifecycleManager lifecycleManager;+ private final EmulatorConfig config;+ private final PerKeyContainerPool pool;++ @Inject+ public VerdaccioSidecarManager(ContainerBuilder containerBuilder, ContainerLifecycleManager lifecycleManager,+ EmulatorConfig config) {+ this.containerBuilder = containerBuilder;+ this.lifecycleManager = lifecycleManager;+ this.config = config;+ this.pool = new PerKeyContainerPool(lifecycleManager, HEALTH_PATH);+ }++ @Override+ public String format() {+ return FORMAT;+ }++ /**+ * Base URL of a ready Verdaccio instance for this npm repository, starting its container if+ * this is the first use. Each repository's container is independent, so concurrent first-use+ * of two different repositories never blocks on each other (unlike Reposilite's one shared+ * instance, which does need a single lock around every provisioning call).+ *+ * @param publicUrl the externally reachable proxy URL for this specific repository (e.g.+ * {@code http://localhost:4566/codeartifact/npm/<domain>/<repository>/}),+ * passed to the container as {@code VERDACCIO_PUBLIC_URL} so package metadata+ * it returns (notably {@code dist.tarball}) points back through Floci's proxy+ * instead of the container's own internal, unreachable-by-the-client address.+ */+ @Override+ public String ensureReady(String npmRepositoryId, String publicUrl) {+ return pool.ensureReady(npmRepositoryId, () -> startContainer(npmRepositoryId, publicUrl));+ }++ /** Stops and removes the container for one npm repository, if one was ever started. */+ @Override+ public void release(String npmRepositoryId) {+ pool.stopContainer(npmRepositoryId);+ }++ private PerKeyContainerPool.StartedContainer startContainer(String npmRepositoryId, String publicUrl) {+ String image = config.services().codeartifact().npmImage();+ String containerName = ContainerStorageHelper.dockerName(config, "floci-verdaccio-" + npmRepositoryId);+ lifecycleManager.removeIfExists(containerName);++ // Loopback-only: this container has no auth of its own (open $all access, matching the+ // Maven proxy's own deliberate choice not to resolve upstreams), so the Bearer check in+ // CodeArtifactNpmDataPlane is the only thing standing between a client and the backing+ // storage. Publishing this to every interface would let anyone who can reach the host+ // bypass that check entirely.+ ContainerSpec spec = containerBuilder.newContainer(image)+ .withName(containerName)+ .withEnv("VERDACCIO_PUBLIC_URL", publicUrl)+ .withLoopbackPortBinding(VERDACCIO_PORT, 0)+ .withDockerNetwork(config.services().dockerNetwork())+ .withEmbeddedDns()+ .withLogRotation()+ .build();+ String containerId = lifecycleManager.create(spec);+ try {+ copyConfig(containerId);+ ContainerInfo info = lifecycleManager.startCreated(containerId, spec);+ EndpointInfo endpoint = info.getEndpoint(VERDACCIO_PORT);+ String url = "http://" + endpoint;+ LOG.infov("Verdaccio sidecar for npm repository {0} is ready at {1}", npmRepositoryId, url);+ return new PerKeyContainerPool.StartedContainer(containerId, url);+ } catch (RuntimeException e) {+ lifecycleManager.stopAndRemove(containerId, null);+ throw e;+ }+ }++ /**+ * Copies {@code config.yaml} into the created, not yet started, container. A copy rather than+ * a bind mount for the same reason {@code ContainerLifecycleManager} copies in the CA bundle:+ * when Floci itself runs in Docker, its own persistent path is not a host path the daemon can+ * mount into a sibling container.+ */+ private void copyConfig(String containerId) {+ byte[] content = CONFIG_YAML.getBytes(StandardCharsets.UTF_8);+ try {+ ByteArrayOutputStream archive = new ByteArrayOutputStream(content.length + 512);+ try (TarArchiveOutputStream tar = new TarArchiveOutputStream(archive)) {+ TarArchiveEntry entry = new TarArchiveEntry(CONFIG_FILE_NAME);+ entry.setSize(content.length);+ entry.setMode(0644);+ tar.putArchiveEntry(entry);+ tar.write(content);+ tar.closeArchiveEntry();+ }+ lifecycleManager.getDockerClient().copyArchiveToContainerCmd(containerId)+ .withRemotePath(CONFIG_REMOTE_DIR)+ .withTarInputStream(new ByteArrayInputStream(archive.toByteArray()))+ .exec();+ } catch (IOException e) {+ throw new IllegalStateException("Could not write the Verdaccio config into container " + containerId, e);+ }+ }++ void onStop(@Observes ShutdownEvent ignored) {+ pool.stopAll();+ }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex aadd77b835..7035f80014 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -879,6 +879,7 @@ floci:enabled: true# maven-url: http://floci-reposilite:8080 # set to skip Reposilite sidecar container managementmaven-image: "dzikoysk/reposilite:3.6.3"+ npm-image: "verdaccio/verdaccio:6.10.4"marketplace:enabled: truedms:diff --git a/src/test/java/io/github/hectorvent/floci/core/common/docker/PerKeyContainerPoolTest.java b/src/test/java/io/github/hectorvent/floci/core/common/docker/PerKeyContainerPoolTest.javanew file mode 100644index 0000000000..044fcfa09e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/docker/PerKeyContainerPoolTest.java@@ -0,0 +1,221 @@+package io.github.hectorvent.floci.core.common.docker;++import com.sun.net.httpserver.HttpServer;+import io.github.hectorvent.floci.core.common.docker.PerKeyContainerPool.StartedContainer;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Test;++import java.io.IOException;+import java.io.OutputStream;+import java.net.InetSocketAddress;+import java.nio.charset.StandardCharsets;+import java.util.ArrayList;+import java.util.List;+import java.util.concurrent.CopyOnWriteArrayList;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicInteger;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.verifyNoInteractions;+import static org.mockito.Mockito.verifyNoMoreInteractions;++/**+ * Covers the per-key container lifecycle (caching, restart-on-unhealthy, teardown, and the+ * concurrent-first-use guarantee) that every per-repository sidecar manager needs, independent of+ * what kind of container it actually starts.+ */+class PerKeyContainerPoolTest {++ private final ContainerLifecycleManager lifecycleManager = mock(ContainerLifecycleManager.class);+ private final PerKeyContainerPool pool = new PerKeyContainerPool(lifecycleManager, "/ping");+ private final List<HttpServer> fakeContainers = new ArrayList<>();++ @AfterEach+ void stopFakeContainers() {+ fakeContainers.forEach(server -> server.stop(0));+ }++ @Test+ void ensureReadyStartsAContainerOnFirstUse() throws IOException {+ String url = startFakePing(200);+ AtomicInteger starterCalls = new AtomicInteger();++ String result = pool.ensureReady("key-1", () -> {+ starterCalls.incrementAndGet();+ return new StartedContainer("container-1", url);+ });++ assertEquals(url, result);+ assertEquals(1, starterCalls.get());+ }++ @Test+ void ensureReadyReturnsTheCachedUrlWithoutCallingTheStarterWhenAlreadyHealthy() throws IOException {+ String url = startFakePing(200);+ pool.ensureReady("key-1", () -> new StartedContainer("container-1", url));++ String result = pool.ensureReady("key-1", () -> {+ throw new AssertionError("starter must not be called for a healthy, already-started container");+ });++ assertEquals(url, result);+ verifyNoInteractions(lifecycleManager);+ }++ @Test+ void ensureReadyRestartsAnUnhealthyContainer() throws IOException {+ String staleUrl = startFakePing(200);+ pool.ensureReady("key-1", () -> new StartedContainer("stale-container", staleUrl));+ // Only now does the first container stop being healthy: ensureReady's first call for a+ // key always waits for its just-started container to actually come up, so seeding with a+ // container that was never reachable at all would hang on that wait instead of exercising+ // the restart path this test is for.+ fakeContainers.forEach(server -> server.stop(0));++ String freshUrl = startFakePing(200);+ String result = pool.ensureReady("key-1", () -> new StartedContainer("fresh-container", freshUrl));++ assertEquals(freshUrl, result);+ verify(lifecycleManager).stopAndRemove("stale-container", null);+ }++ @Test+ void stopContainerStopsAndForgetsATrackedContainer() throws IOException {+ String url = startFakePing(200);+ pool.ensureReady("key-1", () -> new StartedContainer("container-1", url));++ pool.stopContainer("key-1");++ verify(lifecycleManager).stopAndRemove("container-1", null);+ // A second ensureReady must start a new container: the old one is genuinely forgotten,+ // not just marked unhealthy.+ AtomicInteger starterCalls = new AtomicInteger();+ pool.ensureReady("key-1", () -> {+ starterCalls.incrementAndGet();+ return new StartedContainer("container-2", url);+ });+ assertEquals(1, starterCalls.get());+ }++ @Test+ void stopContainerIsANoOpForAnUntrackedOrNullKey() {+ pool.stopContainer("never-started");+ pool.stopContainer(null);++ verifyNoInteractions(lifecycleManager);+ }++ @Test+ void stopContainerWaitsForAConcurrentFirstUseOfTheSameKeyRatherThanMissingIt() throws Exception {+ String url = startFakePing(200);+ CountDownLatch starterEntered = new CountDownLatch(1);+ CountDownLatch releaseStarter = new CountDownLatch(1);+ ExecutorService pool2 = Executors.newFixedThreadPool(2);+ try {+ Future<String> startFuture = pool2.submit(() -> pool.ensureReady("key-1", () -> {+ starterEntered.countDown();+ try {+ assertTrue(releaseStarter.await(5, TimeUnit.SECONDS));+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ }+ return new StartedContainer("container-1", url);+ }));+ // Once this fires, ensureReady is inside its synchronized block, holding key-1's+ // lock: stopContainer below is guaranteed to block behind it, not race it, with no+ // sleep needed to line the two threads up.+ assertTrue(starterEntered.await(5, TimeUnit.SECONDS));++ Future<?> stopFuture = pool2.submit(() -> pool.stopContainer("key-1"));+ releaseStarter.countDown();++ assertEquals(url, startFuture.get(5, TimeUnit.SECONDS));+ stopFuture.get(5, TimeUnit.SECONDS);+ } finally {+ pool2.shutdown();+ assertTrue(pool2.awaitTermination(30, TimeUnit.SECONDS));+ }++ // The container was tracked (by ensureReady, before stopContainer could run) and then+ // removed (by stopContainer, once it got the lock): the race does not orphan it.+ verify(lifecycleManager).stopAndRemove("container-1", null);+ }++ @Test+ void stopAllStopsEveryTrackedContainerAndForgetsThem() throws IOException {+ String urlA = startFakePing(200);+ String urlB = startFakePing(200);+ pool.ensureReady("key-a", () -> new StartedContainer("container-a", urlA));+ pool.ensureReady("key-b", () -> new StartedContainer("container-b", urlB));++ pool.stopAll();++ verify(lifecycleManager).stopAndRemove("container-a", null);+ verify(lifecycleManager).stopAndRemove("container-b", null);+ verifyNoMoreInteractions(lifecycleManager);+ }++ @Test+ void stopAllIsANoOpWhenNothingWasEverStarted() {+ pool.stopAll();++ verifyNoInteractions(lifecycleManager);+ }++ @Test+ void concurrentFirstUseOfTheSameKeyOnlyStartsOneContainer() throws Exception {+ String url = startFakePing(200);+ AtomicInteger starterCalls = new AtomicInteger();+ int attempts = 8;+ ExecutorService pool2 = Executors.newFixedThreadPool(attempts);+ CountDownLatch ready = new CountDownLatch(attempts);+ CountDownLatch go = new CountDownLatch(1);+ List<String> results = new CopyOnWriteArrayList<>();+ try {+ for (int i = 0; i < attempts; i++) {+ pool2.submit(() -> {+ ready.countDown();+ try {+ go.await();+ results.add(pool.ensureReady("shared-key", () -> {+ starterCalls.incrementAndGet();+ return new StartedContainer("container-shared", url);+ }));+ } catch (InterruptedException ignored) {+ Thread.currentThread().interrupt();+ }+ });+ }+ ready.await(5, TimeUnit.SECONDS);+ go.countDown();+ } finally {+ pool2.shutdown();+ assertTrue(pool2.awaitTermination(30, TimeUnit.SECONDS));+ }++ assertEquals(1, starterCalls.get());+ assertEquals(attempts, results.size());+ results.forEach(r -> assertEquals(url, r));+ }++ private String startFakePing(int status) throws IOException {+ HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.createContext("/ping", exchange -> {+ byte[] bytes = "{}".getBytes(StandardCharsets.UTF_8);+ exchange.sendResponseHeaders(status, bytes.length);+ try (OutputStream out = exchange.getResponseBody()) {+ out.write(bytes);+ }+ });+ server.start();+ fakeContainers.add(server);+ return "http://127.0.0.1:" + server.getAddress().getPort();+ }+}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.javaindex c2094ad3a6..29d59c940f 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@@ -238,6 +238,21 @@ class CodeArtifactIntegrationTest {.then().statusCode(400).body("__type", equalTo("ValidationException"));}+ /**+ * Proves the npm route is genuinely wired into the running instance ({@code @Observes+ * Router} registration, the {@code ServiceConfigAccess} enablement check, and the token+ * check), the one thing {@code CodeArtifactNpmDataPlaneTest} cannot: it builds the class by+ * hand rather than through CDI, so it proves nothing about whether the observer actually+ * registers. A missing token is rejected before the named domain or repository is looked up,+ * so this needs neither to exist, and needs no Docker.+ */+ @Test+ void npmEndpointRejectsAMissingTokenWithoutADomainOrRepositoryExisting() {+ given().get("/codeartifact/npm/no-such-domain/no-such-repo/lodash")+ .then().statusCode(401)+ .header("WWW-Authenticate", equalTo("Bearer"));+ }+private static String sha256Hex(byte[] content) {try {return SigV4RequestValidator.sha256Hex(content);diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDataPlaneTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDataPlaneTest.javanew file mode 100644index 0000000000..94c981dc92--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDataPlaneTest.java@@ -0,0 +1,255 @@+package io.github.hectorvent.floci.services.codeartifact;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.AuthorizationTokenScope;+import io.vertx.core.Vertx;+import io.vertx.core.http.HttpClient;+import io.vertx.core.http.HttpClientRequest;+import io.vertx.core.http.HttpClientResponse;+import io.vertx.core.http.HttpMethod;+import io.vertx.core.http.HttpServer;+import io.vertx.core.http.RequestOptions;+import io.vertx.ext.web.Router;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.nio.charset.StandardCharsets;+import java.util.HashMap;+import java.util.Map;+import java.util.Optional;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicReference;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.verifyNoInteractions;+import static org.mockito.Mockito.when;++/**+ * Unit tests for routing npm registry traffic through Floci's data plane to the per-repository+ * Verdaccio container. {@link VerdaccioSidecarManager} is mocked throughout, so no container ever+ * actually starts; the round-trip proxy tests point it at a fake upstream HTTP server instead. The+ * real container-creation path (config injection, {@code VERDACCIO_PUBLIC_URL}) is covered by the+ * Docker-gated npm client integration test.+ */+class CodeArtifactNpmDataPlaneTest {++ private static final String DOMAIN = "dom";+ private static final String REPOSITORY = "repo";+ private static final String NPM_REPOSITORY_ID = "npm-repo-id-1";++ private Vertx vertx;+ private HttpServer upstream;+ private HttpServer dataPlane;+ private HttpClient client;++ @BeforeEach+ void setUp() {+ vertx = Vertx.vertx();+ client = vertx.createHttpClient();+ }++ @AfterEach+ void tearDown() throws Exception {+ if (dataPlane != null) {+ dataPlane.close().toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ }+ if (upstream != null) {+ upstream.close().toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ }+ vertx.close().toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ }++ @Test+ void requestForParsesDomainRepositoryAndRest() {+ CodeArtifactNpmDataPlane.NpmRequest request =+ CodeArtifactNpmDataPlane.requestFor("/codeartifact/npm/dom/repo/lodash").orElseThrow();+ assertEquals("dom", request.domain());+ assertEquals("repo", request.repository());+ assertEquals("/lodash", request.rest());+ }++ @Test+ void requestForDefaultsToRootForTheBareRepositoryPath() {+ CodeArtifactNpmDataPlane.NpmRequest request =+ CodeArtifactNpmDataPlane.requestFor("/codeartifact/npm/dom/repo").orElseThrow();+ assertEquals("/", request.rest());+ }++ @Test+ void requestForRejectsAPathOutsideTheNpmPrefix() {+ assertTrue(CodeArtifactNpmDataPlane.requestFor("/codeartifact/maven/dom/repo/x").isEmpty());+ }++ @Test+ void missingTokenIsRejectedWithoutStartingAContainer() throws Exception {+ CodeArtifactService service = mock(CodeArtifactService.class);+ VerdaccioSidecarManager verdaccioManager = mock(VerdaccioSidecarManager.class);+ startDataPlane(service, verdaccioManager);++ HttpResponse response = get("/codeartifact/npm/" + DOMAIN + "/" + REPOSITORY + "/lodash", null);++ assertEquals(401, response.statusCode());+ assertEquals("Bearer", response.headers().get("www-authenticate"));+ }++ @Test+ void disabledCodeArtifactServiceIsNotServedByThisRoute() throws Exception {+ CodeArtifactService service = mock(CodeArtifactService.class);+ VerdaccioSidecarManager verdaccioManager = mock(VerdaccioSidecarManager.class);+ startDataPlane(service, verdaccioManager, false);++ HttpResponse response = get("/codeartifact/npm/" + DOMAIN + "/" + REPOSITORY + "/lodash", "good-token");++ assertEquals(404, response.statusCode());+ verifyNoInteractions(service, verdaccioManager);+ }++ @Test+ void invalidTokenIsRejected() throws Exception {+ CodeArtifactService service = mock(CodeArtifactService.class);+ when(service.resolveAuthorizationToken(anyString(), anyString())).thenReturn(Optional.empty());+ VerdaccioSidecarManager verdaccioManager = mock(VerdaccioSidecarManager.class);+ startDataPlane(service, verdaccioManager);++ HttpResponse response = get("/codeartifact/npm/" + DOMAIN + "/" + REPOSITORY + "/lodash", "not-a-real-token");++ assertEquals(401, response.statusCode());+ }++ @Test+ void unknownRepositoryIsNotFound() throws Exception {+ CodeArtifactService service = mock(CodeArtifactService.class);+ when(service.resolveAuthorizationToken("good-token", DOMAIN))+ .thenReturn(Optional.of(new AuthorizationTokenScope("000000000000", "us-east-1")));+ when(service.ensureFormatContainerId("npm", "us-east-1", DOMAIN, "000000000000", REPOSITORY))+ .thenThrow(new AwsException("ResourceNotFoundException", "no such repository", 404));+ VerdaccioSidecarManager verdaccioManager = mock(VerdaccioSidecarManager.class);+ startDataPlane(service, verdaccioManager);++ HttpResponse response = get("/codeartifact/npm/" + DOMAIN + "/" + REPOSITORY + "/lodash", "good-token");++ assertEquals(404, response.statusCode());+ }++ @Test+ void aValidRequestIsProxiedToTheRepositorysContainerWithTheClientAuthorizationStripped() throws Exception {+ AtomicReference<String> upstreamPath = new AtomicReference<>();+ AtomicReference<String> upstreamAuthHeader = new AtomicReference<>();+ upstream = vertx.createHttpServer()+ .requestHandler(request -> {+ upstreamPath.set(request.path() + (request.query() != null ? "?" + request.query() : ""));+ upstreamAuthHeader.set(request.getHeader("Authorization"));+ request.response().putHeader("Content-Type", "application/json")+ .setStatusCode(200).end("{\"name\":\"lodash\"}");+ })+ .listen(0, "127.0.0.1")+ .toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);++ CodeArtifactService service = mock(CodeArtifactService.class);+ when(service.resolveAuthorizationToken("good-token", DOMAIN))+ .thenReturn(Optional.of(new AuthorizationTokenScope("000000000000", "us-east-1")));+ when(service.ensureFormatContainerId("npm", "us-east-1", DOMAIN, "000000000000", REPOSITORY))+ .thenReturn(NPM_REPOSITORY_ID);+ VerdaccioSidecarManager verdaccioManager = mock(VerdaccioSidecarManager.class);+ when(verdaccioManager.ensureReady(eq(NPM_REPOSITORY_ID), anyString()))+ .thenReturn("http://127.0.0.1:" + upstream.actualPort());+ startDataPlane(service, verdaccioManager);++ HttpResponse response = get("/codeartifact/npm/" + DOMAIN + "/" + REPOSITORY + "/lodash", "good-token");++ assertEquals(200, response.statusCode());+ assertEquals("{\"name\":\"lodash\"}", response.body());+ assertEquals("/lodash", upstreamPath.get());+ assertNull(upstreamAuthHeader.get());+ }++ @Test+ void aPublishPutStreamsTheBodyThrough() throws Exception {+ AtomicReference<String> upstreamBody = new AtomicReference<>();+ AtomicReference<HttpMethod> upstreamMethod = new AtomicReference<>();+ upstream = vertx.createHttpServer()+ .requestHandler(request -> {+ upstreamMethod.set(request.method());+ request.bodyHandler(body -> {+ upstreamBody.set(body.toString());+ request.response().setStatusCode(201).end();+ });+ })+ .listen(0, "127.0.0.1")+ .toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);++ CodeArtifactService service = mock(CodeArtifactService.class);+ when(service.resolveAuthorizationToken("good-token", DOMAIN))+ .thenReturn(Optional.of(new AuthorizationTokenScope("000000000000", "us-east-1")));+ when(service.ensureFormatContainerId("npm", "us-east-1", DOMAIN, "000000000000", REPOSITORY))+ .thenReturn(NPM_REPOSITORY_ID);+ VerdaccioSidecarManager verdaccioManager = mock(VerdaccioSidecarManager.class);+ when(verdaccioManager.ensureReady(eq(NPM_REPOSITORY_ID), anyString()))+ .thenReturn("http://127.0.0.1:" + upstream.actualPort());+ startDataPlane(service, verdaccioManager);++ HttpResponse response = put("/codeartifact/npm/" + DOMAIN + "/" + REPOSITORY + "/my-pkg", "good-token",+ "{\"name\":\"my-pkg\"}");++ assertEquals(201, response.statusCode());+ assertEquals(HttpMethod.PUT, upstreamMethod.get());+ assertEquals("{\"name\":\"my-pkg\"}", upstreamBody.get());+ }++ private void startDataPlane(CodeArtifactService service, VerdaccioSidecarManager verdaccioManager)+ throws Exception {+ startDataPlane(service, verdaccioManager, true);+ }++ private void startDataPlane(CodeArtifactService service, VerdaccioSidecarManager verdaccioManager,+ boolean codeArtifactEnabled) throws Exception {+ EmulatorConfig config = mock(EmulatorConfig.class);+ when(config.effectiveBaseUrl()).thenReturn("http://localhost:4566");+ ServiceConfigAccess serviceConfigAccess = mock(ServiceConfigAccess.class);+ when(serviceConfigAccess.isEnabled("codeartifact")).thenReturn(codeArtifactEnabled);+ Router router = Router.router(vertx);+ new CodeArtifactNpmDataPlane(service, verdaccioManager, serviceConfigAccess, config, vertx).register(router);+ dataPlane = vertx.createHttpServer().requestHandler(router)+ .listen(0, "127.0.0.1")+ .toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ }++ private HttpResponse get(String path, String bearerToken) throws Exception {+ return request(HttpMethod.GET, path, bearerToken, null);+ }++ private HttpResponse put(String path, String bearerToken, String body) throws Exception {+ return request(HttpMethod.PUT, path, bearerToken, body);+ }++ private HttpResponse request(HttpMethod method, String path, String bearerToken, String body) throws Exception {+ RequestOptions options = new RequestOptions()+ .setHost("127.0.0.1")+ .setPort(dataPlane.actualPort())+ .setMethod(method)+ .setURI(path);+ HttpClientRequest req = client.request(options).toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ if (bearerToken != null) {+ req.putHeader("Authorization", "Bearer " + bearerToken);+ }+ HttpClientResponse resp = (body != null+ ? req.send(body)+ : req.send())+ .toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ String responseBody = resp.body().toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS)+ .toString(StandardCharsets.UTF_8);+ Map<String, String> headers = new HashMap<>();+ resp.headers().forEach(h -> headers.put(h.getKey().toLowerCase(), h.getValue()));+ return new HttpResponse(resp.statusCode(), responseBody, headers);+ }++ private record HttpResponse(int statusCode, String body, Map<String, String> headers) {}+}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.javanew file mode 100644index 0000000000..81560bf483--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmDockerIntegrationTest.java@@ -0,0 +1,282 @@+package io.github.hectorvent.floci.services.codeartifact;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import org.hamcrest.Matcher;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import java.io.IOException;+import java.io.InputStream;+import java.nio.charset.StandardCharsets;+import java.util.Base64;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicInteger;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.anyOf;+import static org.hamcrest.Matchers.is;+import static org.hamcrest.Matchers.startsWith;+import static org.junit.jupiter.api.Assertions.assertArrayEquals;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Runs a real npm-shaped publish/fetch round trip against a live, per-repository Verdaccio+ * container, started by {@link VerdaccioSidecarManager} exactly as in production. The publish+ * body is a real request the actual npm CLI sent during manual verification (captured with a tiny+ * Node.js capture server, see {@code npm-publish-fixture.json}), not a hand-rolled approximation,+ * so this test exercises the exact envelope shape (including a real gzip tarball attachment) a+ * real {@code npm publish} produces. The full round trip was additionally verified by hand with+ * the real npm CLI against a live Floci instance ({@code GetAuthorizationToken} through to+ * {@code npm install}), which is what first caught that {@code VERDACCIO_PUBLIC_URL} is required:+ * without it, {@code dist.tarball} in the metadata response points at the container's own+ * internal, client-unreachable address instead of back through this proxy.+ */+@QuarkusTest+@TestProfile(CodeArtifactNpmSidecarProfile.class)+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class CodeArtifactNpmDockerIntegrationTest {++ private static final String AUTH = "AWS4-HMAC-SHA256 Credential=AKID/20260904/us-east-1/codeartifact/aws4_request";+ private static final String DOMAIN = "npm-sidecar-domain";+ private static final String REPO = "npm-sidecar-repo";+ private static final String PACKAGE_NAME = "floci-verdaccio-spike";++ private static String bearerToken;+ private static byte[] publishFixture;+ private static byte[] expectedTarballBytes;++ @BeforeAll+ static void setUp() throws IOException {+ CodeArtifactNpmSidecarProfile.requireDockerAndTheSidecarImage();+ RestAssuredJsonUtils.configureAwsContentTypes();++ ObjectMapper mapper = new ObjectMapper();+ try (InputStream in = CodeArtifactNpmDockerIntegrationTest.class+ .getResourceAsStream("/codeartifact/npm-publish-fixture.json")) {+ publishFixture = in.readAllBytes();+ }+ JsonNode fixture = mapper.readTree(publishFixture);+ String base64Tarball = fixture.path("_attachments").path(PACKAGE_NAME + "-1.0.0.tgz").path("data").asText();+ expectedTarballBytes = Base64.getDecoder().decode(base64Tarball);+ }++ @Test+ @Order(0)+ void createDomainRepositoryAndAuthorizationToken() {+ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/domain?domain=" + DOMAIN)+ .then().statusCode(200);+ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/repository?domain=" + DOMAIN + "&repository=" + REPO)+ .then().statusCode(200);++ bearerToken = given().header("Authorization", AUTH)+ .post("/v1/authorization-token?domain=" + DOMAIN)+ .then().statusCode(200)+ .extract().jsonPath().getString("authorizationToken");+ }++ @Test+ @Order(1)+ void publishThenFetchRoundTripsTheRealNpmEnvelope() throws IOException {+ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json")+ .body(publishFixture)+ .put("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(anyOf201Or200());++ String metadataBody = given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(200)+ .extract().asString();+ String tarballUrl = new ObjectMapper().readTree(metadataBody)+ .path("versions").path("1.0.0").path("dist").path("tarball").asText();++ // Pins VERDACCIO_PUBLIC_URL: without it this would be the container's own internal,+ // client-unreachable address instead of a URL back through this same proxy.+ assertTrue(tarballUrl.startsWith("http://localhost:4566/codeartifact/npm/" + DOMAIN + "/" + REPO + "/"),+ "tarball URL must point back through the proxy, was: " + tarballUrl);++ byte[] fetchedTarball = given().header("Authorization", "Bearer " + bearerToken)+ .get(tarballUrl.substring("http://localhost:4566".length()))+ .then().statusCode(200)+ .extract().asByteArray();+ assertArrayEquals(expectedTarballBytes, fetchedTarball);+ }++ @Test+ @Order(2)+ void missingPackageAndMissingRepositoryAreNotFound() {+ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/does-not-exist")+ .then().statusCode(404);++ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/npm/" + DOMAIN + "/no-such-repo/does-not-exist")+ .then().statusCode(404);+ }++ @Test+ @Order(3)+ void repositoriesAreIsolatedFromEachOther() {+ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/repository?domain=" + DOMAIN + "&repository=other-repo")+ .then().statusCode(200);++ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/npm/" + DOMAIN + "/other-repo/" + PACKAGE_NAME)+ .then().statusCode(404);+ }++ @Test+ @Order(4)+ void missingOrWrongDomainTokensAreUnauthorized() {+ given().get("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(401)+ .header("WWW-Authenticate", startsWith("Bearer"));++ given().header("Authorization", "Bearer not-a-real-token")+ .get("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(401);++ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/domain?domain=other-npm-token-domain")+ .then().statusCode(200);+ String otherDomainToken = given().header("Authorization", AUTH)+ .post("/v1/authorization-token?domain=other-npm-token-domain")+ .then().statusCode(200)+ .extract().jsonPath().getString("authorizationToken");++ given().header("Authorization", "Bearer " + otherDomainToken)+ .get("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(401);+ }++ @Test+ @Order(5)+ void concurrentFirstUseOfANewRepositoryOnlyStartsOneContainer() throws InterruptedException {+ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/repository?domain=" + DOMAIN + "&repository=concurrent-repo")+ .then().statusCode(200);++ int attempts = 8;+ ExecutorService pool = Executors.newFixedThreadPool(attempts);+ CountDownLatch ready = new CountDownLatch(attempts);+ CountDownLatch go = new CountDownLatch(1);+ AtomicInteger notFoundResponses = new AtomicInteger();+ try {+ for (int i = 0; i < attempts; i++) {+ pool.submit(() -> {+ ready.countDown();+ try {+ go.await();+ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/npm/" + DOMAIN + "/concurrent-repo/does-not-exist")+ .then().statusCode(404);+ notFoundResponses.incrementAndGet();+ } catch (InterruptedException ignored) {+ Thread.currentThread().interrupt();+ }+ });+ }+ ready.await(5, TimeUnit.SECONDS);+ go.countDown();+ } finally {+ pool.shutdown();+ assertTrue(pool.awaitTermination(30, TimeUnit.SECONDS));+ }+ assertEquals(attempts, notFoundResponses.get());+ }++ @Test+ @Order(6)+ void recreatingASameNamedRepositoryDoesNotInheritThePreviousOnesPackages() {+ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/repository?domain=" + DOMAIN + "&repository=reused-name")+ .then().statusCode(200);+ given().header("Authorization", "Bearer " + bearerToken).contentType("application/json")+ .body(publishFixture)+ .put("/codeartifact/npm/" + DOMAIN + "/reused-name/" + PACKAGE_NAME)+ .then().statusCode(anyOf201Or200());++ given().header("Authorization", AUTH)+ .delete("/v1/repository?domain=" + DOMAIN + "&repository=reused-name")+ .then().statusCode(200);+ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/repository?domain=" + DOMAIN + "&repository=reused-name")+ .then().statusCode(200);++ given().header("Authorization", "Bearer " + bearerToken)+ .get("/codeartifact/npm/" + DOMAIN + "/reused-name/" + PACKAGE_NAME)+ .then().statusCode(404);+ }++ @Test+ @Order(7)+ void aDomainCreatedInANonDefaultRegionIsServedThroughTheTokensOwnRegion() {+ String nonDefaultRegionAuth =+ "AWS4-HMAC-SHA256 Credential=AKID/20260904/us-west-2/codeartifact/aws4_request";+ String domain = "npm-sidecar-non-default-region-domain";++ given().contentType("application/json").header("Authorization", nonDefaultRegionAuth).body("{}")+ .post("/v1/domain?domain=" + domain)+ .then().statusCode(200);+ given().contentType("application/json").header("Authorization", nonDefaultRegionAuth).body("{}")+ .post("/v1/repository?domain=" + domain + "&repository=" + REPO)+ .then().statusCode(200);+ String token = given().header("Authorization", nonDefaultRegionAuth)+ .post("/v1/authorization-token?domain=" + domain)+ .then().statusCode(200)+ .extract().jsonPath().getString("authorizationToken");++ given().header("Authorization", "Bearer " + token).contentType("application/json")+ .body(publishFixture)+ .put("/codeartifact/npm/" + domain + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(anyOf201Or200());++ given().header("Authorization", "Bearer " + token)+ .get("/codeartifact/npm/" + domain + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(200);+ }++ @Test+ @Order(8)+ void aDomainCreatedUnderANonDefaultAccountIsServedThroughTheTokensOwnAccount() {+ String otherAccountAuth = "AWS4-HMAC-SHA256 Credential=111122223333/20260904/us-east-1/codeartifact/aws4_request";+ String domain = "npm-sidecar-cross-account-domain";++ given().contentType("application/json").header("Authorization", otherAccountAuth).body("{}")+ .post("/v1/domain?domain=" + domain)+ .then().statusCode(200);+ given().contentType("application/json").header("Authorization", otherAccountAuth).body("{}")+ .post("/v1/repository?domain=" + domain + "&repository=" + REPO)+ .then().statusCode(200);+ String token = given().header("Authorization", otherAccountAuth)+ .post("/v1/authorization-token?domain=" + domain)+ .then().statusCode(200)+ .extract().jsonPath().getString("authorizationToken");++ given().header("Authorization", "Bearer " + token).contentType("application/json")+ .body(publishFixture)+ .put("/codeartifact/npm/" + domain + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(anyOf201Or200());++ given().header("Authorization", "Bearer " + token)+ .get("/codeartifact/npm/" + domain + "/" + REPO + "/" + PACKAGE_NAME)+ .then().statusCode(200);+ }++ private static Matcher<Integer> anyOf201Or200() {+ return anyOf(is(200), is(201));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmSidecarProfile.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmSidecarProfile.javanew file mode 100644index 0000000000..9d347a9e85--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactNpmSidecarProfile.java@@ -0,0 +1,52 @@+package io.github.hectorvent.floci.services.codeartifact;++import io.quarkus.test.junit.QuarkusTestProfile;+import org.eclipse.microprofile.config.ConfigProvider;+import org.junit.jupiter.api.Assumptions;++import java.util.Map;++/**+ * Shared by every CodeArtifact integration test that needs a real Verdaccio sidecar container,+ * started by {@link VerdaccioSidecarManager} exactly as in production. Namespaces containers as+ * {@code floci-codeartifact-npm-test-*} so the manager's remove-before-start never touches a+ * developer's real running Floci. Needs Docker; skipped without it. Locally it is also skipped+ * when the pinned image is not present, so a developer without registry access is not stuck; in+ * CI a missing image is a failure, since a vanished tag must not pass silently.+ */+public class CodeArtifactNpmSidecarProfile implements QuarkusTestProfile {++ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.docker.resource-namespace", "codeartifact-npm-test");+ }++ public static void requireDockerAndTheSidecarImage() {+ Assumptions.assumeTrue(isDockerAvailable(), "Docker daemon must be available for CodeArtifact npm "+ + "sidecar integration tests");+ String image = ConfigProvider.getConfig().getValue("floci.services.codeartifact.npm-image", String.class);+ Assumptions.assumeTrue(imageUsable(image), "Verdaccio sidecar image " + image + " is not present locally");+ }++ private static boolean isDockerAvailable() {+ return run("docker", "version", "--format", "{{.Server.Version}}");+ }++ private static boolean imageUsable(String image) {+ if ("true".equals(System.getenv("CI"))) {+ return true;+ }+ return run("docker", "image", "inspect", image);+ }++ private static boolean run(String... command) {+ try {+ Process process = new ProcessBuilder(command).redirectErrorStream(true).start();+ return process.waitFor() == 0;+ } catch (Exception ignored) {+ // Docker (or the image) isn't available; the caller turns this into a skipped test,+ // not a failure, so there is nothing more useful to log here.+ return false;+ }+ }+}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.javaindex 433ba24beb..890862d7c8 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@@ -49,6 +49,7 @@ class CodeArtifactServiceTest {private CodeArtifactService service;private RegionResolver regionResolver;private AccountAwareStorageBackend<CodeArtifactRepository> repoStore;+ private VerdaccioSidecarManager verdaccioManager;private ReposiliteSidecarClient reposiliteClient;@BeforeEach@@ -67,10 +68,12 @@ class CodeArtifactServiceTest {EmulatorConfig config = mock(EmulatorConfig.class);when(config.effectiveBaseUrl()).thenReturn("http://localhost:4566");+ verdaccioManager = mock(VerdaccioSidecarManager.class);+ when(verdaccioManager.format()).thenReturn("npm");reposiliteClient = mock(ReposiliteSidecarClient.class);when(reposiliteClient.format()).thenReturn("maven");service = new CodeArtifactService(domainStore, repoStore, packageVersionStore, regionResolver, config,- true, null, new CodeArtifactSidecarRegistry(List.of(reposiliteClient)));+ true, null, new CodeArtifactSidecarRegistry(List.of(verdaccioManager, reposiliteClient)));}// -------------------------------------------------------------- domains@@ -297,7 +300,7 @@ class CodeArtifactServiceTest {service.createDomain(REGION, "dom", null, Map.of());CodeArtifactRepository created = service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());- assertEquals(Set.of("maven"), created.getSidecarContainerIds().keySet());+ assertEquals(Set.of("maven", "npm"), created.getSidecarContainerIds().keySet());created.getSidecarContainerIds().values().forEach(id -> assertTrue(id != null && !id.isBlank()));}@@ -310,9 +313,12 @@ class CodeArtifactServiceTest {service.deleteRepository(REGION, "dom", null, "repo");CodeArtifactRepository recreated = service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());- assertTrue(!first.getSidecarContainerIds().get("maven").equals(recreated.getSidecarContainerIds().get("maven")),- "a recreated repository must never reuse the previous one's container id for a format, "- + "or it would inherit its leftover artifacts");+ for (String format : Set.of("maven", "npm")) {+ assertTrue(+ !first.getSidecarContainerIds().get(format).equals(recreated.getSidecarContainerIds().get(format)),+ "a recreated repository must never reuse the previous one's container id for a format, "+ + "or it would inherit its leftover artifacts");+ }}@Test@@ -331,6 +337,24 @@ class CodeArtifactServiceTest {service.describeRepository(REGION, "dom", null, "repo").getSidecarContainerIds().get("maven"));}+ @Test+ void ensureFormatContainerIdBackfillsALegacyRepositoryMissingTheNpmFormat() {+ service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository created = service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ // Simulates a repository persisted before the npm format's proxy existed: Jackson would+ // deserialize a missing map entry exactly like this.+ Map<String, String> withoutNpm = new HashMap<>(created.getSidecarContainerIds());+ withoutNpm.remove("npm");+ created.setSidecarContainerIds(withoutNpm);+ repoStore.putForAccount(ACCOUNT_ID, REGION + "::dom::repo", created);++ String backfilled = service.ensureFormatContainerId("npm", REGION, "dom", null, "repo");++ assertTrue(backfilled != null && !backfilled.isBlank());+ assertEquals(backfilled,+ service.describeRepository(REGION, "dom", null, "repo").getSidecarContainerIds().get("npm"));+ }+@Testvoid ensureFormatContainerIdIsIdempotentForAnAlreadyAssignedFormat() {service.createDomain(REGION, "dom", null, Map.of());@@ -341,6 +365,16 @@ class CodeArtifactServiceTest {assertEquals(created.getSidecarContainerIds().get("maven"), result);}+ @Test+ void ensureFormatContainerIdIsIdempotentForAnAlreadyAssignedNpmFormat() {+ service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository created = service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ String result = service.ensureFormatContainerId("npm", REGION, "dom", null, "repo");++ assertEquals(created.getSidecarContainerIds().get("npm"), result);+ }+@Testvoid ensureFormatContainerIdRequiresExistingRepository() {service.createDomain(REGION, "dom", null, Map.of());@@ -356,21 +390,55 @@ class CodeArtifactServiceTest {service.deleteRepository(REGION, "dom", null, "repo");+ verify(verdaccioManager).release(created.getSidecarContainerIds().get("npm"));verify(reposiliteClient).release(created.getSidecarContainerIds().get("maven"));}@Test- void deleteRepositorySucceedsEvenWhenSidecarReleaseFails() {+ void beforeResetReleasesEveryRepositorysSidecarStorageAcrossEveryAccount() {+ service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository first = service.createRepository(REGION, "dom", null, "repo-1", null, null, Map.of());+ CodeArtifactRepository second = service.createRepository(REGION, "dom", null, "repo-2", null, null, Map.of());++ service.beforeReset();++ verify(verdaccioManager).release(first.getSidecarContainerIds().get("npm"));+ verify(reposiliteClient).release(first.getSidecarContainerIds().get("maven"));+ verify(verdaccioManager).release(second.getSidecarContainerIds().get("npm"));+ verify(reposiliteClient).release(second.getSidecarContainerIds().get("maven"));+ }++ @Test+ void beforeResetToleratesASidecarReleaseFailureAndStillReleasesTheRest() {+ service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository first = service.createRepository(REGION, "dom", null, "repo-1", null, null, Map.of());+ CodeArtifactRepository second = service.createRepository(REGION, "dom", null, "repo-2", null, null, Map.of());+ doThrow(new IllegalStateException("Reposilite unreachable")).when(reposiliteClient)+ .release(first.getSidecarContainerIds().get("maven"));++ // A reset must not abort partway through and leave later repositories' containers running+ // just because one repository's release failed.+ service.beforeReset();++ verify(reposiliteClient).release(second.getSidecarContainerIds().get("maven"));+ verify(verdaccioManager).release(first.getSidecarContainerIds().get("npm"));+ verify(verdaccioManager).release(second.getSidecarContainerIds().get("npm"));+ }++ @Test+ void deleteRepositorySucceedsEvenWhenOneFormatsSidecarReleaseFails() {service.createDomain(REGION, "dom", null, Map.of());service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());doThrow(new IllegalStateException("Reposilite unreachable")).when(reposiliteClient).release(anyString());// The metadata delete already committed; a sidecar failure must not turn that into a// caller-visible error, and must not leave the caller unable to ever get a clean response- // for this repository (a retry would just 404, since the record is already gone).+ // for this repository (a retry would just 404, since the record is already gone). npm's+ // release still runs for the same repository even though maven's threw first.CodeArtifactRepository deleted = service.deleteRepository(REGION, "dom", null, "repo");assertEquals("repo", deleted.getName());+ verify(verdaccioManager).release(deleted.getSidecarContainerIds().get("npm"));AwsException e = assertThrows(AwsException.class,() -> service.describeRepository(REGION, "dom", null, "repo"));assertEquals("ResourceNotFoundException", e.getErrorCode());diff --git a/src/test/resources/codeartifact/npm-publish-fixture.json b/src/test/resources/codeartifact/npm-publish-fixture.jsonnew file mode 100644index 0000000000..2cf54be47e--- /dev/null+++ b/src/test/resources/codeartifact/npm-publish-fixture.json@@ -0,0 +1 @@+{"_id":"floci-verdaccio-spike","name":"floci-verdaccio-spike","description":"spike","dist-tags":{"latest":"1.0.0"},"versions":{"1.0.0":{"name":"floci-verdaccio-spike","version":"1.0.0","description":"spike","main":"index.js","_id":"[email protected]","readme":"ERROR: No README data found!","_nodeVersion":"22.23.2","_npmVersion":"10.9.8","dist":{"integrity":"sha512-RqexezC2reWJgFNtDzgLP9DVPluit9i3KCyAUdML6QvTTN2G5ZscrTrqQPA6HYHjeh3UTpUKs6aPBc7JwEMnTQ==","shasum":"33c611165bf0b85e94ad1945eb8e1fb479805044","tarball":"http://127.0.0.1:19999/floci-verdaccio-spike/-/floci-verdaccio-spike-1.0.0.tgz"}}},"access":null,"_attachments":{"floci-verdaccio-spike-1.0.0.tgz":{"content_type":"application/octet-stream","data":"H4sIAAAAAAAC/+3V0WrDIBQGYK/zFAevG3tMjYWOPYyYs2LbRNEkFMbefTRLxxi9bEPH/G4OHP8bL34Nxh7Nntaua+gsDok9ACJqpeDWflLVwDa1Rim1RgUMJW6rChiyBQypN5Eh3uGSiAjf849ofTOcSNA5+NgneAVVvRQs+y/C3P95ikPy3cL9l7X63X9ZK537v4T3AoB3piW+A/528taVI8XGWOt8mYI7El9dIiPF5Hx3SUmBAr+2DSUbXejnkx/51rhpdf1XePGRn5Usy7In8glDddyfAAwAAA==","length":220}}}\ No newline at end of file