Light, fluffy, and always free - The AWS Local Emulator alternative
feat(codeartifact): add PutPackageOriginConfiguration (#5381)
Priamo Germosen3ff5529fadd6
diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.mdindex 80d0e05cf6..62eca7b5f6 100644--- a/docs/services/codeartifact.md+++ b/docs/services/codeartifact.md@@ -40,6 +40,7 @@ the remaining formats (NuGet, etc.) have no real proxy behind them yet.| `PublishPackageVersion` | Uploads a generic-format asset, creating or extending a package version; requires `x-amz-content-sha256` and verifies it against the real hash of the bytes received. || `DescribePackage` | Returns a package's format, namespace, name, and origin controls (`publish` and `upstream` restrictions). || `DeletePackage` | Deletes a package and every one of its versions; `ResourceNotFoundException` for one that does not exist. |+| `PutPackageOriginConfiguration` | Sets a package's `publish`/`upstream` origin-control restrictions; can create the package (with no versions) if it doesn't exist yet. || `DescribePackageVersion` | Returns a package version's status, revision, and origin. || `GetPackageVersionAsset` | Downloads one asset from a package version by name, optionally pinned to a specific revision. || `TagResource` | Adds or updates tags on a domain or repository ARN. |@@ -279,11 +280,20 @@ state.named file, and none of these sidecars expose that shape cheaply (Reposilite has no per-GAVmetadata beyond file listings; Verdaccio's own registry API could answer it for npm but Maven andpypi have nothing equivalent), so it remains unbridged and still 404s for these three formats.-- **`DescribePackage` origin controls are fixed.** Floci never ingests packages from an upstream- source and does not store origin controls, so every package reports `publish: ALLOW` and- `upstream: BLOCK`, the default for a package whose first version was published directly. For- Maven, npm, and pypi, `DescribePackage` asks the repository's sidecar whether the package exists,- which starts that sidecar if it is not already running.+- **`DescribePackage`'s origin controls default to `publish: ALLOW`/`upstream: BLOCK`** (the+ default for a package whose first version was published directly, since Floci never ingests+ packages from an upstream source) **until a caller sets them explicitly with+ `PutPackageOriginConfiguration`.** For Maven, npm, and pypi, `DescribePackage` asks the+ repository's sidecar whether the package exists, which starts that sidecar if it is not already+ running; a package that exists only because `PutPackageOriginConfiguration` created it (no+ versions yet) is found without touching any sidecar.+- **`PutPackageOriginConfiguration`'s `publish: BLOCK` is only enforced for the `generic`+ format.** `PublishPackageVersion`, the one path it actually gates, accepts only `generic` to+ begin with; Maven, npm, and pypi publishes go through their own native wire protocol (`mvn+ deploy`, `npm publish`, `twine upload`) directly against the repository endpoint, which does not+ yet check this setting. `upstream` is stored and reported faithfully for every format but is+ never enforced for any of them, since Floci has no upstream ingestion path to block in the first+ place.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 8a409d704b..e63c4382e1 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -121,7 +121,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [AWS Backup](backup.md) | `/backup-vaults/*`, `/backup/plans/*`, `/backup-jobs/*`, `/supported-resource-types` | REST JSON | 20 || [AWS FIS](fis.md) | `/experimentTemplates/*`, `/experiments/*`, `/actions/*`, `/targetResourceTypes/*`, `/safetyLevers/*`, `/tags/*` | REST JSON | 26 || [CodeGuru Reviewer](codegurureviewer.md) | `/associations`, `/associations/{associationArn}`, `/tags/*` | REST JSON | 7 |-| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package`, `/v1/package/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*`, `/codeartifact/npm/*`, `/codeartifact/pypi/*` | REST JSON | 28 |+| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/package`, `/v1/package/version*`, `/v1/tag*`, `/v1/authorization-token`, `/codeartifact/maven/*`, `/codeartifact/npm/*`, `/codeartifact/pypi/*` | REST JSON | 29 || [CloudFront](cloudfront.md) | `/2020-05-31/distribution/*`, `/2020-05-31/cache-policy/*`, `/2020-05-31/function/*` | REST XML | 50 || [Route53](route53.md) | `/2013-04-01/hostedzone/*`, `/2013-04-01/healthcheck/*`, `/2013-04-01/change/*` | REST XML | 27 || [Route 53 Resolver](route53resolver.md) | `POST /` + `X-Amz-Target: Route53Resolver.*` | JSON 1.1 | 18 |diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.javaindex 9ea8b5d5c5..155212318b 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@@ -356,6 +356,27 @@ public class CodeArtifactController {return ok(single("deletedPackage", deletedPackageDescription(deleted)));}+ @POST+ @Path("/v1/package")+ public Response putPackageOriginConfiguration(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository,+ @QueryParam("format") String format,+ @QueryParam("namespace") String namespace,+ @QueryParam("package") String packageName, String body) {+ JsonNode req = readTree(body);+ JsonNode restrictions = req.get("restrictions");+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactService.PackageDescription described = service.putPackageOriginConfiguration(region, domain,+ domainOwner, repository, format, namespace, packageName, text(restrictions, "publish"),+ text(restrictions, "upstream"));+ ObjectNode response = objectMapper.createObjectNode();+ ObjectNode restrictionsNode = response.putObject("originConfiguration").putObject("restrictions");+ restrictionsNode.put("publish", described.publishRestriction());+ restrictionsNode.put("upstream", described.upstreamRestriction());+ return ok(response);+ }+@GET@Path("/v1/package/version")public Response describePackageVersion(@Context HttpHeaders headers, @QueryParam("domain") String domain,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 2c8d9549fc..89bbadd986 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@@ -17,6 +17,7 @@ import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactPackagimport 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 io.github.hectorvent.floci.services.codeartifact.model.PackageOriginConfig;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;@@ -74,6 +75,7 @@ public class CodeArtifactService implements Resettable {* repositories created before that format's proxy existed.*/private static final List<String> CONTAINER_BACKED_FORMATS = List.of("maven", "npm", "pypi");+ private static final Set<String> ORIGIN_RESTRICTION_VALUES = Set.of("ALLOW", "BLOCK");private static final Logger LOG = Logger.getLogger(CodeArtifactService.class);@@ -109,6 +111,7 @@ public class CodeArtifactService implements Resettable {private final AccountAwareStorageBackend<CodeArtifactDomain> domains;private final AccountAwareStorageBackend<CodeArtifactRepository> repositories;private final AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersions;+ private final AccountAwareStorageBackend<PackageOriginConfig> packageOriginConfigs;private final RegionResolver regionResolver;private final EmulatorConfig config;private final CodeArtifactSidecarRegistry sidecarRegistry;@@ -132,6 +135,8 @@ public class CodeArtifactService implements Resettable {new TypeReference<Map<String, CodeArtifactRepository>>() {}),storageFactory.create("codeartifact", "codeartifact-package-versions.json",new TypeReference<Map<String, CodeArtifactPackageVersion>>() {}),+ storageFactory.create("codeartifact", "codeartifact-package-origin-configs.json",+ new TypeReference<Map<String, PackageOriginConfig>>() {}),regionResolver, config,"memory".equals(serviceConfigAccess.storageMode("codeartifact")),Path.of(config.storage().persistentPath()).resolve(ASSET_STORAGE_DIR),@@ -142,11 +147,13 @@ public class CodeArtifactService implements Resettable {CodeArtifactService(AccountAwareStorageBackend<CodeArtifactDomain> domains,AccountAwareStorageBackend<CodeArtifactRepository> repositories,AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersions,+ AccountAwareStorageBackend<PackageOriginConfig> packageOriginConfigs,RegionResolver regionResolver, EmulatorConfig config,boolean inMemory, Path assetRoot, CodeArtifactSidecarRegistry sidecarRegistry) {this.domains = domains;this.repositories = repositories;this.packageVersions = packageVersions;+ this.packageOriginConfigs = packageOriginConfigs;this.regionResolver = regionResolver;this.config = config;this.sidecarRegistry = sidecarRegistry;@@ -322,6 +329,16 @@ public class CodeArtifactService implements Resettable {// must not leave the repository stuck: a retry would just 404, since the record above is// already gone.releaseSidecarStorage(r, domain, repository);+ // packageOriginConfigs is keyed by name (region/domain/repository/format/namespace/package),+ // unlike sidecarContainerIds, which createRepository deliberately assigns a fresh id for on+ // every creation so a repository recreated under the same name never inherits the previous+ // one's sidecar content. Without this, the same recreated-under-the-same-name repository+ // would still inherit any package's stored publish/upstream restrictions, including a+ // publish:BLOCK that would reject a publish with no way for the caller to know why.+ String originPrefix = region + "::" + domain + "::" + repository + "::";+ packageOriginConfigs.keysForAccount(owner).stream()+ .filter(k -> k.startsWith(originPrefix))+ .forEach(k -> packageOriginConfigs.deleteForAccount(owner, k));return r;}@@ -563,6 +580,19 @@ public class CodeArtifactService implements Resettable {requireNonBlank(domain, "domain");String owner = effectiveOwner(domainOwner);requireRepository(owner, repositoryKey(region, domain, repository), repository);+ // A caller-configured publish:BLOCK (see PutPackageOriginConfiguration) gates the whole+ // operation before any idempotency check below, the same way a real prerequisite failure+ // would: a retry of already-published bytes is still a PublishPackageVersion call, and+ // AWS's own documented behavior ("version 1.2 cannot be published" once Publish is set to+ // Block) draws no bytes-already-match exception to it.+ String originKey = packageKey(region, domain, repository, format, namespace, packageName);+ String publishRestriction = packageOriginConfigs.getForAccount(owner, originKey)+ .map(PackageOriginConfig::getPublishRestriction)+ .orElse("ALLOW");+ if ("BLOCK".equals(publishRestriction)) {+ throw conflict("Package '" + packageName + "' cannot be published because its origin configuration "+ + "blocks direct publish.", packageName, "package");+ }String key = packageVersionKey(region, domain, repository, format, namespace, packageName, version);CodeArtifactPackageVersion pv = packageVersions.getForAccount(owner, key).orElse(null);@@ -665,41 +695,87 @@ public class CodeArtifactService implements Resettable {/*** Floci never ingests packages from an upstream source, so every package it holds was first* published directly. That is the one case where CodeArtifact's default origin controls are- * publish ALLOW and upstream BLOCK.+ * publish ALLOW and upstream BLOCK; a package a caller has configured via+ * {@link #putPackageOriginConfiguration} carries whatever restrictions were set there instead.*/public record PackageDescription(String format, String namespace, String packageName,String publishRestriction, String upstreamRestriction) {}public PackageDescription describePackage(String region, String domain, String domainOwner, String repository,String format, String namespace, String packageName) {- if (format == null || !PACKAGE_FORMATS.contains(format)) {- throw validation("format must be one of " + PACKAGE_FORMATS + ".");- }- validatePackageToken("package", packageName);- if (namespace != null) {- validatePackageToken("namespace", namespace);- }- // The API reference's own namespace parameter doc for this action: "The namespace is- // required when requesting packages of the following formats: Maven, Swift, generic."- // pypi, nuget, ruby, and cargo packages have no namespace at all, so a supplied one can- // never be real; echoing it back in the response would misrepresent a package that way.- if (("maven".equals(format) || "generic".equals(format)) && (namespace == null || namespace.isBlank())) {- throw validation("namespace is required when describing a " + format + " package.");+ validatePackageCoordinates(format, namespace, packageName, "describing");+ requireNonBlank(domain, "domain");+ requireNonBlank(repository, "repository");+ String owner = effectiveOwner(domainOwner);+ requireRepository(owner, repositoryKey(region, domain, repository), repository);+ String originKey = packageKey(region, domain, repository, format, namespace, packageName);+ Optional<PackageOriginConfig> originConfig = packageOriginConfigs.getForAccount(owner, originKey);+ // PutPackageOriginConfiguration can be called on a package with no versions yet, creating+ // it with no versions (its own documented behavior): a stored config, even with zero+ // versions behind it, already proves the package exists, and the && below must short-circuit+ // on originConfig.isEmpty() before packageExistsViaVersionsOrSidecar ever runs. For a+ // container-backed format that call would otherwise start the real Maven/npm/pypi sidecar+ // container (its own ensureReady lazily provisions one) just to answer a DescribePackage for+ // a package nothing was ever actually published to.+ if (originConfig.isEmpty()+ && !packageExistsViaVersionsOrSidecar(region, domain, owner, repository, format, namespace,+ packageName)) {+ throw notFound("Package '" + packageName + "' was not found.", packageName, "package");}- if ("pypi".equals(format) && namespace != null) {- throw validation("pypi packages do not have a namespace.");+ String publishRestriction = originConfig.map(PackageOriginConfig::getPublishRestriction).orElse("ALLOW");+ String upstreamRestriction = originConfig.map(PackageOriginConfig::getUpstreamRestriction).orElse("BLOCK");+ return new PackageDescription(format, namespace, packageName, publishRestriction, upstreamRestriction);+ }++ /**+ * Sets the publish/upstream origin-control restrictions for a package. Unlike every other+ * package-level operation here, this one does not require the package to already exist:+ * AWS documents that calling it on a package with no versions yet creates the package (with+ * no versions) and applies the requested restrictions, specifically so a caller can lock down+ * a package (block direct publish, block upstream ingestion, or both) before anything is ever+ * published to it or connected to the repository.+ *+ * <p>{@code synchronized} for the same reason every other package-mutating method here is:+ * {@link #publishPackageVersion} reads this same record to decide whether to allow a publish,+ * and must never see a half-applied write.+ */+ public synchronized PackageDescription putPackageOriginConfiguration(String region, String domain,+ String domainOwner, String repository, String format, String namespace, String packageName,+ String publishRestriction, String upstreamRestriction) {+ validatePackageCoordinates(format, namespace, packageName, "setting the origin configuration of");+ // Both restrictions are required (the API reference: "You must include both the desired+ // upstream and publish restrictions"), and package groups' extra ALLOW_SPECIFIC_REPOSITORIES+ // / INHERIT values do not apply to a plain package's own restrictions. Set.of's own+ // contains(null) throws rather than returning false, so a missing value needs its own+ // null check first rather than falling into the membership test.+ if (publishRestriction == null || !ORIGIN_RESTRICTION_VALUES.contains(publishRestriction)) {+ throw validation("restrictions.publish must be one of " + ORIGIN_RESTRICTION_VALUES + ".");+ }+ if (upstreamRestriction == null || !ORIGIN_RESTRICTION_VALUES.contains(upstreamRestriction)) {+ throw validation("restrictions.upstream must be one of " + ORIGIN_RESTRICTION_VALUES + ".");}requireNonBlank(domain, "domain");requireNonBlank(repository, "repository");String owner = effectiveOwner(domainOwner);requireRepository(owner, repositoryKey(region, domain, repository), repository);- boolean exists = CONTAINER_BACKED_FORMATS.contains(format)+ String key = packageKey(region, domain, repository, format, namespace, packageName);+ packageOriginConfigs.putForAccount(owner, key, new PackageOriginConfig(publishRestriction,+ upstreamRestriction));+ return new PackageDescription(format, namespace, packageName, publishRestriction, upstreamRestriction);+ }++ /**+ * Whether a package has any real version behind it: a stored {@code packageVersions} record+ * for generic, or the repository's own sidecar for a container-backed format. Deliberately+ * does not know about {@code packageOriginConfigs}; {@link #describePackage} checks that+ * separately and short-circuits before ever calling this, so an origin-config-only package+ * (no versions) never pays for a sidecar round trip just to be found.+ */+ private boolean packageExistsViaVersionsOrSidecar(String region, String domain, String owner, String repository,+ String format, String namespace, String packageName) {+ return CONTAINER_BACKED_FORMATS.contains(format)? containerBackedPackageExists(region, domain, owner, repository, format, namespace, packageName): genericPackageExists(region, domain, owner, repository, format, namespace, packageName);- if (!exists) {- throw notFound("Package '" + packageName + "' was not found.", packageName, "package");- }- return new PackageDescription(format, namespace, packageName, "ALLOW", "BLOCK");}private boolean containerBackedPackageExists(String region, String domain, String owner, String repository,@@ -739,35 +815,25 @@ public class CodeArtifactService implements Resettable {*/public synchronized PackageDescription deletePackage(String region, String domain, String domainOwner,String repository, String format, String namespace, String packageName) {- if (format == null || !PACKAGE_FORMATS.contains(format)) {- throw validation("format must be one of " + PACKAGE_FORMATS + ".");- }- validatePackageToken("package", packageName);- if (namespace != null) {- validatePackageToken("namespace", namespace);- }- // Same boundary as describePackage's own namespace rules (see its comment there for the- // API reference citation): a missing generic/maven namespace would delete under a- // null-namespace key nothing real ever publishes to, and a supplied pypi namespace would- // be silently ignored by the sidecar's existence check rather than rejected.- if (("maven".equals(format) || "generic".equals(format)) && (namespace == null || namespace.isBlank())) {- throw validation("namespace is required when deleting a " + format + " package.");- }- if ("pypi".equals(format) && namespace != null) {- throw validation("pypi packages do not have a namespace.");- }+ validatePackageCoordinates(format, namespace, packageName, "deleting");requireNonBlank(domain, "domain");requireNonBlank(repository, "repository");String owner = effectiveOwner(domainOwner);requireRepository(owner, repositoryKey(region, domain, repository), repository);+ // Looked up before any deletion below: an origin-config-only package (no version ever+ // published, see putPackageOriginConfiguration) is the one case where neither branch below+ // finds anything real to delete, yet the package still exists, the same way describePackage+ // already recognizes it. hadRealContent carries whether the branch actually found something.+ String originKey = packageKey(region, domain, repository, format, namespace, packageName);+ Optional<PackageOriginConfig> originConfig = packageOriginConfigs.getForAccount(owner, originKey);+ boolean hadRealContent;if (CONTAINER_BACKED_FORMATS.contains(format)) {- deleteContainerBackedPackage(region, domain, owner, repository, format, namespace, packageName);+ hadRealContent = deleteContainerBackedPackageIfPresent(region, domain, owner, repository, format,+ namespace, packageName);} else {List<CodeArtifactPackageVersion> versions = genericPackageVersions(region, domain, owner, repository,format, namespace, packageName);- if (versions.isEmpty()) {- throw notFound("Package '" + packageName + "' was not found.", packageName, "package");- }+ hadRealContent = !versions.isEmpty();for (CodeArtifactPackageVersion pv : versions) {String versionKey = packageVersionKey(region, domain, repository, format, namespace, packageName,pv.getVersion());@@ -787,7 +853,19 @@ public class CodeArtifactService implements Resettable {}}}- return new PackageDescription(format, namespace, packageName, "ALLOW", "BLOCK");+ if (!hadRealContent && originConfig.isEmpty()) {+ throw notFound("Package '" + packageName + "' was not found.", packageName, "package");+ }+ // DeletePackage removes the package entity itself, origin configuration included (AWS's+ // own doc: "Deletes a package and all associated package versions"), and the real+ // DeletePackage response's deletedPackage.originConfiguration reports whatever restrictions+ // were actually in effect, not CodeArtifact's bare defaults. A later DescribePackage on the+ // same coordinates must 404 rather than finding a zero-version package the deleted config+ // left behind.+ packageOriginConfigs.deleteForAccount(owner, originKey);+ String publishRestriction = originConfig.map(PackageOriginConfig::getPublishRestriction).orElse("ALLOW");+ String upstreamRestriction = originConfig.map(PackageOriginConfig::getUpstreamRestriction).orElse("BLOCK");+ return new PackageDescription(format, namespace, packageName, publishRestriction, upstreamRestriction);}/**@@ -799,14 +877,29 @@ public class CodeArtifactService implements Resettable {* {@link UnsupportedOperationException} for a sidecar that genuinely cannot do this, rather than* silently leaving the package in place or claiming a success it cannot back up; that becomes a* real, if deliberately blunt, AWS error here instead of an unhandled 500.+ *+ * <p>Returns whether the sidecar actually had the package, rather than throwing when it does+ * not: the caller still has to decide between success (an origin-config-only package with+ * nothing real behind it yet) and a genuine 404, which needs the origin-config lookup this+ * method deliberately knows nothing about.+ *+ * <p>Always asks the sidecar, even for a package deletePackage otherwise knows only through a+ * stored origin configuration: unlike describePackage's short-circuit, a package set up this+ * way is a real target for a later native-protocol publish (PublishPackageVersion only ever+ * accepts generic, but {@code mvn deploy}/{@code npm publish}/{@code twine upload} go straight+ * to the sidecar and leave no record here), so skipping this call could silently leave real+ * content behind. The cost is a lazily-started container on every container-backed delete,+ * origin-config-only or not; that cost already existed for every real package before this+ * method's origin-config awareness, this just stops it from being skipped by accident instead+ * of by choice.*/- private void deleteContainerBackedPackage(String region, String domain, String owner, String repository,- String format, String namespace, String packageName) {+ private boolean deleteContainerBackedPackageIfPresent(String region, String domain, String owner,+ String repository, String format, String namespace, String packageName) {String repoId = ensureFormatContainerId(format, region, domain, owner, repository);RepositorySidecarManager manager = sidecarRegistry.forFormat(format).orElseThrow(() -> notFound("Package '" + packageName + "' was not found.", packageName, "package"));if (!manager.packageExists(repoId, domain, repository, namespace, packageName)) {- throw notFound("Package '" + packageName + "' was not found.", packageName, "package");+ return false;}try {manager.deletePackage(repoId, domain, repository, namespace, packageName);@@ -814,6 +907,7 @@ public class CodeArtifactService implements Resettable {throw new AwsException("InternalServerException","Deleting a " + format + " package is not yet supported by this emulator.", 500);}+ return true;}private void deleteAssetContent(String owner, String packageVersionKey, String assetName) {@@ -1025,6 +1119,7 @@ public class CodeArtifactService implements Resettable {domains.clear();repositories.clear();packageVersions.clear();+ packageOriginConfigs.clear();authorizationTokens.clear();if (inMemory) {memoryAssetStore.clear();@@ -1192,6 +1287,33 @@ public class CodeArtifactService implements Resettable {}}+ /**+ * The format/package/namespace coordinate validation shared by every package-level operation+ * that takes them. {@code action} is a present-participle phrase ("describing", "setting the+ * origin configuration of") substituted into the one message that otherwise differs per caller.+ *+ * <p>The namespace rule is the API reference's own namespace parameter doc for these actions:+ * "The namespace is required when requesting packages of the following formats: Maven, Swift,+ * generic." pypi, nuget, ruby, and cargo packages have no namespace at all, so a supplied one+ * can never be real; echoing it back in a response would misrepresent a package that way.+ */+ private static void validatePackageCoordinates(String format, String namespace, String packageName,+ String action) {+ if (format == null || !PACKAGE_FORMATS.contains(format)) {+ throw validation("format must be one of " + PACKAGE_FORMATS + ".");+ }+ validatePackageToken("package", packageName);+ if (namespace != null) {+ validatePackageToken("namespace", namespace);+ }+ if (("maven".equals(format) || "generic".equals(format)) && (namespace == null || namespace.isBlank())) {+ throw validation("namespace is required when " + action + " a " + format + " package.");+ }+ if ("pypi".equals(format) && namespace != null) {+ throw validation("pypi packages do not have a namespace.");+ }+ }+private static void validateAssetName(String assetName) {if (assetName == null || assetName.isEmpty() || assetName.length() > 255|| !ASSET_NAME.matcher(assetName).matches()) {@@ -1390,6 +1512,12 @@ public class CodeArtifactService implements Resettable {+ (namespace == null ? "" : namespace) + "::" + packageName + "::" + version;}+ private static String packageKey(String region, String domain, String repository, String format,+ String namespace, String packageName) {+ return region + "::" + domain + "::" + repository + "::" + format + "::"+ + (namespace == null ? "" : namespace) + "::" + packageName;+ }+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/PackageOriginConfig.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/PackageOriginConfig.javanew file mode 100644index 0000000000..f41ee1a37c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/PackageOriginConfig.java@@ -0,0 +1,42 @@+package io.github.hectorvent.floci.services.codeartifact.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * The origin-control restrictions a caller explicitly set on a package via+ * {@code PutPackageOriginConfiguration}. A package with no record here still has an origin+ * configuration, it is just CodeArtifact's documented default (publish ALLOW, upstream BLOCK);+ * see {@code CodeArtifactService.PackageDescription}'s own Javadoc for why that default holds+ * for every package Floci serves until a caller overrides it.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class PackageOriginConfig {+ private String publishRestriction;+ private String upstreamRestriction;++ public PackageOriginConfig() {+ }++ public PackageOriginConfig(String publishRestriction, String upstreamRestriction) {+ this.publishRestriction = publishRestriction;+ this.upstreamRestriction = upstreamRestriction;+ }++ public String getPublishRestriction() {+ return publishRestriction;+ }++ public void setPublishRestriction(String publishRestriction) {+ this.publishRestriction = publishRestriction;+ }++ public String getUpstreamRestriction() {+ return upstreamRestriction;+ }++ public void setUpstreamRestriction(String upstreamRestriction) {+ this.upstreamRestriction = upstreamRestriction;+ }+}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.javaindex d2d473b060..6ea17b011f 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactAssetPersistenceTest.java@@ -11,6 +11,7 @@ import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.Publimport 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.PackageOriginConfig;import io.github.hectorvent.floci.testutil.LogCapture;import org.junit.jupiter.api.Assumptions;import org.junit.jupiter.api.Test;@@ -85,6 +86,28 @@ class CodeArtifactAssetPersistenceTest {assertEquals(published.packageVersion().getRevision(), result.packageVersionRevision());}+ /**+ * {@code packageOriginConfigs} is wired through {@code StorageFactory} the same way+ * {@code domains}/{@code repositories}/{@code packageVersions} are, but that similarity had+ * never actually been exercised: this confirms a stored origin configuration, including one+ * set on a package with no versions at all, actually round-trips through disk rather than only+ * ever having been read back from the same in-memory instance that wrote it.+ */+ @Test+ void packageOriginConfigurationSurvivesRestart(@TempDir Path dir) {+ CodeArtifactService first = newService(dir);+ first.createDomain(REGION, "dom", null, Map.of());+ first.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ first.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "never-published", "BLOCK",+ "ALLOW");++ CodeArtifactService restarted = newService(dir);+ CodeArtifactService.PackageDescription described = restarted.describePackage(REGION, "dom", null, "repo",+ "generic", "ns", "never-published");+ assertEquals("BLOCK", described.publishRestriction());+ assertEquals("ALLOW", described.upstreamRestriction());+ }+/*** The in-memory {@code PackageAsset.content} field is {@code @JsonIgnore}, so a package* version reloaded from disk (a fresh {@code CodeArtifactService} instance here, standing in@@ -443,6 +466,8 @@ class CodeArtifactAssetPersistenceTest {"codeartifact-repositories.json", new TypeReference<Map<String, CodeArtifactRepository>>() {});AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersionStore = accountAware(dir,"codeartifact-package-versions.json", new TypeReference<Map<String, CodeArtifactPackageVersion>>() {});+ AccountAwareStorageBackend<PackageOriginConfig> packageOriginConfigStore = accountAware(dir,+ "codeartifact-package-origin-configs.json", new TypeReference<Map<String, PackageOriginConfig>>() {});RegionResolver regionResolver = mock(RegionResolver.class);when(regionResolver.getAccountId()).thenReturn(ACCOUNT_ID);@@ -453,8 +478,9 @@ class CodeArtifactAssetPersistenceTest {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"), new CodeArtifactSidecarRegistry(List.of()));+ return new CodeArtifactService(domainStore, repoStore, packageVersionStore, packageOriginConfigStore,+ regionResolver, config, false, dir.resolve("codeartifact-assets"),+ new CodeArtifactSidecarRegistry(List.of()));}private <V> AccountAwareStorageBackend<V> accountAware(Path dir, String fileName, TypeReference<Map<String, V>> type) {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 d6e72f1867..1a55af7001 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@@ -250,6 +250,49 @@ class CodeArtifactIntegrationTest {.then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));}+ @Test+ void putPackageOriginConfigurationCreatesAPackageAndItsRestrictionsSurviveDescribeAndDelete() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=origin-config-domain").then().statusCode(200);+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/repository?domain=origin-config-domain&repository=repo")+ .then().statusCode(200);++ given().contentType("application/json").header("Authorization", AUTH)+ .body("{\"restrictions\":{\"publish\":\"BLOCK\",\"upstream\":\"ALLOW\"}}")+ .post("/v1/package?domain=origin-config-domain&repository=repo&format=generic&namespace=ns"+ + "&package=never-published")+ .then().statusCode(200)+ .body("originConfiguration.restrictions.publish", equalTo("BLOCK"))+ .body("originConfiguration.restrictions.upstream", equalTo("ALLOW"));++ given().header("Authorization", AUTH)+ .get("/v1/package?domain=origin-config-domain&repository=repo&format=generic&namespace=ns"+ + "&package=never-published")+ .then().statusCode(200)+ .body("package.originConfiguration.restrictions.publish", equalTo("BLOCK"))+ .body("package.originConfiguration.restrictions.upstream", equalTo("ALLOW"));++ byte[] content = "blocked".getBytes(StandardCharsets.UTF_8);+ given().header("Authorization", AUTH).header("x-amz-content-sha256", sha256Hex(content))+ .contentType("application/octet-stream").body(content)+ .post("/v1/package/version/publish?domain=origin-config-domain&repository=repo&format=generic"+ + "&namespace=ns&package=never-published&version=1.0.0&asset=a.txt")+ .then().statusCode(409).body("__type", equalTo("ConflictException"));++ given().header("Authorization", AUTH)+ .delete("/v1/package?domain=origin-config-domain&repository=repo&format=generic&namespace=ns"+ + "&package=never-published")+ .then().statusCode(200)+ .body("deletedPackage.originConfiguration.restrictions.publish", equalTo("BLOCK"))+ .body("deletedPackage.originConfiguration.restrictions.upstream", equalTo("ALLOW"));++ given().header("Authorization", AUTH)+ .get("/v1/package?domain=origin-config-domain&repository=repo&format=generic&namespace=ns"+ + "&package=never-published")+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));+ }+@Testvoid unfinishedPublishKeepsVersionOpenForMoreAssets() {given().contentType("application/json").header("Authorization", AUTH)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 5ddc798bcb..a821c8a9c0 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@@ -15,6 +15,7 @@ import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.Resoimport 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.PackageOriginConfig;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;@@ -63,6 +64,8 @@ class CodeArtifactServiceTest {repoStore = AccountAwareStorageBackend.inMemory(ACCOUNT_ID);AccountAwareStorageBackend<CodeArtifactPackageVersion> packageVersionStore =AccountAwareStorageBackend.inMemory(ACCOUNT_ID);+ AccountAwareStorageBackend<PackageOriginConfig> packageOriginConfigStore =+ AccountAwareStorageBackend.inMemory(ACCOUNT_ID);regionResolver = mock(RegionResolver.class);when(regionResolver.getAccountId()).thenReturn(ACCOUNT_ID);@@ -79,8 +82,8 @@ class CodeArtifactServiceTest {when(reposiliteClient.format()).thenReturn("maven");pypiserverClient = mock(PypiserverSidecarClient.class);when(pypiserverClient.format()).thenReturn("pypi");- service = new CodeArtifactService(domainStore, repoStore, packageVersionStore, regionResolver, config,- true, null, new CodeArtifactSidecarRegistry(+ service = new CodeArtifactService(domainStore, repoStore, packageVersionStore, packageOriginConfigStore,+ regionResolver, config, true, null, new CodeArtifactSidecarRegistry(List.of(verdaccioClient, reposiliteClient, pypiserverClient)));}@@ -421,6 +424,34 @@ class CodeArtifactServiceTest {assertEquals("ResourceNotFoundException", e.getErrorCode());}+ /**+ * createRepository already guarantees this for container-backed sidecar content, by design+ * (a fresh sidecarContainerIds id on every creation, never derived from the repository's+ * name). packageOriginConfigs is keyed by name instead, so deleteRepository has to clean it+ * up explicitly, or a repository recreated under the same name would inherit a prior+ * package's restrictions, including a publish:BLOCK the new repository's owner never set and+ * has no way to discover.+ */+ @Test+ void deleteRepositoryRemovesOriginConfigsSoARecreatedRepositoryDoesNotInheritThem() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "BLOCK",+ "BLOCK");++ service.deleteRepository(REGION, "dom", null, "repo");+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ AwsException gone = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom", null,+ "repo", "generic", "ns", "my-pkg"));+ assertEquals("ResourceNotFoundException", gone.getErrorCode());++ byte[] content = "x".getBytes(StandardCharsets.UTF_8);+ PublishPackageVersionResult published = service.publishPackageVersion(REGION, "dom", null, "repo", "generic",+ "ns", "my-pkg", "1.0.0", "a.txt", sha256Hex(content), "false", content);+ assertEquals("Published", published.packageVersion().getStatus());+ }+@Testvoid createRepositoryAcceptsExistingUpstream() {service.createDomain(REGION, "dom", null, Map.of());@@ -660,11 +691,22 @@ class CodeArtifactServiceTest {void clearRemovesAllPersistedState() {service.createDomain(REGION, "dom", null, Map.of());service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ // An origin-config-only package (no versions, see putPackageOriginConfiguration) is its+ // own persisted record distinct from a domain, repository, or package version; clear()+ // missing it would leave describePackage still finding a package that should be gone.+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "never-published",+ "BLOCK", "BLOCK");service.clear();assertTrue(service.listDomains(REGION, null, null).items().isEmpty());AwsException e = assertThrows(AwsException.class,() -> service.describeRepository(REGION, "dom", null, "repo"));assertEquals("ResourceNotFoundException", e.getErrorCode());++ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ AwsException packageGone = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom",+ null, "repo", "generic", "ns", "never-published"));+ assertEquals("ResourceNotFoundException", packageGone.getErrorCode());}// ---------------------------------------------------- authorization tokens@@ -1104,6 +1146,156 @@ class CodeArtifactServiceTest {assertEquals("ValidationException", e.getErrorCode());}+ /**+ * The one package-level operation that works before the package exists at all: AWS documents+ * that calling it creates the package with no versions and applies the requested restrictions,+ * so a caller can lock a package down before anything is ever published to it.+ */+ @Test+ void putPackageOriginConfigurationCreatesAPackageWithNoVersionsAndDescribePackageReflectsIt() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ AwsException notYetFound = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom",+ null, "repo", "generic", "ns", "never-published"));+ assertEquals("ResourceNotFoundException", notYetFound.getErrorCode());++ CodeArtifactService.PackageDescription configured = service.putPackageOriginConfiguration(REGION, "dom",+ null, "repo", "generic", "ns", "never-published", "BLOCK", "BLOCK");+ assertEquals("BLOCK", configured.publishRestriction());+ assertEquals("BLOCK", configured.upstreamRestriction());++ CodeArtifactService.PackageDescription described = service.describePackage(REGION, "dom", null, "repo",+ "generic", "ns", "never-published");+ assertEquals("BLOCK", described.publishRestriction());+ assertEquals("BLOCK", described.upstreamRestriction());+ }++ /**+ * The same no-versions-needed existence proof applies uniformly to a container-backed format,+ * not just generic: the pypi sidecar never heard of this package (its mock answers false by+ * default, standing in for a real sidecar that was never asked to provision anything for it),+ * yet the stored origin configuration alone must still be enough for describePackage to find+ * the package rather than 404ing because the sidecar-exists check came back empty.+ */+ @Test+ void putPackageOriginConfigurationCreatesAContainerBackedPackageWithNoVersionsToo() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "pypi", null, "never-published", "BLOCK",+ "ALLOW");++ CodeArtifactService.PackageDescription described = service.describePackage(REGION, "dom", null, "repo",+ "pypi", null, "never-published");+ assertEquals("BLOCK", described.publishRestriction());+ assertEquals("ALLOW", described.upstreamRestriction());+ verify(pypiserverClient, never()).packageExists(any(), any(), any(), any(), any());+ }++ @Test+ void putPackageOriginConfigurationOverridesTheDirectPublishDefaultsOfAnExistingPackage() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "x".getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt",+ sha256Hex(content), "false", content);++ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "BLOCK",+ "ALLOW");++ CodeArtifactService.PackageDescription described = service.describePackage(REGION, "dom", null, "repo",+ "generic", "ns", "my-pkg");+ assertEquals("BLOCK", described.publishRestriction());+ assertEquals("ALLOW", described.upstreamRestriction());+ }++ @Test+ void putPackageOriginConfigurationValidatesRestrictionsAndNamespaceShape() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ AwsException missingRestrictions = assertThrows(AwsException.class, () -> service+ .putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", null, null));+ assertEquals("ValidationException", missingRestrictions.getErrorCode());++ AwsException missingUpstreamOnly = assertThrows(AwsException.class, () -> service+ .putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "ALLOW",+ null));+ assertEquals("ValidationException", missingUpstreamOnly.getErrorCode());++ AwsException badRestrictionValue = assertThrows(AwsException.class, () -> service+ .putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg",+ "ALLOW_SPECIFIC_REPOSITORIES", "BLOCK"));+ assertEquals("ValidationException", badRestrictionValue.getErrorCode());++ AwsException badUpstreamValue = assertThrows(AwsException.class, () -> service+ .putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "ALLOW",+ "ALLOW_SPECIFIC_REPOSITORIES"));+ assertEquals("ValidationException", badUpstreamValue.getErrorCode());++ AwsException missingNamespaceForGeneric = assertThrows(AwsException.class, () -> service+ .putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", null, "my-pkg", "ALLOW",+ "BLOCK"));+ assertEquals("ValidationException", missingNamespaceForGeneric.getErrorCode());++ AwsException namespaceForPypi = assertThrows(AwsException.class, () -> service+ .putPackageOriginConfiguration(REGION, "dom", null, "repo", "pypi", "bogus-namespace", "my-pkg",+ "ALLOW", "BLOCK"));+ assertEquals("ValidationException", namespaceForPypi.getErrorCode());++ // None of the rejections above may have created the package or changed anything about it:+ // every one of them must still 404 just like before any of these calls were attempted.+ AwsException stillAbsent = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom",+ null, "repo", "generic", "ns", "my-pkg"));+ assertEquals("ResourceNotFoundException", stillAbsent.getErrorCode());+ }++ /**+ * Same rejections as above, but against a package that already carries a stored+ * configuration: a rejected update must leave that prior configuration exactly as it was,+ * not half-apply the new, invalid restrictions.+ */+ @Test+ void putPackageOriginConfigurationLeavesAnExistingConfigurationUnchangedOnRejection() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "ALLOW",+ "BLOCK");++ assertThrows(AwsException.class, () -> service.putPackageOriginConfiguration(REGION, "dom", null, "repo",+ "generic", "ns", "my-pkg", "ALLOW", "ALLOW_SPECIFIC_REPOSITORIES"));++ CodeArtifactService.PackageDescription unchanged = service.describePackage(REGION, "dom", null, "repo",+ "generic", "ns", "my-pkg");+ assertEquals("ALLOW", unchanged.publishRestriction());+ assertEquals("BLOCK", unchanged.upstreamRestriction());+ }++ /**+ * Mirrors the AWS user guide's own worked example: once a package's origin configuration sets+ * Publish to Block, a direct PublishPackageVersion for that package must be rejected, even for+ * an otherwise brand-new version, and restoring Publish to Allow lifts the rejection again.+ */+ @Test+ void publishPackageVersionIsRejectedOnceOriginConfigurationBlocksPublish() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "BLOCK",+ "ALLOW");++ byte[] content = "x".getBytes(StandardCharsets.UTF_8);+ AwsException blocked = assertThrows(AwsException.class, () -> service.publishPackageVersion(REGION, "dom",+ null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt", sha256Hex(content), "false", content));+ assertEquals("ConflictException", blocked.getErrorCode());++ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "ALLOW",+ "ALLOW");+ PublishPackageVersionResult published = service.publishPackageVersion(REGION, "dom", null, "repo", "generic",+ "ns", "my-pkg", "1.0.0", "a.txt", sha256Hex(content), "false", content);+ assertEquals("Published", published.packageVersion().getStatus());+ }+@Testvoid deletePackageRemovesEveryVersionAndAssetButLeavesOtherPackagesAlone() {service.createDomain(REGION, "dom", null, Map.of());@@ -1145,6 +1337,93 @@ class CodeArtifactServiceTest {assertEquals("ResourceNotFoundException", unknown.getErrorCode());}+ /**+ * The real DeletePackage response's deletedPackage.originConfiguration reports whatever+ * restrictions were actually in effect, not CodeArtifact's bare ALLOW/BLOCK defaults.+ */+ @Test+ void deletePackageReportsTheOriginConfigurationThatWasActuallyInEffect() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "x".getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt",+ sha256Hex(content), "false", content);+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "ALLOW",+ "ALLOW");++ CodeArtifactService.PackageDescription deleted = service.deletePackage(REGION, "dom", null, "repo",+ "generic", "ns", "my-pkg");+ assertEquals("ALLOW", deleted.publishRestriction());+ assertEquals("ALLOW", deleted.upstreamRestriction());+ }++ /**+ * DeletePackage removes the package entity, origin configuration included (AWS's own doc:+ * "Deletes a package and all associated package versions"). A leftover origin-config record+ * must not resurrect the deleted package as a zero-version one on the next DescribePackage.+ */+ @Test+ void deletePackageClearsTheOriginConfigurationSoDescribePackageStays404Afterward() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ byte[] content = "x".getBytes(StandardCharsets.UTF_8);+ service.publishPackageVersion(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "1.0.0", "a.txt",+ sha256Hex(content), "false", content);+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "my-pkg", "BLOCK",+ "BLOCK");++ service.deletePackage(REGION, "dom", null, "repo", "generic", "ns", "my-pkg");++ AwsException gone = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom", null,+ "repo", "generic", "ns", "my-pkg"));+ assertEquals("ResourceNotFoundException", gone.getErrorCode());+ }++ /**+ * An origin-config-only package (no version ever published) is still a package+ * describePackage finds; deletePackage must agree rather than 404ing on the same coordinates+ * describePackage just reported as existing.+ */+ @Test+ void deletePackageRemovesAnOriginConfigOnlyPackageThatWasNeverPublishedTo() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "generic", "ns", "never-published",+ "BLOCK", "BLOCK");++ CodeArtifactService.PackageDescription deleted = service.deletePackage(REGION, "dom", null, "repo",+ "generic", "ns", "never-published");+ assertEquals("BLOCK", deleted.publishRestriction());+ assertEquals("BLOCK", deleted.upstreamRestriction());++ AwsException gone = assertThrows(AwsException.class, () -> service.describePackage(REGION, "dom", null,+ "repo", "generic", "ns", "never-published"));+ assertEquals("ResourceNotFoundException", gone.getErrorCode());+ }++ /**+ * Same case for a container-backed format: the sidecar still gets asked (unlike+ * describePackage's short-circuit, deletePackage cannot skip this: a package set up through+ * PutPackageOriginConfiguration could also have real content published to it directly through+ * the native protocol later, which deletePackage still has to find and remove), but it reports+ * nothing there, and the stored origin configuration alone must still let deletePackage+ * succeed rather than 404 on a package describePackage itself finds.+ */+ @Test+ void deletePackageRemovesAnOriginConfigOnlyContainerBackedPackageThatTheSidecarNeverHeardOf() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ service.putPackageOriginConfiguration(REGION, "dom", null, "repo", "pypi", null, "never-published", "ALLOW",+ "BLOCK");+ when(pypiserverClient.packageExists(anyString(), eq("dom"), eq("repo"), isNull(), eq("never-published")))+ .thenReturn(false);++ CodeArtifactService.PackageDescription deleted = service.deletePackage(REGION, "dom", null, "repo", "pypi",+ null, "never-published");+ assertEquals("ALLOW", deleted.publishRestriction());+ verify(pypiserverClient, never()).deletePackage(any(), any(), any(), any(), any());+ }+@Testvoid deletePackageBridgesToReposiliteForMavenAfterConfirmingItExists() {service.createDomain(REGION, "dom", null, Map.of());