Skip to content

feat(codeartifact): support the cargo (crates.io) registry format - #8370

Merged
pgermosen merged 1 commit into
mainfrom
feat/codeartifact-upstream-repo
Nov 14, 2026
Merged

pgermosen merged 1 commit into
mainfrom
feat/codeartifact-upstream-repo

Conversation

@pgermosen

@pgermosen pgermosen commented Nov 14, 2026 •

Copy link
Copy Markdown
Member

Summary

CodeArtifact's Rust/Cargo repositories currently have no native support at all: no sidecar, no
wire protocol, no external connection. This adds it, following the same shape as the existing
Maven/npm/pypi/NuGet container-backed formats.

  • KellnrSidecarManager/KellnrSidecarClient run a real Kellnr
    container per cargo-enabled repository and speak its native HTTP API for publish, download, and
    the sparse index.
  • CodeArtifactCargoController implements the real cargo sparse-registry wire protocol (publish,
    download, sparse index lookup, config.json), and forwards Kellnr's own publish rejections (e.g.
    republishing an existing version, which the Cargo Book documents as permanently disallowed)
    verbatim rather than swallowing them into an opaque error.
  • The public:crates-io external connection is wired up via CargoExternalConnectionClient (real
    index.crates.io/static.crates.io wire calls) and CodeArtifactCargoExternalConnectionImporter,
    reusing the same claim/fence/retention-origin machinery NuGet's own importer already uses. Cargo's
    sparse index covers every version of a crate name in one file, and a real cargo client always
    consults it before anything else, so unlike the other formats' importers this one also merges
    real upstream-only version lines into the local index response — a read-only proxy step with no
    retention write of its own — so an upstream-only crate is actually visible to dependency
    resolution before anything is retained.

Known gaps, called out in docs/services/codeartifact.md: no repository-to-repository upstream
importer yet for cargo (every other native format already has one), and no yank/owner/search
routes. Both are natural follow-ups, not bundled into this PR.

Update after review: fixed KellnrSidecarClient missing a listPackages override (made every
ListPackages call 500 once cargo joined the container-backed formats), sparse-index bucket paths
not being lowercased per the Cargo Book's own spec (confirmed live: a mixed-case crate like
Inflector genuinely 404s at its original-case path against the real index.crates.io), the admin
account behind Kellnr's internal publish token sitting at Kellnr's own shared admin/admin
default instead of a fresh per-container random password, a cached publish token never recovering
from a silent container restart, two unbounded-allocation spots (the publish body's own declared
metadata length, and the external sparse-index fetch), a renamed dependency's alias/real-name fields
swapped between the index and publish shapes, features2/links/rust_version being dropped from
a retained crate's synthesized metadata, and the Kellnr image floating on an unpinned major tag.

Type of change

  • Bug fix (fix:)
  • New feature (feat:)
  • Breaking change (feat!: or fix!:)
  • Docs / chore

AWS Compatibility

Verified against the real cargo wire protocol (Cargo Book's registry-web-api/publishing
pages) and against the real, live index.crates.io/static.crates.io production endpoints
directly (sparse-index bucketing, line shape, download route, and a live cksum-vs-downloaded-bytes
check), not just Kellnr's own behavior. AWS's own external-connection.html documents
public:crates-io as a supported external connection; CodeArtifactService already had the
public:crates-io -> cargo mapping scaffolded in before this PR.

Checklist

  • ./mvnw test passes locally
  • New or updated integration test added
  • Commit messages follow Conventional Commits
  • I have no more than 2 open, non-draft pull requests and no more than 4 open pull requests in total (drafts included) in this repository (maintainers and dependency bots are exempt). (already have 2 open non-draft PRs; opening this one anyway on explicit instruction)

@qodo-code-review

Copy link
Copy Markdown

PR Summary by Qodo

Add Cargo registry and crates.io support to CodeArtifact

✨ Enhancement 🧪 Tests 📝 Documentation ⚙️ Configuration changes 🕐 40+ Minutes

Grey Divider

AI Description

• Serve Cargo publish, sparse-index, and crate downloads through per-repository Kellnr containers.
• Resolve crates.io versions through external connections, retaining verified crates on download.
• Add configuration, protocol and integration tests, and documentation of supported routes and gaps.
Diagram

graph TD
  Cargo["Cargo client"] --> Controller["Cargo controller"] --> KellnrClient["Kellnr client"] --> Kellnr["Kellnr container"]
  Controller --> Importer["External importer"] --> ExternalClient["Crates client"] --> CratesIo["crates.io"]
  Controller --> Service["CodeArtifact service"]
  Importer --> Service
