Light, fluffy, and always free - The AWS Local Emulator alternative
feat(codeartifact): support publishing and reading generic-format package versions (#3839)
Priamo Germosenbbaf3568c507
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CodeArtifactTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CodeArtifactTest.javaindex 4771494786..c1b607bfca 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CodeArtifactTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CodeArtifactTest.java@@ -2,11 +2,16 @@ package com.floci.test;import org.jboss.logging.Logger;import org.junit.jupiter.api.*;+import software.amazon.awssdk.core.ResponseBytes;+import software.amazon.awssdk.core.sync.RequestBody;import software.amazon.awssdk.services.codeartifact.CodeartifactClient;import software.amazon.awssdk.services.codeartifact.model.*;// Explicit import: this file's Tag usage is the CodeArtifact model type, not JUnit's @Tag.import software.amazon.awssdk.services.codeartifact.model.Tag;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.security.NoSuchAlgorithmException;import java.util.List;import static org.assertj.core.api.Assertions.assertThat;@@ -219,6 +224,76 @@ class CodeArtifactTest {assertThat(disassoc.repository().externalConnections()).isEmpty();}+ @Test+ @Order(70)+ @DisplayName("PublishPackageVersion - publishes a generic asset and verifies its hashes")+ void publishPackageVersion() {+ byte[] content = "hello from the compat suite".getBytes(StandardCharsets.UTF_8);+ String sha256 = sha256Hex(content);++ PublishPackageVersionResponse resp = codeArtifact.publishPackageVersion(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .format(PackageFormat.GENERIC)+ .namespace("compat-ns")+ .packageValue("compat-pkg")+ .packageVersion("1.0.0")+ .assetName("asset.txt")+ .assetSHA256(sha256),+ RequestBody.fromBytes(content));++ assertThat(resp.status()).isEqualTo(PackageVersionStatus.PUBLISHED);+ assertThat(resp.asset().name()).isEqualTo("asset.txt");+ assertThat(resp.asset().size()).isEqualTo(content.length);+ assertThat(resp.asset().hashes().get(HashAlgorithm.SHA_256)).isEqualTo(sha256);+ }++ // No SDK-level bad-assetSHA256 test: the Java SDK overwrites that header during SigV4 signing; see CodeArtifactServiceTest instead.++ @Test+ @Order(72)+ @DisplayName("DescribePackageVersion / GetPackageVersionAsset - round-trip exact bytes")+ void describeAndDownloadPackageVersionAsset() {+ DescribePackageVersionResponse described = codeArtifact.describePackageVersion(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .format(PackageFormat.GENERIC)+ .namespace("compat-ns")+ .packageValue("compat-pkg")+ .packageVersion("1.0.0"));+ assertThat(described.packageVersion().status()).isEqualTo(PackageVersionStatus.PUBLISHED);+ assertThat(described.packageVersion().origin().originType()).isEqualTo(PackageVersionOriginType.INTERNAL);++ ResponseBytes<GetPackageVersionAssetResponse> downloaded = codeArtifact.getPackageVersionAssetAsBytes(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .format(PackageFormat.GENERIC)+ .namespace("compat-ns")+ .packageValue("compat-pkg")+ .packageVersion("1.0.0")+ .asset("asset.txt"));+ assertThat(downloaded.response().assetName()).isEqualTo("asset.txt");+ assertThat(downloaded.asByteArray()).isEqualTo("hello from the compat suite".getBytes(StandardCharsets.UTF_8));+ }++ @Test+ @Order(73)+ @DisplayName("PublishPackageVersion - a second publish to a Published version conflicts")+ void republishingAPublishedVersionConflicts() {+ byte[] content = "won't land".getBytes(StandardCharsets.UTF_8);+ assertThatThrownBy(() -> codeArtifact.publishPackageVersion(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .format(PackageFormat.GENERIC)+ .namespace("compat-ns")+ .packageValue("compat-pkg")+ .packageVersion("1.0.0")+ .assetName("another.txt")+ .assetSHA256(sha256Hex(content)),+ RequestBody.fromBytes(content)))+ .isInstanceOf(ConflictException.class);+ }+@Test@Order(90)@DisplayName("DeleteDomain - fails while repositories still exist")@@ -226,4 +301,17 @@ class CodeArtifactTest {assertThatThrownBy(() -> codeArtifact.deleteDomain(r -> r.domain(DOMAIN))).isInstanceOf(ConflictException.class);}++ private static String sha256Hex(byte[] content) {+ try {+ byte[] digest = MessageDigest.getInstance("SHA-256").digest(content);+ StringBuilder sb = new StringBuilder(digest.length * 2);+ for (byte b : digest) {+ sb.append(String.format("%02x", b));+ }+ return sb.toString();+ } catch (NoSuchAlgorithmException e) {+ throw new IllegalStateException(e);+ }+ }}diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.mdindex f786cd3895..4ce56551b6 100644--- a/docs/services/codeartifact.md+++ b/docs/services/codeartifact.md@@ -5,8 +5,10 @@**Endpoint:** `http://localhost:4566`Floci supports the CodeArtifact control plane: domains, repositories, resource policies, tags,-and public upstream (external) connections. Package publish/fetch endpoints for each format-(npm, PyPI, Maven, NuGet, generic, etc.) are not implemented yet.+and public upstream (external) connections. Package publish/fetch is implemented for the+`generic` format only, matching AWS's own restriction that `PublishPackageVersion` accepts only+`generic`; the other formats (npm, PyPI, Maven, NuGet, etc.) have no real package-manager-protocol+proxy behind them yet.## Supported Actions@@ -32,6 +34,9 @@ and public upstream (external) connections. Package publish/fetch endpoints for| `DeleteRepositoryPermissionsPolicy` | Removes a repository's resource policy, optionally checked against `policyRevision`. || `AssociateExternalConnection` | Attaches a fixed-catalog public upstream (e.g. `public:npmjs`) to a repository; mutually exclusive with repository upstreams. || `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. |+| `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. || `UntagResource` | Removes tags by key from a domain or repository ARN. || `ListTagsForResource` | Lists the tags on a domain or repository ARN. |@@ -48,6 +53,15 @@ enforces the one-external-connection-per-repository limit AWS enforces. A reposiupstream repositories or an external connection, but not both, matching AWS; `CreateRepository`and `UpdateRepository` also cap direct upstreams at 10, AWS's own repository limit.+`PublishPackageVersion` creates a package version in the `Unfinished` state when the `unfinished`+flag is set, and `Published` otherwise; once `Published`, a repeat publish to the same+domain/repository/package/version fails with `ConflictException`, matching AWS's real rule that a+published version cannot accept additional assets. Every publish returns a fresh+`versionRevision`, and each asset's hashes (`MD5`, `SHA-1`, `SHA-256`, `SHA-512`) are computed from+the bytes Floci actually received, not echoed from the request. Floci enforces AWS's own published+quotas for this action: a 5 GB max asset file size and a 350-asset cap per package version, both+returning `ServiceQuotaExceededException`.+## AWS-compatible failuresDomain and repository names, tags, pagination, duplicate names, missing upstreams, policy-revision@@ -71,6 +85,16 @@ state.that is not the caller's own account looks up that account's domain/repository with notrust-policy or permissions-policy enforcement, consistent with Floci's IAM enforcement beingopt-in elsewhere, but worth knowing if you rely on domain-sharing semantics.+- **Package management beyond publish/describe/get-asset isn't implemented.** `ListPackages`,+ `ListPackageVersions`, `ListPackageVersionAssets`, `DeletePackageVersions`,+ `DisposePackageVersions`, and `UpdatePackageVersionsStatus` don't exist yet; the only way to+ move a version from `Unfinished` to `Published` today is a follow-up `PublishPackageVersion`+ call that omits the `unfinished` flag.+- **The 5 GB asset size quota is nominal.** `PublishPackageVersion` receives the request body as+ a single byte array before Floci ever checks its length, so a request already large enough to+ exhaust available heap fails before the quota check runs. The `ServiceQuotaExceededException`+ behavior is correct for anything that does fit in memory; it is not itself a streaming size+ limit.See the [CodeArtifact API Reference](https://docs.aws.amazon.com/codeartifact/latest/APIReference/Welcome.html).diff --git a/docs/services/index.md b/docs/services/index.mdindex 95e2ed4a91..5be2607342 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -118,7 +118,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/tag*` | REST JSON | 22 |+| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package/version*`, `/v1/tag*` | REST JSON | 25 || [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/services/codeartifact/CodeArtifactController.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.javaindex 204457d4f3..eba721b01f 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@@ -11,13 +11,18 @@ import io.github.hectorvent.floci.core.common.PaginatedResult;import io.github.hectorvent.floci.core.common.Pagination;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.DomainView;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.PackageVersionAssetResult;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.PublishPackageVersionResult;import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.ResourcePolicy;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactPackageVersion;import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactRepository;import io.github.hectorvent.floci.services.codeartifact.model.ExternalConnection;+import io.github.hectorvent.floci.services.codeartifact.model.PackageAsset;import jakarta.inject.Inject;import jakarta.ws.rs.Consumes;import jakarta.ws.rs.DELETE;import jakarta.ws.rs.GET;+import jakarta.ws.rs.HeaderParam;import jakarta.ws.rs.POST;import jakarta.ws.rs.PUT;import jakarta.ws.rs.Path;@@ -272,6 +277,64 @@ public class CodeArtifactController {return ok(single("repository", repositoryDescription(r)));}+ // ------------------------------------------------------- package versions++ @POST+ @Path("/v1/package/version/publish")+ @Consumes(MediaType.WILDCARD)+ public Response publishPackageVersion(@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,+ @QueryParam("version") String version,+ @QueryParam("asset") String assetName,+ @QueryParam("unfinished") String unfinished,+ @HeaderParam("x-amz-content-sha256") String assetSha256,+ byte[] body) {+ String region = regionResolver.resolveRegion(headers);+ PublishPackageVersionResult result = service.publishPackageVersion(region, domain, domainOwner, repository,+ format, namespace, packageName, version, assetName, assetSha256, unfinished, body);+ return ok(publishPackageVersionResponse(result));+ }++ @GET+ @Path("/v1/package/version")+ public Response describePackageVersion(@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,+ @QueryParam("version") String version) {+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactPackageVersion pv = service.describePackageVersion(region, domain, domainOwner, repository,+ format, namespace, packageName, version);+ return ok(single("packageVersion", packageVersionDescription(pv)));+ }++ @GET+ @Path("/v1/package/version/asset")+ public Response getPackageVersionAsset(@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,+ @QueryParam("version") String version,+ @QueryParam("asset") String assetName,+ @QueryParam("revision") String revision) {+ String region = regionResolver.resolveRegion(headers);+ PackageVersionAssetResult result = service.getPackageVersionAsset(region, domain, domainOwner, repository,+ format, namespace, packageName, version, assetName, revision);+ return Response.ok(result.asset().getContent(), MediaType.APPLICATION_OCTET_STREAM)+ .header("X-AssetName", result.asset().getName())+ .header("X-PackageVersion", version)+ .header("X-PackageVersionRevision", result.packageVersionRevision())+ .build();+ }+// -------------------------------------------------------------------- tags@POST@@ -377,6 +440,48 @@ public class CodeArtifactController {return response;}+ private ObjectNode publishPackageVersionResponse(PublishPackageVersionResult result) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("format", result.packageVersion().getFormat());+ if (result.packageVersion().getNamespace() != null) {+ node.put("namespace", result.packageVersion().getNamespace());+ }+ node.put("package", result.packageVersion().getPackageName());+ node.put("version", result.packageVersion().getVersion());+ node.put("versionRevision", result.packageVersion().getRevision());+ node.put("status", result.packageVersion().getStatus());+ node.set("asset", assetSummary(result.asset()));+ return node;+ }++ private ObjectNode packageVersionDescription(CodeArtifactPackageVersion pv) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("format", pv.getFormat());+ if (pv.getNamespace() != null) {+ node.put("namespace", pv.getNamespace());+ }+ node.put("packageName", pv.getPackageName());+ node.put("version", pv.getVersion());+ node.put("revision", pv.getRevision());+ node.put("status", pv.getStatus());+ if (pv.getPublishedTime() != null) {+ node.put("publishedTime", pv.getPublishedTime());+ }+ ObjectNode origin = node.putObject("origin");+ origin.put("originType", "INTERNAL");+ node.putArray("licenses");+ return node;+ }++ private ObjectNode assetSummary(PackageAsset asset) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("name", asset.getName());+ node.put("size", asset.getSize());+ ObjectNode hashes = node.putObject("hashes");+ asset.getHashes().forEach(hashes::put);+ return node;+ }+private ObjectNode resourcePolicy(ResourcePolicy policy) {ObjectNode node = objectMapper.createObjectNode();node.put("resourceArn", policy.resourceArn());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 9887efa1bf..56c86b68de 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@@ -8,23 +8,40 @@ import io.github.hectorvent.floci.core.common.PaginatedResult;import io.github.hectorvent.floci.core.common.Pagination;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.Resettable;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import io.github.hectorvent.floci.core.common.auth.SigV4RequestValidator;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactDomain;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactPackageVersion;import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactRepository;import io.github.hectorvent.floci.services.codeartifact.model.ExternalConnection;+import io.github.hectorvent.floci.services.codeartifact.model.PackageAsset;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;-+import org.jboss.logging.Logger;++import java.io.IOException;+import java.io.UncheckedIOException;+import java.nio.charset.StandardCharsets;+import java.nio.file.AtomicMoveNotSupportedException;+import java.nio.file.Files;+import java.nio.file.Path;+import java.nio.file.StandardCopyOption;+import java.security.MessageDigest;+import java.security.NoSuchAlgorithmException;import java.time.Instant;import java.util.ArrayList;+import java.util.Comparator;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Optional;import java.util.Set;import java.util.UUID;+import java.util.concurrent.ConcurrentHashMap;import java.util.regex.Pattern;+import java.util.stream.Stream;@ApplicationScopedpublic class CodeArtifactService implements Resettable {@@ -46,26 +63,73 @@ public class CodeArtifactService implements Resettable {Set.of("npm", "pypi", "maven", "nuget", "generic", "ruby", "swift", "cargo");private static final Set<String> ENDPOINT_TYPES = Set.of("dualstack", "ipv4");+ private static final Logger LOG = Logger.getLogger(CodeArtifactService.class);+private static final Pattern DOMAIN_NAME = Pattern.compile("[a-z][a-z0-9\\-]{0,48}[a-z0-9]");private static final Pattern REPOSITORY_NAME = Pattern.compile("[A-Za-z0-9][A-Za-z0-9._\\-]{1,99}");private static final Pattern ACCOUNT_ID = Pattern.compile("[0-9]{12}");+ private static final Pattern PACKAGE_TOKEN = Pattern.compile("[^#/\\s]+");+ // Matches the wire model's AssetName pattern exactly: any non-empty string with no+ // control/format/unassigned/surrogate/private-use characters. Without this, an asset name+ // containing '\r'/'\n' would be echoed back verbatim in the X-AssetName response header.+ private static final Pattern ASSET_NAME = Pattern.compile("\\P{C}+");+ private static final List<String> ASSET_HASH_ALGORITHMS = List.of("MD5", "SHA-1", "SHA-256", "SHA-512");+ private static final long MAX_ASSET_FILE_SIZE_BYTES = 5L * 1024 * 1024 * 1024;+ private static final int MAX_ASSETS_PER_PACKAGE_VERSION = 350;+ private static final String ASSET_STORAGE_DIR = "codeartifact-assets";public record DomainView(CodeArtifactDomain domain, int repositoryCount) {}public record ResourcePolicy(String resourceArn, String revision, String document) {}+ public record PublishPackageVersionResult(CodeArtifactPackageVersion packageVersion, PackageAsset asset) {}+ public record PackageVersionAssetResult(PackageAsset asset, String packageVersionRevision) {}private final AccountAwareStorageBackend<CodeArtifactDomain> domains;private final AccountAwareStorageBackend<CodeArtifactRepository> repositories;+ private final AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersions;private final RegionResolver regionResolver;private final EmulatorConfig config;+ // Asset bytes never go through the JSON/WAL-backed `packageVersions` store (see PackageAsset's+ // @JsonIgnore content field): they're kept here instead, on disk in persistent/hybrid/wal mode+ // or in this map in memory mode, so a publish only ever rewrites metadata.+ private final boolean inMemory;+ private final Path assetRoot;+ private final ConcurrentHashMap<String, byte[]> memoryAssetStore = new ConcurrentHashMap<>();@Inject- public CodeArtifactService(StorageFactory storageFactory, RegionResolver regionResolver, EmulatorConfig config) {- this.domains = storageFactory.create("codeartifact", "codeartifact-domains.json",- new TypeReference<Map<String, CodeArtifactDomain>>() {});- this.repositories = storageFactory.create("codeartifact", "codeartifact-repositories.json",- new TypeReference<Map<String, CodeArtifactRepository>>() {});+ public CodeArtifactService(StorageFactory storageFactory, RegionResolver regionResolver, EmulatorConfig config,+ ServiceConfigAccess serviceConfigAccess) {+ this(+ storageFactory.create("codeartifact", "codeartifact-domains.json",+ new TypeReference<Map<String, CodeArtifactDomain>>() {}),+ storageFactory.create("codeartifact", "codeartifact-repositories.json",+ new TypeReference<Map<String, CodeArtifactRepository>>() {}),+ storageFactory.create("codeartifact", "codeartifact-package-versions.json",+ new TypeReference<Map<String, CodeArtifactPackageVersion>>() {}),+ regionResolver, config,+ "memory".equals(serviceConfigAccess.storageMode("codeartifact")),+ Path.of(config.storage().persistentPath()).resolve(ASSET_STORAGE_DIR));+ }++ /** Package-private constructor for testing. */+ CodeArtifactService(AccountAwareStorageBackend<CodeArtifactDomain> domains,+ AccountAwareStorageBackend<CodeArtifactRepository> repositories,+ AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersions,+ RegionResolver regionResolver, EmulatorConfig config,+ boolean inMemory, Path assetRoot) {+ this.domains = domains;+ this.repositories = repositories;+ this.packageVersions = packageVersions;this.regionResolver = regionResolver;this.config = config;+ this.inMemory = inMemory;+ this.assetRoot = assetRoot;+ if (!inMemory) {+ try {+ Files.createDirectories(assetRoot);+ } catch (IOException e) {+ throw new UncheckedIOException("Failed to create CodeArtifact asset data directory: " + assetRoot, e);+ }+ }}// ---------------------------------------------------------------- domains@@ -350,6 +414,120 @@ public class CodeArtifactService implements Resettable {return r;}+ // ------------------------------------------------------- package versions++ public synchronized PublishPackageVersionResult publishPackageVersion(String region, String domain,+ String domainOwner, String repository, String format, String namespace, String packageName,+ String version, String assetName, String assetSha256, String unfinishedParam, byte[] content) {+ if (!"generic".equals(format)) {+ throw validation("format must be 'generic'; PublishPackageVersion only supports the generic "+ + "package format.");+ }+ boolean unfinished = parseBoolean(unfinishedParam);+ validatePackageToken("package", packageName);+ validatePackageToken("packageVersion", version);+ if (namespace != null) {+ validatePackageToken("namespace", namespace);+ }+ validateAssetName(assetName);+ if (assetSha256 == null || !SigV4RequestValidator.isSha256Hex(assetSha256)) {+ throw validation("assetSHA256 is required and must be a 64-character SHA-256 hex digest.");+ }+ byte[] assetContent = content != null ? content : new byte[0];+ if (assetContent.length > MAX_ASSET_FILE_SIZE_BYTES) {+ throw new AwsException("ServiceQuotaExceededException",+ "The maximum asset file size is 5 Gigabytes.", 402);+ }+ String actualSha256 = sha256Hex(assetContent);+ if (!assetSha256.equalsIgnoreCase(actualSha256)) {+ throw validation("assetSHA256 does not match the SHA-256 hash of the uploaded content.");+ }++ String owner = effectiveOwner(domainOwner);+ requireRepository(owner, repositoryKey(region, domain, repository));+ String key = packageVersionKey(region, domain, repository, format, namespace, packageName, version);++ CodeArtifactPackageVersion pv = packageVersions.getForAccount(owner, key).orElse(null);+ if (pv != null && "Published".equals(pv.getStatus())) {+ throw conflict("Package version '" + version + "' of package '" + packageName + "' is already "+ + "Published; no additional assets can be uploaded to it.");+ }+ if (pv == null) {+ pv = new CodeArtifactPackageVersion();+ pv.setDomainName(domain);+ pv.setDomainOwner(owner);+ pv.setRegion(region);+ pv.setRepositoryName(repository);+ pv.setFormat(format);+ pv.setNamespace(namespace);+ pv.setPackageName(packageName);+ pv.setVersion(version);+ }++ Map<String, PackageAsset> assets = new LinkedHashMap<>(pv.getAssets());+ if (!assets.containsKey(assetName) && assets.size() >= MAX_ASSETS_PER_PACKAGE_VERSION) {+ throw new AwsException("ServiceQuotaExceededException",+ "A package version can have a maximum of " + MAX_ASSETS_PER_PACKAGE_VERSION + " assets.", 402);+ }++ PackageAsset asset = new PackageAsset();+ asset.setName(assetName);+ asset.setSize(assetContent.length);+ asset.setContent(assetContent);+ asset.setHashes(computeHashes(assetContent));+ writeAssetContent(owner, key, assetName, assetContent);+ assets.put(assetName, asset);+ pv.setAssets(assets);++ pv.setStatus(unfinished ? "Unfinished" : "Published");+ if (!unfinished && pv.getPublishedTime() == null) {+ pv.setPublishedTime(Instant.now().getEpochSecond());+ }+ pv.setRevision(newRevision());++ packageVersions.putForAccount(owner, key, pv);+ return new PublishPackageVersionResult(pv, asset);+ }++ public CodeArtifactPackageVersion describePackageVersion(String region, String domain, String domainOwner,+ String repository, String format, String namespace, String packageName, String version) {+ if (format == null || !PACKAGE_FORMATS.contains(format)) {+ throw validation("format must be one of " + PACKAGE_FORMATS + ".");+ }+ String owner = effectiveOwner(domainOwner);+ String key = packageVersionKey(region, domain, repository, format, namespace, packageName, version);+ return packageVersions.getForAccount(owner, key)+ .orElseThrow(() -> notFound("Package version '" + version + "' of package '" + packageName+ + "' was not found."));+ }++ public PackageVersionAssetResult getPackageVersionAsset(String region, String domain, String domainOwner,+ String repository, String format, String namespace, String packageName, String version,+ String assetName, String packageVersionRevision) {+ if (format == null || !PACKAGE_FORMATS.contains(format)) {+ throw validation("format must be one of " + PACKAGE_FORMATS + ".");+ }+ String owner = effectiveOwner(domainOwner);+ String key = packageVersionKey(region, domain, repository, format, namespace, packageName, version);+ CodeArtifactPackageVersion pv = packageVersions.getForAccount(owner, key)+ .orElseThrow(() -> notFound("Package version '" + version + "' of package '" + packageName+ + "' was not found."));+ if (packageVersionRevision != null && !packageVersionRevision.equals(pv.getRevision())) {+ throw notFound("Package version '" + version + "' was not found at revision '"+ + packageVersionRevision + "'.");+ }+ PackageAsset asset = pv.getAssets().get(assetName);+ if (asset == null) {+ throw notFound("Asset '" + assetName + "' was not found on package version '" + version + "'.");+ }+ // The live object's content may already be populated (same JVM as the publish that set+ // it), but it isn't guaranteed to be: a reload from the persisted store never restores it,+ // since it's excluded from that JSON/WAL. Always re-read from the asset store itself+ // rather than trusting whatever happens to already be on the object.+ asset.setContent(readAssetContent(owner, key, assetName));+ return new PackageVersionAssetResult(asset, pv.getRevision());+ }+// -------------------------------------------------------------------- tagspublic synchronized void tagResource(String resourceArn, Map<String, String> newTags) {@@ -398,6 +576,12 @@ public class CodeArtifactService implements Resettable {public void clear() {domains.clear();repositories.clear();+ packageVersions.clear();+ if (inMemory) {+ memoryAssetStore.clear();+ } else {+ deleteAssetRoot();+ }}// ----------------------------------------------------------------- helpers@@ -522,6 +706,125 @@ public class CodeArtifactService implements Resettable {return merged;}+ private static void validatePackageToken(String field, String value) {+ if (value == null || value.isEmpty() || value.length() > 255 || !PACKAGE_TOKEN.matcher(value).matches()) {+ throw validation(field + " must be 1-255 characters with no '#', '/', or whitespace.");+ }+ }++ private static void validateAssetName(String assetName) {+ if (assetName == null || assetName.isEmpty() || assetName.length() > 255+ || !ASSET_NAME.matcher(assetName).matches()) {+ throw validation("asset must be 1-255 characters with no control characters.");+ }+ }++ // ----------------------------------------------------------- asset bytes++ private void writeAssetContent(String owner, String packageVersionKey, String assetName, byte[] content) {+ if (inMemory) {+ memoryAssetStore.put(assetStoreKey(owner, packageVersionKey, assetName), content);+ return;+ }+ Path filePath = resolveAssetPath(owner, packageVersionKey, assetName);+ try {+ Files.createDirectories(filePath.getParent());+ Path tmp = filePath.resolveSibling(filePath.getFileName() + ".tmp-" + UUID.randomUUID());+ try {+ Files.write(tmp, content);+ try {+ Files.move(tmp, filePath, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);+ } catch (AtomicMoveNotSupportedException e) {+ Files.move(tmp, filePath, StandardCopyOption.REPLACE_EXISTING);+ }+ } finally {+ Files.deleteIfExists(tmp);+ }+ } catch (IOException e) {+ throw new UncheckedIOException("Failed to write CodeArtifact asset file: " + filePath, e);+ }+ }++ private byte[] readAssetContent(String owner, String packageVersionKey, String assetName) {+ if (inMemory) {+ byte[] content = memoryAssetStore.get(assetStoreKey(owner, packageVersionKey, assetName));+ return content != null ? content : new byte[0];+ }+ Path filePath = resolveAssetPath(owner, packageVersionKey, assetName);+ try {+ return Files.readAllBytes(filePath);+ } catch (IOException e) {+ throw new UncheckedIOException("Failed to read CodeArtifact asset file: " + filePath, e);+ }+ }++ private static String assetStoreKey(String owner, String packageVersionKey, String assetName) {+ return owner + "::" + packageVersionKey + "::" + assetName;+ }++ /**+ * Both path segments are SHA-256 hex digests, never the raw names: an asset name may contain+ * '/', '.', '..' or run long, and the version key can exceed a filesystem's filename limit, so+ * using either directly would let distinct legal names collide or fail. Digests are fixed+ * length, path-safe, and cannot escape the directory.+ */+ private Path resolveAssetPath(String owner, String packageVersionKey, String assetName) {+ return assetRoot.resolve(owner)+ .resolve(sha256Hex(packageVersionKey.getBytes(StandardCharsets.UTF_8)))+ .resolve(sha256Hex(assetName.getBytes(StandardCharsets.UTF_8)));+ }++ private void deleteAssetRoot() {+ if (!Files.isDirectory(assetRoot)) {+ return;+ }+ try (Stream<Path> paths = Files.walk(assetRoot)) {+ paths.sorted(Comparator.reverseOrder()).forEach(p -> {+ try {+ Files.deleteIfExists(p);+ } catch (IOException e) {+ LOG.errorv(e, "Failed to delete CodeArtifact asset file: {0}", p);+ }+ });+ } catch (IOException e) {+ LOG.errorv(e, "Failed to reset CodeArtifact asset storage under {0}", assetRoot);+ }+ }++ private static boolean parseBoolean(String value) {+ if (value == null || value.isBlank()) {+ return false;+ }+ if ("true".equalsIgnoreCase(value) || "false".equalsIgnoreCase(value)) {+ return Boolean.parseBoolean(value);+ }+ throw validation("unfinished must be 'true' or 'false'.");+ }++ private static Map<String, String> computeHashes(byte[] content) {+ Map<String, String> hashes = new LinkedHashMap<>();+ for (String algorithm : ASSET_HASH_ALGORITHMS) {+ hashes.put(algorithm, SigV4RequestValidator.hexEncode(digest(algorithm, content)));+ }+ return hashes;+ }++ private static String sha256Hex(byte[] content) {+ try {+ return SigV4RequestValidator.sha256Hex(content);+ } catch (Exception e) {+ throw new IllegalStateException("JVM does not support SHA-256", e);+ }+ }++ private static byte[] digest(String algorithm, byte[] content) {+ try {+ return MessageDigest.getInstance(algorithm).digest(content);+ } catch (NoSuchAlgorithmException e) {+ throw new IllegalStateException("JVM does not support " + algorithm, e);+ }+ }+private static String domainKey(String region, String domain) {return region + "::" + domain;}@@ -530,6 +833,12 @@ public class CodeArtifactService implements Resettable {return region + "::" + domain + "::" + repository;}+ private static String packageVersionKey(String region, String domain, String repository, String format,+ String namespace, String packageName, String version) {+ return region + "::" + domain + "::" + repository + "::" + format + "::"+ + (namespace == null ? "" : namespace) + "::" + packageName + "::" + version;+ }+private static AwsException validation(String message) {return new AwsException("ValidationException", message, 400);}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactPackageVersion.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactPackageVersion.javanew file mode 100644index 0000000000..5dd005df57--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactPackageVersion.java@@ -0,0 +1,121 @@+package io.github.hectorvent.floci.services.codeartifact.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.Collections;+import java.util.LinkedHashMap;+import java.util.Map;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class CodeArtifactPackageVersion {+ private String domainName;+ private String domainOwner;+ private String region;+ private String repositoryName;+ private String format;+ private String namespace;+ private String packageName;+ private String version;+ private String status;+ private String revision;+ private Long publishedTime;+ private Map<String, PackageAsset> assets = new LinkedHashMap<>();++ public String getDomainName() {+ return domainName;+ }++ public void setDomainName(String domainName) {+ this.domainName = domainName;+ }++ public String getDomainOwner() {+ return domainOwner;+ }++ public void setDomainOwner(String domainOwner) {+ this.domainOwner = domainOwner;+ }++ public String getRegion() {+ return region;+ }++ public void setRegion(String region) {+ this.region = region;+ }++ public String getRepositoryName() {+ return repositoryName;+ }++ public void setRepositoryName(String repositoryName) {+ this.repositoryName = repositoryName;+ }++ public String getFormat() {+ return format;+ }++ public void setFormat(String format) {+ this.format = format;+ }++ public String getNamespace() {+ return namespace;+ }++ public void setNamespace(String namespace) {+ this.namespace = namespace;+ }++ public String getPackageName() {+ return packageName;+ }++ public void setPackageName(String packageName) {+ this.packageName = packageName;+ }++ public String getVersion() {+ return version;+ }++ public void setVersion(String version) {+ this.version = version;+ }++ public String getStatus() {+ return status;+ }++ public void setStatus(String status) {+ this.status = status;+ }++ public String getRevision() {+ return revision;+ }++ public void setRevision(String revision) {+ this.revision = revision;+ }++ public Long getPublishedTime() {+ return publishedTime;+ }++ public void setPublishedTime(Long publishedTime) {+ this.publishedTime = publishedTime;+ }++ public Map<String, PackageAsset> getAssets() {+ return Collections.unmodifiableMap(assets);+ }++ public void setAssets(Map<String, PackageAsset> assets) {+ this.assets = assets == null ? new LinkedHashMap<>() : new LinkedHashMap<>(assets);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/PackageAsset.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/PackageAsset.javanew file mode 100644index 0000000000..28c6b85727--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/PackageAsset.java@@ -0,0 +1,55 @@+package io.github.hectorvent.floci.services.codeartifact.model;++import com.fasterxml.jackson.annotation.JsonIgnore;+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.Collections;+import java.util.LinkedHashMap;+import java.util.Map;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class PackageAsset {+ private String name;+ private long size;+ // Kept out of the persisted package-version JSON/WAL: CodeArtifactService writes and reads+ // these bytes through its own asset store (disk file in persistent/hybrid/wal mode, a side+ // map in memory mode) instead, so a publish never rewrites every asset of every package+ // version just to append one more.+ @JsonIgnore+ private byte[] content = new byte[0];+ private Map<String, String> hashes = new LinkedHashMap<>();++ public String getName() {+ return name;+ }++ public void setName(String name) {+ this.name = name;+ }++ public long getSize() {+ return size;+ }++ public void setSize(long size) {+ this.size = size;+ }++ public byte[] getContent() {+ return content.clone();+ }++ public void setContent(byte[] content) {+ this.content = content == null ? new byte[0] : content.clone();+ }++ public Map<String, String> getHashes() {+ return Collections.unmodifiableMap(hashes);+ }++ public void setHashes(Map<String, String> hashes) {+ this.hashes = hashes == null ? new LinkedHashMap<>() : new LinkedHashMap<>(hashes);+ }+}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.javanew file mode 100644index 0000000000..aabd7c252e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java@@ -0,0 +1,130 @@+package io.github.hectorvent.floci.services.codeartifact;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.PersistentStorage;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.PackageVersionAssetResult;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.PublishPackageVersionResult;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactDomain;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactPackageVersion;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactRepository;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.nio.file.Files;+import java.nio.file.Path;+import java.util.Base64;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * Asset bytes must not ride along in the JSON-backed {@code codeartifact-package-versions.json}+ * store: that file is rewritten whole on every publish, so embedding a growing set of assets+ * there would make every later publish pay to re-serialize every earlier one. This exercises+ * {@link CodeArtifactService} against a real {@link PersistentStorage}, the same backend+ * {@code persistent} storage mode uses in production.+ */+class CodeArtifactAssetPersistenceTest {++ private static final String REGION = "us-east-1";+ private static final String ACCOUNT_ID = "123456789012";++ @Test+ void assetBytesAreNotEmbeddedInThePersistedPackageVersionJson(@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[] content = "hello world, this is the asset payload".getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", null, "my-pkg", "1.0.0", "a.txt",+ sha256Hex(content), "false", content);++ String json = Files.readString(dir.resolve("codeartifact-package-versions.json"));+ String base64Content = Base64.getEncoder().encodeToString(content);+ assertFalse(json.contains(base64Content),+ "persisted package-version JSON must not embed asset bytes: " + json);+ }++ @Test+ void assetContentSurvivesRestart(@TempDir Path dir) {+ CodeArtifactService first = newService(dir);+ first.createDomain(REGION, "dom", null, Map.of());+ first.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "hello world".getBytes(StandardCharsets.UTF_8);+ PublishPackageVersionResult published = first.publishPackageVersion(REGION, "dom", null, "repo", "generic",+ null, "my-pkg", "1.0.0", "a.txt", sha256Hex(content), "false", content);++ CodeArtifactService restarted = newService(dir);+ PackageVersionAssetResult result = restarted.getPackageVersionAsset(REGION, "dom", null, "repo", "generic",+ null, "my-pkg", "1.0.0", "a.txt", null);++ assertEquals("hello world", new String(result.asset().getContent(), StandardCharsets.UTF_8));+ assertEquals(published.packageVersion().getRevision(), result.packageVersionRevision());+ }++ @Test+ void distinctAssetNamesNeverCollideOnDisk(@TempDir Path dir) {+ CodeArtifactService service = newService(dir);+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ String longToken = "p".repeat(255);+ List<String> names = List.of("b", "x/../b", ".", "..", "b/c", "/b", "b/");+ for (String name : names) {+ byte[] content = ("content of " + name).getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", longToken, longToken, longToken,+ name, sha256Hex(content), "true", content);+ }++ CodeArtifactService restarted = newService(dir);+ for (String name : names) {+ PackageVersionAssetResult result = restarted.getPackageVersionAsset(REGION, "dom", null, "repo",+ "generic", longToken, longToken, longToken, name, null);+ assertEquals("content of " + name, new String(result.asset().getContent(), StandardCharsets.UTF_8));+ }+ }++ private CodeArtifactService newService(Path dir) {+ AccountAwareStorageBackend<CodeArtifactDomain> domainStore = accountAware(dir, "codeartifact-domains.json",+ new TypeReference<Map<String, CodeArtifactDomain>>() {});+ AccountAwareStorageBackend<CodeArtifactRepository> repoStore = accountAware(dir,+ "codeartifact-repositories.json", new TypeReference<Map<String, CodeArtifactRepository>>() {});+ AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersionStore = accountAware(dir,+ "codeartifact-package-versions.json", new TypeReference<Map<String, CodeArtifactPackageVersion>>() {});++ RegionResolver regionResolver = mock(RegionResolver.class);+ when(regionResolver.getAccountId()).thenReturn(ACCOUNT_ID);+ when(regionResolver.buildArn(anyString(), anyString(), anyString())).thenAnswer(invocation ->+ "arn:aws:" + invocation.getArgument(0, String.class) + ":" + invocation.getArgument(1, String.class)+ + ":" + ACCOUNT_ID + ":" + invocation.getArgument(2, String.class));++ EmulatorConfig config = mock(EmulatorConfig.class);+ when(config.effectiveBaseUrl()).thenReturn("http://localhost:4566");++ return new CodeArtifactService(domainStore, repoStore, packageVersionStore, regionResolver, config,+ false, dir.resolve("codeartifact-assets"));+ }++ private <V> AccountAwareStorageBackend<V> accountAware(Path dir, String fileName, TypeReference<Map<String, V>> type) {+ PersistentStorage<String, V> backend = new PersistentStorage<>(dir.resolve(fileName), type);+ backend.load();+ return new AccountAwareStorageBackend<>(backend, null, ACCOUNT_ID);+ }++ private static String sha256Hex(byte[] content) {+ try {+ return io.github.hectorvent.floci.core.common.auth.SigV4RequestValidator.sha256Hex(content);+ } catch (Exception e) {+ throw new IllegalStateException(e);+ }+ }+}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 ea3d82ffbc..5977cc2128 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@@ -1,15 +1,19 @@package io.github.hectorvent.floci.services.codeartifact;+import io.github.hectorvent.floci.core.common.auth.SigV4RequestValidator;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.junit.QuarkusTest;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;+import java.nio.charset.StandardCharsets;+import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.emptyIterable;import static org.hamcrest.Matchers.equalTo;import static org.hamcrest.Matchers.hasSize;import static org.hamcrest.Matchers.notNullValue;+import static org.junit.jupiter.api.Assertions.assertArrayEquals;@QuarkusTestclass CodeArtifactIntegrationTest {@@ -129,4 +133,77 @@ class CodeArtifactIntegrationTest {.body("{}").post("/v1/domain?domain=NOT-VALID").then().statusCode(400).body("__type", equalTo("ValidationException"));}++ @Test+ void publishDescribeAndGetPackageVersionAssetRoundTripExactBytes() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=pkg-domain").then().statusCode(200);+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/repository?domain=pkg-domain&repository=pkg-repo").then().statusCode(200);++ byte[] content = "hello codeartifact".getBytes(StandardCharsets.UTF_8);+ String sha256 = sha256Hex(content);++ given().header("Authorization", AUTH).header("x-amz-content-sha256", sha256)+ .contentType("application/octet-stream").body(content)+ .post("/v1/package/version/publish?domain=pkg-domain&repository=pkg-repo&format=generic"+ + "&package=my-pkg&version=1.0.0&asset=asset.txt")+ .then().statusCode(200)+ .body("status", equalTo("Published"))+ .body("versionRevision", notNullValue())+ .body("asset.name", equalTo("asset.txt"))+ .body("asset.size", equalTo(content.length))+ .body("asset.hashes.'SHA-256'", equalTo(sha256));++ given().header("Authorization", AUTH)+ .get("/v1/package/version?domain=pkg-domain&repository=pkg-repo&format=generic"+ + "&package=my-pkg&version=1.0.0")+ .then().statusCode(200)+ .body("packageVersion.status", equalTo("Published"))+ .body("packageVersion.origin.originType", equalTo("INTERNAL"));++ byte[] downloaded = given().header("Authorization", AUTH)+ .get("/v1/package/version/asset?domain=pkg-domain&repository=pkg-repo&format=generic"+ + "&package=my-pkg&version=1.0.0&asset=asset.txt")+ .then().statusCode(200)+ .header("X-AssetName", equalTo("asset.txt"))+ .extract().asByteArray();+ assertArrayEquals(content, downloaded);++ given().header("Authorization", AUTH).header("x-amz-content-sha256", sha256)+ .contentType("application/octet-stream").body(content)+ .post("/v1/package/version/publish?domain=pkg-domain&repository=pkg-repo&format=generic"+ + "&package=my-pkg&version=1.0.0&asset=another.txt")+ .then().statusCode(409).body("__type", equalTo("ConflictException"));+ }++ @Test+ void unfinishedPublishKeepsVersionOpenForMoreAssets() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=unfinished-domain").then().statusCode(200);+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/repository?domain=unfinished-domain&repository=repo").then().statusCode(200);++ byte[] content = "partial".getBytes(StandardCharsets.UTF_8);+ String sha256 = sha256Hex(content);++ given().header("Authorization", AUTH).header("x-amz-content-sha256", sha256)+ .contentType("application/octet-stream").body(content)+ .post("/v1/package/version/publish?domain=unfinished-domain&repository=repo&format=generic"+ + "&package=my-pkg&version=1.0.0&asset=a.txt&unfinished=true")+ .then().statusCode(200).body("status", equalTo("Unfinished"));++ given().header("Authorization", AUTH)+ .get("/v1/package/version?domain=unfinished-domain&repository=repo&format=generic"+ + "&package=my-pkg&version=1.0.0")+ .then().statusCode(200).body("packageVersion.status", equalTo("Unfinished"));+ }++ private static String sha256Hex(byte[] content) {+ try {+ return SigV4RequestValidator.sha256Hex(content);+ } catch (Exception e) {+ throw new IllegalStateException(e);+ }+ }}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 cccce4072d..9c97414a22 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@@ -1,19 +1,22 @@package io.github.hectorvent.floci.services.codeartifact;-import com.fasterxml.jackson.core.type.TypeReference;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.PaginatedResult;import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.auth.SigV4RequestValidator;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;-import io.github.hectorvent.floci.core.storage.StorageFactory;import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.DomainView;import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.ResourcePolicy;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.PackageVersionAssetResult;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.PublishPackageVersionResult;import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactDomain;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactPackageVersion;import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactRepository;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import java.nio.charset.StandardCharsets;import java.util.ArrayList;import java.util.List;import java.util.Map;@@ -26,9 +29,7 @@ import java.util.concurrent.atomic.AtomicInteger;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;-import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;-import static org.mockito.ArgumentMatchers.eq;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.when;@@ -40,15 +41,11 @@ class CodeArtifactServiceTest {private CodeArtifactService service;@BeforeEach- @SuppressWarnings({"unchecked", "rawtypes"})void setUp() {- StorageFactory storageFactory = mock(StorageFactory.class);AccountAwareStorageBackend<CodeArtifactDomain> domainStore = AccountAwareStorageBackend.inMemory(ACCOUNT_ID);AccountAwareStorageBackend<CodeArtifactRepository> repoStore = AccountAwareStorageBackend.inMemory(ACCOUNT_ID);- when(storageFactory.create(eq("codeartifact"), eq("codeartifact-domains.json"), any(TypeReference.class)))- .thenReturn((AccountAwareStorageBackend) domainStore);- when(storageFactory.create(eq("codeartifact"), eq("codeartifact-repositories.json"), any(TypeReference.class)))- .thenReturn((AccountAwareStorageBackend) repoStore);+ AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersionStore =+ AccountAwareStorageBackend.inMemory(ACCOUNT_ID);RegionResolver regionResolver = mock(RegionResolver.class);when(regionResolver.getAccountId()).thenReturn(ACCOUNT_ID);@@ -59,7 +56,8 @@ class CodeArtifactServiceTest {EmulatorConfig config = mock(EmulatorConfig.class);when(config.effectiveBaseUrl()).thenReturn("http://localhost:4566");- service = new CodeArtifactService(storageFactory, regionResolver, config);+ service = new CodeArtifactService(domainStore, repoStore, packageVersionStore, regionResolver, config,+ true, null);}// -------------------------------------------------------------- domains@@ -352,4 +350,236 @@ class CodeArtifactServiceTest {() -> service.describeRepository(REGION, "dom", null, "repo"));assertEquals("ResourceNotFoundException", e.getErrorCode());}++ // -------------------------------------------------------- package versions++ @Test+ void publishPackageVersionComputesRealHashesAndPublishesByDefault() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "hello world".getBytes(StandardCharsets.UTF_8);+ String sha256 = sha256Hex(content);++ PublishPackageVersionResult result = service.publishPackageVersion(REGION, "dom", null, "repo", "generic",+ "my-ns", "my-pkg", "1.0.0", "asset.txt", sha256, "false", content);++ assertEquals("Published", result.packageVersion().getStatus());+ assertEquals("asset.txt", result.asset().getName());+ assertEquals(content.length, result.asset().getSize());+ assertEquals(sha256, result.asset().getHashes().get("SHA-256"));+ assertTrue(result.asset().getHashes().containsKey("MD5"));+ assertTrue(result.asset().getHashes().containsKey("SHA-1"));+ assertTrue(result.asset().getHashes().containsKey("SHA-512"));+ }++ @Test+ void publishPackageVersionRejectsMismatchedSha256() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "hello world".getBytes(StandardCharsets.UTF_8);++ AwsException e = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom", null,+ "repo", "generic", null, "my-pkg", "1.0.0", "asset.txt", "0".repeat(64), "false", content));+ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void publishPackageVersionRequiresAssetSha256() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "hello world".getBytes(StandardCharsets.UTF_8);++ AwsException missing = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom",+ null, "repo", "generic", null, "my-pkg", "1.0.0", "asset.txt", null, "false", content));+ assertEquals("ValidationException", missing.getErrorCode());++ AwsException malformed = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom",+ null, "repo", "generic", null, "my-pkg", "1.0.0", "asset.txt", "not-hex", "false", content));+ assertEquals("ValidationException", malformed.getErrorCode());+ }++ @Test+ void publishPackageVersionRejectsAssetNameWithControlCharacters() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "hello world".getBytes(StandardCharsets.UTF_8);+ String sha256 = sha256Hex(content);++ // A newline here would land verbatim in the X-AssetName response header on GetPackageVersionAsset.+ AwsException e = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom", null,+ "repo", "generic", null, "my-pkg", "1.0.0", "asset.txt\r\nX-Injected: true", sha256, "false",+ content));+ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void publishPackageVersionRejectsMalformedUnfinishedFlag() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "hello world".getBytes(StandardCharsets.UTF_8);++ AwsException e = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom", null,+ "repo", "generic", null, "my-pkg", "1.0.0", "asset.txt", sha256Hex(content), "yes", content));+ assertEquals("ValidationException", e.getErrorCode());++ PublishPackageVersionResult omitted = service.publishPackageVersion(REGION, "dom", null, "repo", "generic",+ null, "my-pkg", "1.0.0", "asset.txt", sha256Hex(content), null, content);+ assertEquals("Published", omitted.packageVersion().getStatus());+ }++ @Test+ void publishPackageVersionRejectsNonGenericFormat() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "x".getBytes(StandardCharsets.UTF_8);++ AwsException e = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom", null,+ "repo", "npm", null, "my-pkg", "1.0.0", "asset.txt", sha256Hex(content), "false", content));+ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void publishPackageVersionRequiresExistingRepository() {+ service.createDomain(REGION, "dom", null, Map.of());+ byte[] content = "x".getBytes(StandardCharsets.UTF_8);++ AwsException e = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom", null,+ "no-such-repo", "generic", null, "my-pkg", "1.0.0", "asset.txt", sha256Hex(content), "false", content));+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ }++ @Test+ void unfinishedPublishAllowsMultipleAssetsThenFinalizes() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] first = "first".getBytes(StandardCharsets.UTF_8);+ byte[] second = "second".getBytes(StandardCharsets.UTF_8);++ PublishPackageVersionResult r1 = service.publishPackageVersion(REGION, "dom", null, "repo", "generic", null,+ "my-pkg", "1.0.0", "a.txt", sha256Hex(first), "true", first);+ assertEquals("Unfinished", r1.packageVersion().getStatus());++ PublishPackageVersionResult r2 = service.publishPackageVersion(REGION, "dom", null, "repo", "generic", null,+ "my-pkg", "1.0.0", "b.txt", sha256Hex(second), "false", second);+ assertEquals("Published", r2.packageVersion().getStatus());+ assertEquals(2, r2.packageVersion().getAssets().size());+ assertTrue(r2.packageVersion().getAssets().containsKey("a.txt"));+ assertTrue(r2.packageVersion().getAssets().containsKey("b.txt"));+ }++ @Test+ void publishingToAnAlreadyPublishedVersionConflicts() {+ 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", null, "my-pkg", "1.0.0", "a.txt",+ sha256Hex(content), "false", content);++ AwsException e = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom", null,+ "repo", "generic", null, "my-pkg", "1.0.0", "b.txt", sha256Hex(content), "false", content));+ assertEquals("ConflictException", e.getErrorCode());+ }++ @Test+ void publishPackageVersionCapsAssetsPerVersionAtThreeHundredFifty() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ for (int i = 0; i < 350; i++) {+ byte[] content = ("content-" + i).getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", null, "my-pkg", "1.0.0",+ "asset-" + i + ".txt", sha256Hex(content), "true", content);+ }+ byte[] oneMore = "one-more".getBytes(StandardCharsets.UTF_8);+ AwsException e = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom", null,+ "repo", "generic", null, "my-pkg", "1.0.0", "asset-350.txt", sha256Hex(oneMore), "true", oneMore));+ assertEquals("ServiceQuotaExceededException", e.getErrorCode());++ // Re-publishing an asset name already on the version must not itself trip the cap.+ byte[] resend = "content-0".getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", null, "my-pkg", "1.0.0", "asset-0.txt",+ sha256Hex(resend), "true", resend);+ }++ @Test+ void describePackageVersionRoundTripsAndReportsNotFound() {+ 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);++ CodeArtifactPackageVersion pv = service.describePackageVersion(REGION, "dom", null, "repo", "generic", "ns",+ "my-pkg", "1.0.0");+ assertEquals("Published", pv.getStatus());+ assertEquals("ns", pv.getNamespace());++ AwsException e = assertThrows(AwsException.class, () -> service.describePackageVersion(REGION, "dom", null,+ "repo", "generic", "ns", "my-pkg", "2.0.0"));+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ }++ @Test+ void getPackageVersionAssetReturnsExactBytesAndValidatesRevision() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "hello world".getBytes(StandardCharsets.UTF_8);+ PublishPackageVersionResult published = service.publishPackageVersion(REGION, "dom", null, "repo", "generic",+ null, "my-pkg", "1.0.0", "a.txt", sha256Hex(content), "false", content);++ PackageVersionAssetResult result = service.getPackageVersionAsset(REGION, "dom", null, "repo", "generic",+ null, "my-pkg", "1.0.0", "a.txt", null);+ assertEquals(content.length, result.asset().getContent().length);+ assertEquals("hello world", new String(result.asset().getContent(), StandardCharsets.UTF_8));+ assertEquals(published.packageVersion().getRevision(), result.packageVersionRevision());++ AwsException wrongAsset = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION,+ "dom", null, "repo", "generic", null, "my-pkg", "1.0.0", "missing.txt", null));+ assertEquals("ResourceNotFoundException", wrongAsset.getErrorCode());++ AwsException wrongRevision = assertThrows(AwsException.class, () -> service.getPackageVersionAsset(REGION,+ "dom", null, "repo", "generic", null, "my-pkg", "1.0.0", "a.txt", "not-the-current-revision"));+ assertEquals("ResourceNotFoundException", wrongRevision.getErrorCode());+ }++ @Test+ void concurrentUnfinishedPublishesOfDifferentAssetsBothPersist() throws InterruptedException {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ int assetCount = 8;+ ExecutorService pool = Executors.newFixedThreadPool(assetCount);+ CountDownLatch ready = new CountDownLatch(assetCount);+ CountDownLatch go = new CountDownLatch(1);+ try {+ for (int i = 0; i < assetCount; i++) {+ int index = i;+ pool.submit(() -> {+ ready.countDown();+ try {+ go.await();+ byte[] content = ("content-" + index).getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", null, "my-pkg",+ "1.0.0", "asset-" + index + ".txt", sha256Hex(content), "true", content);+ } catch (InterruptedException ignored) {+ Thread.currentThread().interrupt();+ }+ });+ }+ ready.await(5, TimeUnit.SECONDS);+ go.countDown();+ } finally {+ pool.shutdown();+ assertTrue(pool.awaitTermination(10, TimeUnit.SECONDS));+ }+ CodeArtifactPackageVersion pv = service.describePackageVersion(REGION, "dom", null, "repo", "generic", null,+ "my-pkg", "1.0.0");+ assertEquals(assetCount, pv.getAssets().size());+ }++ private static String sha256Hex(byte[] content) {+ try {+ return SigV4RequestValidator.sha256Hex(content);+ } catch (Exception e) {+ throw new IllegalStateException(e);+ }+ }}