github getnora-io/nora v1.4.6

59 minutes ago

[1.4.6] - 2026-11-17

Added

  • The Docker repository page filters its tags (#855) — the page of a repository lists its tags under a filter box: type part of a tag name, and the list keeps the tags that contain it, whatever the case. The heading says how many match, and a filter nothing matches says so. The filter is a plain form, applied when Enter is pressed, so the page needs no script for it. Without a filter the list of tags is as before.
  • nora mirror go fills the Go module proxy for an offline go mod download (#1185) — nora mirror had no Go subcommand: nora mirror go exited with unrecognized subcommand 'go', and Go modules could only be seeded by running the go command through NORA once. nora mirror go --modfile go.mod now reads the requirements of go.mod and the go.sum beside it (or the one given with --sumfile) and fetches each module version through NORA's /go/ proxy, so NORA stores it under the key it serves and curation judges it as it judges a go client. A required module gets its .info, .mod and .zip, after the replace directives: a module replaced by another is fetched as the replacement, and a module replaced by a directory is skipped. A version that go.sum lists with a module hash gets the same three files, and a version listed only with a /go.mod hash gets its .mod, which the go command reads to build the module graph — unless go.mod's go line is older than 1.17 or missing: then go mod download downloads every module of the graph, and every go.sum version gets all three files. A directory replacement may be quoted, a space included (=> "../local module"). A requirement on a branch, tag or commit (vnext, master) is resolved through its .info, and the files of the version it names are fetched, as the go command fetches them; a query the go command resolves from the version list (latest, v1, v1.2) stops the command with its line and a hint to run go mod tidy. Paths and versions are escaped as the go command escapes them (github.com/BurntSushi is asked as github.com/!burnt!sushi). A file NORA cannot serve fails its module version, and the command exits non-zero. A go.mod or go.sum line that cannot be read stops the command with its file and line number, before anything is fetched. Measured with go 1.22.5 against a store filled only by nora mirror go, with the upstream and every other host unreachable: go mod download, go build, go mod verify and go list -deps -test all of a project with 10 requirements and 26 go.sum lines succeed; with go 1.22.5 and 1.26.3, go mod download, go build and go mod verify succeed for a go 1.16 project whose go.sum lists a dependency only with its /go.mod hash, for a go.mod without a go line, for a quoted directory replacement with a space, and for requirements on vnext and master. On 1.4.5 the command does not exist.
  • Docker metadata_ttl can be set per upstream (#1222) — one [docker] metadata_ttl window applied to every proxied tag, so an operator either revalidated every tag of every upstream, with the extra round trips and rate-limit pressure that brings, or served a re-pushed upstream tag stale. A [[docker.upstreams]] entry can now set its own metadata_ttl, in the same values: a positive number of seconds serves a tag copy from cache for that long, and a value that is not positive revalidates every pull. A copy takes the window of the upstream whose storage namespace it is stored under. An upstream without the key follows the global value, so a config without it behaves as before. A copy from the fallback chain (an upstream without prefix or namespaces) is stored under the first upstream's namespace, and takes that upstream's window.

Fixed

  • A NuGet release keeps its age when the registration is refetched (#1146) — with min_release_age set and upstream dates not trusted (NORA_TRUST_UPSTREAM_DATES=false, the default), a NuGet version's age was the modification time of the cached registration document, and every refetch after NORA_NUGET_METADATA_TTL rewrote that file, on a 304 too. A release that clients asked for more often than the minimum age never matured: the download was refused with "package is 0h old". NORA now records, per package, when it first saw each version listed in a registration index or page, and the age of a version counts from that moment: a refetch, 200 or 304, keeps it, and a version a later registration lists starts at zero. The record sits in storage next to the cache, survives restarts, and is carried by nora backup and nora migrate; a registration cached before the upgrade starts the versions it lists at its last write time. Other formats that date a release by a rewritten metadata file (pub, Conan, Cargo, Terraform, PyPI) are not changed by this entry.
  • A store-side copy on Google Cloud Storage overwrites an existing object again (#1162) — object_store 0.13 had the GCS copy modes swapped (apache/arrow-rs-object-store#712): an overwrite sent x-goog-if-generation-match: 0, so a copy onto an existing object failed with 412 Precondition Failed, and a create-only copy never refused. NORA now uses object_store 0.14, which sends the precondition only for a create-only copy. S3, local and in-memory storage were not affected. Fixed by @jgrund.
  • UI pages no longer stat each stored file (#1172) — the Go namespace pages and a Go module's versions page, and the npm, Cargo, PyPI, Conan, Pub, Ansible, Terraform and Raw package pages, listed storage and then read each listed file's size and time with a separate stat(), one after another. On S3 that is a HEAD request per stored version on every visit, so the pages slowed down as the cache grew. They now take size and time from the listing itself, which already carries them: a page costs the same number of storage requests whether a package has 3 versions or 40, and shows the same sizes and times as before. Measured on an S3 test server with one Go module of 200 cached versions: /ui/go went from 602 HEAD requests and about 3.3 s a visit to none and 0.3 s, the module page from 201 and 1.5 s to none and 0.5 s. On S3, a Go module version or a scoped npm tarball written by NORA 0.9.2 or earlier (before #534 changed how @ is written in object keys) still shows as cached with its own size and time: where the prefix holds an @, these two pages also list its old form on S3, one more request a visit (GCS never wrote that form and is not asked). If a listing fails, they read each version's metadata as before instead of showing stored versions as not cached, and log a warning.
  • npm: tarball links follow the instance that serves them (#1180) — a packument NORA keeps names each tarball at the public_url of the instance that wrote it. A store moved to another address sent npm install without a lockfile to the old one: ECONNREFUSED on 1.4.2, and ETARGET from 1.4.3, where the versions with links outside NORA and the upstream are left out. Now a link of NORA's own form to a tarball NORA holds moves to the serving instance's address, in the cached packument and in published ones, when the link names this instance's current address or the address NORA wrote into the copy when it stored it. A copy stored by an earlier release has no such record: its links to another address are external, and the packument is fetched again while the upstream answers, which writes the record. A version whose tarball NORA does not hold stays out of the packument while the upstream is down, as before.
  • A proxied artifact served right before a stop is kept (#1181) — A graceful stop now waits for the proxy cache writes that run after their response, within the same 10 seconds it already gave the background schedulers, so an artifact served right before the stop is kept and is served after a restart even without the upstream. The total stop time does not grow. A write still running at the end of those 10 seconds is named in a warning and fetched from the upstream again later.
  • Downloads no longer wait out the object store's retries while the store is down (#1182) — with S3 or GCS storage stopped or not answering, a download waited for the store client's retries before NORA answered: about 70 seconds to a minute or more, or until the client gave up when the store took connections but never answered, and then often with a 404 or 500 that clients take as final. A read now waits at most [storage] answer_timeout_secs (default 10, env NORA_STORAGE_ANSWER_TIMEOUT_SECS) for the store to answer; a body that has started streams at its own pace as before. A request the store left unanswered is answered 503 Service Unavailable with Retry-After: 30 instead of the 404, 500 or 502 it would have had; any other answer, including what a proxy served from its upstream, is unchanged. While the store has not answered, proxied artifacts are served without being cached and writes are refused at once with 503, until the store answers again. /ready is unchanged. Set answer_timeout_secs = 0 to wait as long as the store client retries, as 1.4.5 did, for example for a slow store that is recovering.
  • nora mirror pip and nora mirror cargo fill a store that an offline client installs from (#1183) — nora mirror pip fetched only the project page /simple/<name>/ of each requirement, and nora mirror cargo only the .crate files. Both still reported every package as mirrored. In an isolated network, pip install against the store found no version (from versions: none) and cargo fetch got 502 for every sparse index entry. Now nora mirror pip fetches every file of the pinned version of each requirement: each wheel and the sdist, because the platform and Python version of the client that installs later are not known. nora mirror cargo fetches the sparse index entry of every locked crate as well as its .crate. A requirement that is not pinned to one version (>=, ~=, a wildcard or no version) names no files, so it is reported as failed and the command exits non-zero. A requirement whose files NORA cannot serve, or a crate whose index entry is missing or does not list the locked version, is reported the same way. Requirements files written by pip-compile --generate-hashes are now read correctly: before, continuation lines, --hash options, extras and environment markers were read as package names and versions. Measured with pip 22.0.2 and cargo 1.96.0 against a store filled only by nora mirror, with every upstream unreachable: pip install of requests 2.32.3 and its four dependencies, and cargo fetch --locked of five crates, now succeed. On 1.4.5 both fail.
  • nora mirror docker mirrors multi-platform images (#1184) — for an image published as an index (alpine:3.20, and most official images), the mirror stored only the linux/amd64 manifest and then pushed an index that lists every platform and attestation, so NORA refused it: rejecting manifest push: references an absent blob/sub-manifest (sha256:6243dec9…) (the amd64 attestation, the second entry of the alpine:3.20 index) and Mirror failed: 1 packages failed. An image pinned by its index digest (alpine@sha256:…) failed as well, because the platform manifest was pushed under the index digest. Now every manifest an index lists, and every blob those manifests reference, is stored before the index, platform manifests under their own digests, so the tag or the pinned digest is the upstream index byte for byte and pulls on any of its platforms. An index that lists another index is followed down (at most 4 levels). Mirroring a multi-platform image therefore downloads and stores all its platforms, not one. Separately, after a docker pull of the image through NORA, NORA reported the cached blobs present, the mirror skipped them, and the manifest push was refused because the repository itself did not hold them; the mirror now asks NORA to mount such a blob into the repository (POST /v2/<name>/blobs/uploads/?mount=<digest>&from=<name>) and uploads it when the mount is not possible.
  • [tls] ca_cert now covers the S3 and GCS storage client (#1186) — the CA bundle named by [tls] ca_cert (NORA_TLS_CA_CERT) was trusted only by the clients for upstream registries and import. An S3-compatible store with a certificate from a private CA (MinIO, Ceph RGW, an on-prem gateway) was refused at the handshake, so /ready stayed 503 and every write failed with a log that said nothing about the certificate. The object store client now trusts every certificate in the bundle as well, on top of the system trust store, which stays in use; nora migrate builds both ends the same way. A bundle that cannot be read or holds no usable certificate stops a start on S3 or GCS with exit code 78 and the bundle's path. Deployments on local storage do not read the bundle for storage.
  • Docker: a tag that no upstream has is remembered for a short time, and concurrent requests for it share one round of upstream requests (#1192) — a manifest that exists nowhere reached every upstream on every request: a CI loop over a missing image multiplied the load on the upstreams until they rate-limited NORA, and then public pulls failed as missing too. Now the first request asks the upstreams, concurrent requests for the same tag wait for that answer, and a tag that every upstream answered not found for is answered 404 without asking again for [docker] miss_ttl seconds (NORA_DOCKER_MISS_TTL, default 30; 0 turns the remembering off). A miss is remembered only when every upstream asked said not found: an upstream that failed, refused NORA's credentials, or rate-limited it leaves the miss unremembered. A tag pushed to NORA is served at once. Referrers tags (sha256-…) are never remembered, so their answers during an outage are unchanged.
  • Docker tags/list lists the tags of the upstream a name routes to (#1218) — GET /v2/<name>/tags/list read only NORA's own storage, so for a name that is proxied (Docker Hub, or a [[docker.upstreams]] entry) it listed only the tags already copied, and a client that resolves versions through this endpoint, such as Renovate's Docker datasource, saw only those. The listing now merges the upstream's tags with the local ones, in ASCIIbetical order, the way manifests/<tag> resolves them, and reads every page the upstream sends, whether its Link header comes in one field or several. It honours n and last, and sends a Link header with rel="next" when more tags follow. A short name also lists the tags of its library/ official image. A name with a push of its own is hosted: its listing is answered from local storage, without asking the upstream. Curation refuses a name it blocks before any upstream is asked, an internal namespace is never sent upstream, and a name no upstream serves is answered from local storage only. An upstream that refuses NORA the listing with a 403 makes the answer 502 with a DENIED body, never an empty list. When an upstream fails, a listing with local tags is served as stale (X-Nora-Stale: true) if serve_stale is on, as a stale manifest is; otherwise, and when there are no tags to serve, the answer is 502 with an UNAVAILABLE body. When the registry cannot read the keys of its own pushes, the listing answers 503 and asks no upstream, rather than listing the copies it could read.
  • terraform init works on a warm cache while the Terraform upstream does not answer (#1230) — with an upstream that accepts the connection and never answers, every Terraform metadata request waited for NORA_TF_PROXY_TIMEOUT twice before the stored copy was served (the failed request was retried once first): about 61 s with the default 30 s, while Terraform gives up on a mirror request after 10 s and tries twice, so terraform init failed although every provider it needed was cached. The network mirror index.json and {version}.json also came back unmarked, with Cache-Control: public, max-age=60, nothing was logged, and with the circuit breaker on, an open breaker answered 503 instead of the stored copy. Now, when a stored copy is there to serve stale, the upstream is asked once, for at most the new revalidate_timeout (NORA_TF_REVALIDATE_TIMEOUT, default 5 s, never longer than proxy_timeout), and an open breaker serves the copy at once. With trust_upstream_dates on, the release-date query to registry.terraform.io shares that time with the revalidation, so download metadata and the mirror {version}.json also come within it. Every such answer, on the mirror paths and on the provider version list, download metadata and module version list alike, carries X-Nora-Stale: true and Cache-Control: public, max-age=0, must-revalidate, is logged as a warning and is counted in the new nora_proxy_stale_served_total{registry} metric; a request the stale version list answers with a 404 or 502 is neither logged nor counted. A stored copy that is not JSON is never served and does not cost the request its retry, and a version list the upstream answers with something that is not JSON is not stored: the stored copy is served stale instead. Measured with Terraform 1.9.8 against an upstream that never answers and default settings: terraform init now completes in about 11 s from the cache, where 1.4.5 fails after 21 s. With no stored copy nothing changes: the full proxy_timeout, one retry, then 502 (503 with the breaker open). A copy within metadata_ttl and a stored provider archive are still served without asking the upstream, and an upstream that answers still refreshes the copy. revalidate_timeout = 0 is refused at startup, since a stored copy would then never be refreshed.
  • A cached proxied image pulls while its Docker upstream is down (#1253) — with the upstream unreachable, answering 5xx or skipped for its open circuit breaker, docker pull of an image NORA had cached failed with every upstream registry failed to answer. Docker 29 (containerd image store) pulls the attestation manifest that BuildKit and Docker Hub put in an image index, and looks up its signatures and attestations under the tag sha256-<digest> (the OCI referrers tag schema); the upstream had answered 404 for that tag, NORA kept no copy of a 404 and answered the lookup 502, and docker ended the pull. With serve_stale on (the default), such a tag that NORA holds no copy of is now answered 404 MANIFEST_UNKNOWN with X-Nora-Stale: true while no upstream answers, as a registry without referrers answers it, and the pull completes. That 404 carries Cache-Control: no-store, so an HTTP cache in front of NORA does not keep it and go on hiding the tag once the upstream is back. Only that exact form (sha256- and 64 lowercase hex digits) is answered so: any other tag NORA has not cached stays 502 while the upstream is down, so a client does not conclude the image does not exist; an upstream that rate-limits NORA or refuses its credentials keeps its 429 or 502 DENIED; with serve_stale = false nothing changes. The lookup's 404 says only that NORA knows of no signatures or attestations at that moment; a verifier that requires a signature still fails.
  • The Hugging Face card on the dashboard opens a page, and Hugging Face is in the sidebar (#1257) — with Hugging Face enabled, the dashboard showed its card, but the card linked to /ui/hf, which answered 404, and the sidebar left Hugging Face out. /ui/hf now lists the repositories NORA has cached files for, each with its file count and size, and a repository's page lists its cached files by digest with the HF_ENDPOINT command to download through NORA; an id with no cached file has no page. The page answers to the repository id with its slash encoded or not, and in the Hub's own letter case. The sidebar lists Hugging Face when it is enabled, and every card on the dashboard now links to a page that answers.
  • The dashboard says when a registry's upstreams are hidden (#1258) — the Mount Points table showed - in the upstream column for a caller who is not signed in, the same as for a registry with no upstream, so a proxy that was configured and working looked unconfigured. The addresses stay hidden from such callers, as since #934. The column now reads "Hidden — sign in to see" where signing in is possible, or "Hidden" on an instance without authentication. /api/ui/dashboard says the same in a new proxy_hidden field per mount point. RPM and Debian upstreams, configured per repository, are reported like the other formats.
  • A command that exits on an error still writes its last log line (#1264) — NORA_LOG_FILE was written from a queue that process::exit did not drain, so the line logged just before an error exit, usually the error itself, could be missing from the file. NORA now writes the file from its own thread and gives the queue about a second to reach the file before any exit, a return from main or a panic. A log file that takes no writes holds up no request and no shutdown. tracing-appender is no longer a dependency.
  • A docker push to a proxied name succeeds after a pull of the same image through NORA (#1270) — after docker pull of an image through a proxied name, docker push of that image back to the same name failed: the client was told Layer already exists and then manifest references an unknown blob (400 MANIFEST_BLOB_UNKNOWN), although NORA held every layer. The layer probe found the copy the pull had cached under the upstream namespace, while the manifest check looked only under the bare name. The manifest check now looks up each layer and each sub-manifest of an index the same way the probe does, the namespaced copy and then the bare name, so the push is accepted.
  • migrate-docker-keys no longer writes a proxied copy under its namespace a second time (#1271) — the migration treated a key as already namespaced only when its first segment had a dot. A copy pulled through an upstream whose namespace has none, such as http://harbor:5000 (namespace harbor) or http://localhost:5000 (localhost), was taken for a bare image name and copied to docker/<namespace>/<namespace>/…. The namespace of each Docker upstream is now read from the configuration, explicit or derived from its URL, with the same rule the proxy uses, and such copies stay where they are. Legacy keys still move under the first upstream's namespace, and a name whose first segment holds a dot is classified as before. A bare key under an upstream's namespace is kept when it has no push record, because it cannot be told apart from a copy; a repository with a push record keeps its keys. --dry-run reports the same decisions as the real run.
  • Maven retention stops advertising the versions it deletes (#1281) — a retention rule deleted a Maven version's files but left the artifact's maven-metadata.xml as it was, so the document went on listing the deleted version, and <latest> or <release> could still name it. A client resolving RELEASE, LATEST or a version range picked that version and got a 404. Retention now removes the versions it deleted from the stored document, points <latest> and <release> at the highest version left, rewrites the document's checksums, and deletes the document when no version is left. Versions a hosted+proxy read merged in from an upstream (#885) stay listed. A retired SNAPSHOT's own maven-metadata.xml and checksums are deleted with it: left behind, they kept the version directory alive and the next deploy listed the version again. A dry run changes nothing.

Security

  • quick-xml 0.41 (RUSTSEC-2026-0194, RUSTSEC-2026-0195, #799) — with object_store 0.14 the lock no longer carries quick-xml 0.39, whose attribute and namespace parsing could exhaust memory on a crafted S3 response. The two advisories were accepted until now; cargo audit and cargo deny pass without them. Fixed by @jgrund.
  • Upstream addresses on the dashboard no longer show the credentials written into them (#1258) — for a signed-in caller, a read-only token included, the Mount Points table and /api/ui/dashboard listed each upstream address as configured. An address written with credentials in it, such as https://user:token@mirror.example/simple, showed them in full. The addresses are now read by the URL parser the proxy client uses and shown without their user:password@ part, in every spelling the client accepts. An address that parser cannot read is not shown. Credentials kept in the separate auth settings were never shown. If you wrote credentials into an upstream address, consider rotating them and moving them to the auth setting for that registry.
  • Upstream credentials written in an address stay out of every output (#1262) — Upstream credentials written in the address (https://user:secret@host) no longer reach /metrics, a 503 or 429 body, the log or the quarantine journal when the address is spelled https:///user:secret@host, https:/user:secret@host, https:user:secret@host or with backslashes. The proxy client accepts these spellings and sends the credentials, but the circuit breaker key and the log filter missed them, and the breaker key is a /metrics label that is readable without signing in by default. Every output now reads the address with the proxy client's parser. A password with a space, a quote or angle brackets, and an address written without a scheme, are masked too, and an upstream address refused at startup is no longer printed with its credentials. Docker: an upstream configured with credentials in its address and no namespace stored its proxy cache under the user name (docker/<user>/…), which the Docker list shows. The namespace is now the host. After the upgrade, images cached before are fetched from the upstream again into docker/<host>/…; offline, they are not served from the old place. The old directory stays in storage, and the Docker list keeps showing its name, the user, until it is removed: after upgrading, delete docker/<user>/ from storage. It holds that upstream's proxy cache, which is fetched again on the next pull; before deleting it, check that no image was pushed to NORA under a name starting with <user>/, since such an image is stored in the same directory. To keep that cache instead, either set namespace = "<user>" on that upstream before upgrading, which keeps the user in the storage keys and in the list, or move docker/<user>/ to docker/<host>/ in storage. A configuration file that cannot be read is now reported by its path, line and column and the parser's message, without quoting the line, which could hold the password of an upstream address; a value the message quotes is masked. The same applies to a reload on SIGHUP and to a skipped config.toml in the working directory.

Install

# x86_64
curl -LO https://github.com/getnora-io/nora/releases/download/v1.4.6/nora-linux-amd64
chmod +x nora-linux-amd64
sudo mv nora-linux-amd64 /usr/local/bin/nora

# ARM64 (Apple Silicon, Graviton, Ampere)
curl -LO https://github.com/getnora-io/nora/releases/download/v1.4.6/nora-linux-arm64
chmod +x nora-linux-arm64
sudo mv nora-linux-arm64 /usr/local/bin/nora

Docker

docker pull getnora/nora:1.4.6
Variant Image Platforms
Alpine (default) getnora/nora:1.4.6 amd64, arm64
RED OS getnora/nora:1.4.6-redos amd64
Astra Linux SE getnora/nora:1.4.6-astra amd64
GHCR ghcr.io/getnora-io/nora:1.4.6 amd64, arm64

DEB / RPM

# Debian / Ubuntu / Astra Linux (amd64)
curl -LO https://github.com/getnora-io/nora/releases/download/v1.4.6/nora-amd64.deb
sudo dpkg -i nora-amd64.deb

# RHEL / Fedora / RED OS (amd64)
curl -LO https://github.com/getnora-io/nora/releases/download/v1.4.6/nora-amd64.rpm
sudo rpm -i nora-amd64.rpm

Changelog

See CHANGELOG.md

Don't miss a new nora release

NewReleases is sending notifications on new releases.