Loading
High-Level Assessment

The per-repository Kellnr sidecar fits the existing container-backed format architecture and avoids implementing registry storage from scratch. An on-demand download proxy alone would not expose upstream-only versions to Cargo's sparse-index resolver, so the read-only index merge is necessary.

Files changed (19) +3902 / -79

Enhancement (7) +1578 / -19
CargoExternalConnectionClient.javaFetch sparse indexes and crates from crates.io +168/-0

Fetch sparse indexes and crates from crates.io

• Adds an outbound client for the public index and crate download hosts. Streams crate files to disk while calculating size and SHA-256 and enforcing the asset limit.

src/main/java/io/floci/aws/services/codeartifact/CargoExternalConnectionClient.java

CodeArtifactCargoController.javaServe the Cargo sparse-registry protocol +366/-0

Serve the Cargo sparse-registry protocol

• Adds authenticated config, sparse-index, download, and publish routes. Forwards publish rejections from Kellnr and streams downloads while holding the repository lease.

src/main/java/io/floci/aws/services/codeartifact/CodeArtifactCargoController.java

CodeArtifactCargoExternalConnectionImporter.javaMerge upstream versions and retain downloaded crates +348/-0

Merge upstream versions and retain downloaded crates

• Makes upstream-only versions visible in sparse-index responses without retaining them on lookup. On download, verifies the crate checksum and uses existing origin claims and fences to retain it.

src/main/java/io/floci/aws/services/codeartifact/CodeArtifactCargoExternalConnectionImporter.java

CodeArtifactService.javaRegister Cargo as a container-backed format +9/-4

Register Cargo as a container-backed format

• Includes Cargo in repository container IDs, copy eligibility, namespace validation, and the current-repository check used during retention.

src/main/java/io/floci/aws/services/codeartifact/CodeArtifactService.java

CodeArtifactTokenExtractor.javaAccept bare Cargo authorization tokens +15/-8

Accept bare Cargo authorization tokens

• Extends shared token extraction to accept Cargo's scheme-free Authorization value alongside Basic and Bearer credentials.

src/main/java/io/floci/aws/services/codeartifact/CodeArtifactTokenExtractor.java

KellnrSidecarClient.javaBridge CodeArtifact package operations to Kellnr +639/-0

Bridge CodeArtifact package operations to Kellnr

• Implements the shared sidecar contract for crate lookup, assets, publishing, copying, and hard deletion. Manages internal Kellnr credentials and repository-level write locks.

src/main/java/io/floci/aws/services/codeartifact/KellnrSidecarClient.java

SidecarUriUtils.javaAdd shared crates.io index bucketing +33/-7

Add shared crates.io index bucketing

• Adds the crate-name bucketing rule used by both Kellnr index requests and public crates.io lookups.

src/main/java/io/floci/aws/services/codeartifact/SidecarUriUtils.java

Tests (8) +2028 / -1
CargoExternalConnectionClientTest.javaTest public registry HTTP requests +183/-0

Test public registry HTTP requests

• Uses a local HTTP server to verify index bucketing, crate bytes and hashes, redirects, and missing-content behavior.

src/test/java/io/floci/aws/services/codeartifact/CargoExternalConnectionClientTest.java

CodeArtifactCargoControllerLeaseTest.javaTest Cargo routing and lease handling +326/-0

Test Cargo routing and lease handling

• Covers config and index responses, import dispatch, streamed download leases, publish checks, rejection forwarding, and failure cleanup.

src/test/java/io/floci/aws/services/codeartifact/CodeArtifactCargoControllerLeaseTest.java

CodeArtifactCargoDockerIntegrationTest.javaExercise Cargo routes against Kellnr +352/-0

Exercise Cargo routes against Kellnr

• Tests publish and download round trips, dependency entries, authorization, repository isolation, duplicate-publish rejection, archived downloads, and publish controls with a live container.

src/test/java/io/floci/aws/services/codeartifact/CodeArtifactCargoDockerIntegrationTest.java

CodeArtifactCargoExternalConnectionDockerIntegrationTest.javaExercise live crates.io retention +201/-0

Exercise live crates.io retention

• Checks that an upstream version appears before retention, downloads into Kellnr, counts bytes once, respects upstream blocks, and reports external origin.

src/test/java/io/floci/aws/services/codeartifact/CodeArtifactCargoExternalConnectionDockerIntegrationTest.java

CodeArtifactCargoExternalConnectionImporterTest.javaTest index merging and fenced imports +364/-0

Test index merging and fenced imports

• Covers local-versus-upstream index lines, blocked retention, checksum mismatch, claims, concurrent writes, and fence changes.

src/test/java/io/floci/aws/services/codeartifact/CodeArtifactCargoExternalConnectionImporterTest.java

CodeArtifactServiceTest.javaExpect Cargo container IDs on repository creation +1/-1

Expect Cargo container IDs on repository creation

• Updates the repository creation assertion to include Cargo among container-backed formats.

src/test/java/io/floci/aws/services/codeartifact/CodeArtifactServiceTest.java

KellnrSidecarClientTest.javaTest Kellnr HTTP and package bridge behavior +468/-0

Test Kellnr HTTP and package bridge behavior

• Uses a local server to verify index and asset lookups, streamed downloads, publish wire bodies, token reuse, admin deletion, and repository locks.

src/test/java/io/floci/aws/services/codeartifact/KellnrSidecarClientTest.java

KellnrSidecarManagerTest.javaTest Kellnr teardown and request leases +133/-0

Test Kellnr teardown and request leases

• Verifies container teardown, deferred removal during active requests, and retry after failed removal without requiring Docker.

src/test/java/io/floci/aws/services/codeartifact/KellnrSidecarManagerTest.java

Documentation (1) +150 / -59
codeartifact.mdDocument Cargo endpoint and support boundaries +150/-59

Document Cargo endpoint and support boundaries

• Explains Cargo authentication, registry routes, Kellnr storage, crates.io retention, and the image setting. Records limitations including missing repository-to-repository upstream resolution and yank, owner, and search routes.

docs/services/codeartifact.md

Other (3) +146 / -0
EmulatorConfig.javaExpose the Kellnr image setting +9/-0

Expose the Kellnr image setting

• Adds a configurable image for per-repository Cargo containers, defaulting to ghcr.io/kellnr/kellnr:5.

src/main/java/io/floci/aws/config/EmulatorConfig.java

KellnrSidecarManager.javaManage leased Kellnr containers per repository +136/-0

Manage leased Kellnr containers per repository

• Starts Kellnr lazily, checks API readiness, and coordinates container release with active request leases and teardown.

src/main/java/io/floci/aws/services/codeartifact/KellnrSidecarManager.java

application.ymlSet the default Cargo sidecar image +1/-0

Set the default Cargo sidecar image

• Configures ghcr.io/kellnr/kellnr:5 as the default Kellnr image.

src/main/resources/application.yml

@qodo-code-review

qodo-code-review Bot commented Nov 14, 2026 •

Copy link
Copy Markdown

Code Review by Qodo

🐞 Bugs (0) 📘 Rule violations (1) 🔗 Cross-repo conflicts (0) 📜 Skill insights (0)

Grey Divider


Action required

1. Crates with uppercase names cannot be fetched ✓ Resolved

Resolving commit: a4b479e

Resolution reason
Lowercases the crate name (Locale.ROOT) before computing the sparse-index bucket directories and
index filename in SidecarUriUtils.cratesIoBucketPath, so Inflector resolves at in/fl/inflector; the
original casing is preserved for download and other identifiers.
Description
cratesIoBucketPath builds the bucket directories and index filename from the original-case crate
name instead of its lowercase form. For a mixed-case crate such as Inflector, the download route,
packageVersionExists, external-connection tryImport, and local asset fetch can request a path
such as In/fl/Inflector that does not match Cargo’s lowercase index path.

2. Listing packages fails for every repository ✓ Resolved

Resolving commit: a4b479e

Resolution reason
Implemented listPackages in KellnrSidecarClient: returns an empty list when the sidecar is not
running, otherwise paginates Kellnr's /api/v1/ui/crates listing and maps each crate name to a
PackageIdentifier with null namespace. Cargo listing no longer falls through to the throwing
default.
Description
Adding cargo to CONTAINER_BACKED_FORMATS makes listPackages call
KellnrSidecarClient.listPackages, which has no override and therefore uses the interface default
that throws UnsupportedOperationException. An unfiltered ListPackages request for any
repository, or one filtered to cargo, reaches that default and is converted to a 500
InternalServerException, even when the repository has never held a crate.

3. Network peers can alter stored crates ✓ Resolved

Resolving commit: a4b479e

Resolution reason
At PR head, the admin password is no longer the fixed admin/admin default.
KellnrSidecarManager.startContainer generates a fresh 256-bit random password per container
(generateAdminPassword, lines 157-158) and passes it via KELLNR_SETUP__ADMIN_PWD (line 170).
KellnrSidecarClient.adminLogin reads it from manager.adminPassword(...) (line 807) rather than a
hardcoded value. The docs and javadoc were updated to describe this, matching the suggested fix's
core remedy (unique per-container password set via KELLNR_SETUP__ADMIN_PWD), though the
network-isolation alternative was not applied, so a peer can still reach the port but cannot log in
with defaults.
Description
KellnrSidecarManager attaches each sidecar to a shared Docker network while adminLogin uses
Kellnr’s fixed admin/admin credentials, contrary to the documentation’s “second, real barrier” and
the class’s loopback-only reachability claim. A workload container on that network can reach the
sidecar directly, authenticate without the CodeArtifact token check, and mint a publish token or use
the admin deletion routes for crates in the reachable repository.

View high (1)
4. Cargo clients miss the mapped port ✗ Dismissed
Description
CodeArtifactCargoController.configJson advertises the URL returned by GetRepositoryEndpoint,
which uses Floci's default http://localhost:4566 base URL rather than the mapped port exposed by
testcontainers-floci. When a test obtains the Cargo endpoint through that module, Cargo follows
the advertised index and download URLs to port 4566 instead of the reachable Testcontainers
endpoint.


Remediation recommended

5. Oversized metadata can exhaust heap ✓ Resolved

Resolving commit: a4b479e

Resolution reason
A 10 MiB ceiling (MAX_PUBLISH_METADATA_BYTES) on the client-declared metadata length is enforced
before the readNBytes allocation; out-of-range values return HTTP 400 instead of allocating up to ~2
GiB.
Description
readMetadataPrefix passes the client-supplied metadata length directly to InputStream.readNBytes
without a metadata-specific bound. An authenticated publisher can supply a large metadata section
within the accepted multi-gigabyte envelope, forcing an enormous allocation before the crate is
checked or published.

6. Large index replies can exhaust heap ✓ Resolved

Resolving commit: a4b479e

Resolution reason
Replaced the unbounded transfer with a bounded read: body.readNBytes(MAX_SPARSE_INDEX_BYTES + 1)
capped at 16 MiB (MAX_SPARSE_INDEX_BYTES), returning Optional.empty() for oversized indexes, so heap
use is capped per lookup.
Description
fetchSparseIndex transfers the entire external HTTP body into an unbounded ByteArrayOutputStream
before parsing it. Every sparse lookup for a repository connected to crates.io can reach this path,
so an unexpectedly large upstream response can consume the server heap rather than fail at a bounded
index limit.

7. Fetch errors silently drop crate versions 📘 Rule violation ☼ Reliability
Description
In retainCrate, a catch (RuntimeException e) around externalConnectionClient.fetchCrate logs a
warning and returns false, so the version is skipped and the import loop continues. Any runtime
failure, such as a network error or sidecar fault, is handled the same way as a missing version, and
the only named benign case (AssetTooLargeException) has its own separate catch.
Code

src/main/java/io/floci/aws/services/codeartifact/CodeArtifactCargoExternalConnectionImporter.java[R133-136]

+                } catch (RuntimeException e) {
+                    LOG.warnv(e, "Could not fetch {0} {1} from {2} while retaining a Cargo crate through an "
+                            + "external connection.", packageName, version, externalConnectionName);
+                    return false;
Relevance

●●● Strong

Narrowing broad RuntimeException catches to benign cases was accepted in several PRs; the team
favors explicit suppression.

PR-#5849
PR-#5895
PR-#6090

ⓘ Recommendations generated based on similar findings in past PRs

Evidence
The broad catch (RuntimeException e) logs and returns false for any fetch failure. The rule
requires catching only specific types or known benign cases, and letting non-benign failures
propagate so the operation can fail.

Rule 3865600: Do not swallow exceptions broadly; suppress only known benign errors
src/main/java/io/floci/aws/services/codeartifact/CodeArtifactCargoExternalConnectionImporter.java[125-137]

Agent prompt
The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`retainCrate` catches every `RuntimeException` from `externalConnectionClient.fetchCrate`, logs a warning, and returns `false`. Real failures such as connection errors or sidecar faults are therefore indistinguishable from an absent version, and they never fail the import.

## Fix Focus Areas
- src/main/java/io/floci/aws/services/codeartifact/CodeArtifactCargoExternalConnectionImporter.java[123-137]

## Recommended Fix
Catch only the specific benign outcome, for example a 404 that `fetchCrate` reports as an empty `Optional`. Let other `RuntimeException`s propagate so the caller can fail the import. If per-version skipping is intended for transient errors, make that explicit by catching a specific exception type and keep the warning log with its traceback. Add a test asserting that a non-404 failure is not suppressed.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

Dismiss ↗ | View ↗


View medium (6)
8. Failed imports leave temporary files ✓ Resolved

Resolving commit: a4b479e

Resolution reason
N/A
Description
buildStagedWireBody creates a temporary file but does not delete it if writing the headers or
copying the crate raises an exception. The caller enters its cleanup block only after that helper
returns, so a staging failure leaves the partial file behind in the temporary directory.

9. Large crate copies load the whole file into memory ✓ Resolved

Resolving commit: 73fe462

Resolution reason
The Path-based overload was rewritten to stage the length-prefixed wire body to a temp file by
streaming the crate bytes through Files.copy, then publish the staged file via publishRawWireBody
under lockFor, deleting the staged file in finally. No whole-file byte[] is held in memory.
Description
KellnrSidecarClient.storePackageVersionAsset(Path, long) calls Files.readAllBytes and then
builds another full-size publish body, holding roughly twice the crate size on the heap.
CopyPackageVersions and its restoration path use this overload for assets accepted up to 5 GiB, so
large crates can exhaust the JVM or fail above the byte[] limit despite the documented
disk-streaming behavior; the importer’s buildStagedWireBody and publishRawWireBody show a
streamed approach.

10. Every crate lookup waits on a live crates.io call ✗ Dismissed
Description
mergeExternalVersions calls fetchSparseIndex on index.crates.io for every sparse-index request,
with no caching and no negative caching, before it answers. A cargo build that resolves hundreds
of crates makes hundreds of outbound round trips, and when crates.io is slow or unreachable (offline
CI, air-gapped hosts) each lookup can stall for the 5s connect / 20s request timeout, including
lookups for crates that exist only locally.

11. Retained crates break dependency resolution ✓ Resolved

Resolving commit: 03e2440

Resolution reason
The current head code maps renamed dependencies (package -> name, alias -> explicit_name_in_toml),
merges features2 into features, and copies links and rust_version from the index line.
Description
metadataFromIndexLine copies an index dependency’s alias into the publish name instead of
mapping package to name and the alias to explicit_name_in_toml; it also drops features2,
links, and rust_version. When Kellnr retains an upstream crate, mergeExternalVersions serves
the rebuilt local index line instead of the upstream line, so Cargo can look up a nonexistent
dependency or lose dep: and weak-dependency features during resolution.

12. Publishes fail after a Kellnr container restart ✓ Resolved

Resolving commit: a4b479e

Resolution reason
Added sendPublishWithRetry: on a 401 from Kellnr it evicts the cached per-repository publish token,
mints a fresh token under a new admin login, and retries the request once. Both publish() and
publishRawWireBody() use it, so a container silently restarted by PerKeyContainerPool heals on the
next publish.
Description
publishToken caches the minted Kellnr API token per repository id and clears it only in
release(). PerKeyContainerPool.ensureReady silently replaces an unhealthy container with a
fresh, empty Kellnr under the same key, and the old token isn't valid there. From then on every
native cargo publish gets Kellnr's 401 forwarded verbatim, and every CopyPackageVersions or
external-connection retention for that repository throws, until Floci itself restarts.

13. Tests write private sidecar pool fields ✗ Dismissed
Description
seedPooledContainer uses getDeclaredField and setAccessible(true) to reach the private pool
field of KellnrSidecarManager and the private containers map of PerKeyContainerPool, then
inserts a fake container entry. Any rename or restructuring of those internals breaks the tests, and
the same reflective helper is duplicated in KellnrSidecarClientTest, spreading the brittleness to
both suites.


Informational

14. Cargo sidecar image uses a floating major tag ✓ Resolved

Resolving commit: 73fe462

Resolution reason
The cargo image default was changed from the floating major tag ghcr.io/kellnr/kellnr:5 to the
exact pinned version ghcr.io/kellnr/kellnr:5.14.1 in EmulatorConfig, application.yml and docs,
matching the other sidecar images.
Description
The cargoImage default ghcr.io/kellnr/kellnr:5 moves with every 5.x release, while every other
sidecar image is pinned to an exact version. KellnrSidecarClient relies on undocumented internal
routes (/api/v1/ui/delete_version, /api/v1/user/add_token, the login cookie), so a new minor
release can silently break delete, publish or token minting.

Grey Divider

Context sources
✅ Compliance rules (platform): 15 rules
✅ Web pages:
  +10 more
✅ Cross-repo context — repo relationships
  Explored: repo: floci-io/testcontainers-floci-go (sha: 8db9d48e) — View relationship
  Explored: repo: floci-io/testcontainers-floci-python (sha: e6b79f58) — View relationship
  Explored: repo: floci-io/testcontainers-floci (sha: e900a79e) — View relationship
  Explored: repo: floci-io/testcontainers-floci-node (sha: 1251b1d3) — View relationship
  Explored: repo: floci-io/testcontainers-floci-dotnet (sha: a011afd5) — View relationship
Review mode: Auto: 🧠 Deep: Confidence 3/5: broad protocol, importer, sidecar changes create many subtle risks.

Grey Divider

Tip of the day
💡 Did you know, you can ask Qodo to dismiss a finding you disagree with, with your reason on record

More tips ↗ | Customize Qodo ↗ | Qodo docs ↗

Grey Divider

Qodo Logo

@pgermosen pgermosen added codeartifact AWS CodeArtifact enhancement New feature or request labels Nov 14, 2026
@pgermosen
pgermosen force-pushed the feat/codeartifact-upstream-repo branch 2 times, most recently from a4b479e to 73fe462 Compare November 14, 2026 21:16
CodeArtifact's Rust/Cargo repositories had no native support at all: no sidecar,
no wire protocol, no external connection. Adds it following the same shape as
the existing Maven/npm/pypi/NuGet container-backed formats.

KellnrSidecarManager/KellnrSidecarClient run a real Kellnr container per
cargo-enabled repository and speak its native HTTP API for publish, download,
and the sparse index. CodeArtifactCargoController implements the real `cargo`
sparse-registry wire protocol (publish, download, sparse index lookup,
config.json) and forwards Kellnr's own publish rejections (e.g. republishing an
existing version, which the Cargo Book documents as permanently disallowed)
verbatim rather than swallowing them into an opaque error.

Adds the `public:crates-io` external connection via CargoExternalConnectionClient
(real index.crates.io/static.crates.io wire calls) and
CodeArtifactCargoExternalConnectionImporter, reusing the existing
claim/fence/retention-origin machinery the same way NuGet's own importer does.
Cargo's sparse index covers every version of a crate name in one file and a
real cargo client always consults it first, so unlike the other formats'
importers this one also merges real upstream-only version lines into the local
index response (mergeExternalVersions), a read-only proxy step with no
retention write of its own, so an upstream-only crate is actually visible to a
client's dependency resolution before anything is retained.

Fixes against the live Kellnr/crates.io protocols found while addressing
review: KellnrSidecarClient now implements listPackages (its absence made
every ListPackages call 500 once cargo joined the container-backed formats);
sparse-index bucket paths are lowercased per the Cargo Book's own spec
(crates.io's own index is case-sensitive about this even though a crate's
real name isn't); the admin account behind Kellnr's internal publish token is
given a fresh random password per container rather than Kellnr's own shared
default; a stale cached publish token (e.g. after a silent container restart)
is retried once rather than 401ing forever; both publish-body parsing and the
external sparse-index fetch are now bounded against an oversized allocation;
a renamed dependency's alias and real name are mapped correctly between the
index and publish shapes, and features2/links/rust_version now survive a
retained crate's synthesized metadata; the Kellnr image is pinned to the
exact version this was built and tested against rather than a floating major
tag.

Known gaps, called out in docs/services/codeartifact.md: no repository-to-repository
upstream importer yet for cargo (every other native format already has one), and
no yank/owner/search routes.
@pgermosen
pgermosen force-pushed the feat/codeartifact-upstream-repo branch from 73fe462 to 03e2440 Compare November 14, 2026 23:20
@pgermosen
pgermosen merged commit 15a632e into main Nov 14, 2026
26 checks passed
@pgermosen
pgermosen deleted the feat/codeartifact-upstream-repo branch November 14, 2026 23:51
@hectorvent

Copy link
Copy Markdown
Member

🎉 This PR is included in version 2.5.0 🎉

The release is available on GitHub release

Your semantic-release bot 📦🚀

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

codeartifact AWS CodeArtifact enhancement New feature or request released

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants