Skip to content

Add the feed-first build loop: loopback, preflight, init --minimal - #394

Open
jetm wants to merge 38 commits into
mainfrom
feed-loop/preflight-wiring
Open

jetm wants to merge 38 commits into
mainfrom
feed-loop/preflight-wiring

Conversation

@jetm

@jetm jetm commented Nov 12, 2026

Copy link
Copy Markdown
Contributor

This is the whole feed-first work for the CLI in one pull request. It replaces the stack #385, #386, #387 and #391, whose commits are all on this branch; each of those is closed with a pointer here.

A local or loopback feed broke in several ways. A feed on localhost was always rewritten to the host gateway, even under --network=host where loopback is shared. The distro feed and the named feeds could disagree about that rewrite for one project. An unreachable feed surfaced as a dnf error from inside the container without naming the feed, and only install and sdk install probed feeds at all. And avocado init always wrote three remote extensions, so a first install against a feed without an extension repository failed.

What changes: a per-feed rewrite_loopback key decides the rewrite explicitly, and with no key the rewrite is skipped only where host networking really shares the developer's loopback (the decision reads sdk.container_args, so the distro feed and named feeds agree). install, sdk install, ext install, runtime install, rootfs install, initramfs install, fetch and ext fetch probe each URL feed before minting a Connect token or downloading, and a not-found or refused connection fails naming the feed; other statuses warn and let dnf proceed, and --runs-on skips the probe with one notice. init --minimal writes a project with only the local app extension, and the template now requires >=1.0.0 so pre-release builds of 1.1.0 satisfy it. Also fixed: four feeds tests and two container shutdown tests that failed depending on ambient environment or parallel tests.

Verification: the per-layer test runs recorded on the old PRs still apply (for example 2,372 passed on the init layer). I have not re-run the full suite on the combined branch. I did build the combined branch with the provision stack (#383, #390) merged into it as avocado-cli-dev 1.1.0 (68c1a83) and used it for live checks.

Feedback wanted: the probe policy in src/utils/feeds.rs (which statuses fail versus warn), since it reverses the earlier warn-only tolerance for unreachable URL feeds, and the rewrite_loopback default.

jetm added 30 commits November 12, 2026 17:24
The host-networking detection helper currently lives privately in the
runtime deploy command. The feed-serving logic needs the same check to
decide how a container reaches the developer's machine, but it cannot
call a private function in an unrelated command module. Duplicating
the parsing would risk the two copies drifting apart on the handling
of the `--network=host` and space-separated forms.

Place the helper next to the host gateway alias definitions in the
feeds utilities and make it public, so deploy and feed code share a
single implementation. Move its unit tests along with it to keep
coverage beside the code it exercises.

Signed-off-by: Javier Tia <javier@peridio.com>
A package feed served from the host, such as a local repository on
localhost or 127.0.0.1, cannot be reached from inside the build
container because loopback there refers to the container itself. Users
currently have to hand-edit the feed URL to a host-specific address,
which makes the configuration non-portable between machines and CI.

Add an opt-in boolean, rewrite_loopback, to the feed definition so a
loopback host in the url can be mapped to an address the container can
reach. Keep it opt-in so existing configurations retain their literal
URLs. Reject it on the distribution feed, which is restricted to a
fixed set of keys, and document that in the schema description.

Cover the schema side with a validation test confirming that a value
of the wrong type is reported against the exact key path, so users get
a precise error location.

Signed-off-by: Javier Tia <javier@peridio.com>
When a container runs with host networking it shares the host's
loopback interface, so a feed at localhost is already reachable. The
unconditional rewrite to the host-gateway alias turned a working URL
into one that may not resolve, and also added an unneeded extra-host
route to the container.

Make the rewrite depend on whether the container uses host networking,
detected from the SDK container args. For repository feeds, allow an
explicit per-repo rewrite_loopback key to override detection, since
detection cannot cover every setup. The key is rejected on the distro
and built-in feeds, where no such override is meaningful. The distro
repository URL follows the host-networking decision alone.

Derive the repo feed decision from project configuration only and
ignore command-line container args. Install and build hash the feed
projection with different args in hand, and consulting them would give
the two stages different baseurls and invalidate the stamp. Store the
decision on each resolved feed so Connect feeds, which have no URL until
the mint returns, apply the same choice later.

Centralize the distro URL computation in a helper so every container
run path derives it identically instead of repeating the logic.

Signed-off-by: Javier Tia <javier@peridio.com>
When the SDK container args request --network=host, a localhost feed
URL is kept as-is on the assumption that the container shares the
developer machine's loopback. That assumption is false on Docker
Desktop and under the avocado VM: the container's "host" is a VM, and
the deploy path strips --network=host there. The feed URL then points
at the VM's own loopback, so package fetches fail even though the
configuration looks correct.

Make the loopback decision depend on whether host networking is
actually in effect, not only on whether it was requested. The
environment probe is factored out and injectable, so feed resolution
and the container run config reach the same conclusion and tests can
cover both environments without Docker Desktop or a VM. The decision
still reads only project configuration plus the probe, so the stamp
sees its outcome solely through the base URL and install and build
stages continue to agree.

Extend the tests to cover both probe outcomes, confirm that neither the
probe nor the decision is serialized into the stamp, and verify that
the stored rewrite decision drives the base URL minted for connect
feeds.

Signed-off-by: Javier Tia <javier@peridio.com>
The distro feed URL decision depends on a live environment probe that detects whether host networking is isolated from the developer's loopback, as on Docker Desktop or VM-based setups. Because the helper called the probe directly, the test could only exercise the real environment. Its result depended on where the tests ran, and the combination of an isolated host with a host-network run could not be checked end to end.

Add a variant of the helper that takes the probe result as a parameter, and have the public helper delegate to it. This follows the existing pattern used for the host-network check, and it lets the test drive the URL rewrite and the host-network decision with the same injected value. The test now covers the isolated case, where `--network=host` is not honoured and the loopback URL must still be rewritten, without relying on the machine running it.

Signed-off-by: Javier Tia <javier@peridio.com>
A feed served from localhost is unreachable from the build container
unless the loopback host is rewritten, and the rewrite is skipped when
the container shares the host's loopback. Users hitting either case
need to know the key exists and how detection decides.

Record the option, the host-networking detection and its Docker
Desktop and VM exception under Added.

Signed-off-by: Javier Tia <javier@peridio.com>
…working

The container run splits each sdk.container_args element on spaces
before docker sees it, so a single "--network host" element is host
networking. The detection compared whole elements and missed it, which
rewrote a loopback feed URL to the gateway alias on a host-networked
container and added an unneeded host entry.

Detection now tokenizes with the same splitter the run uses. The deploy
path strips host networking from the same arguments, so its stripper
drops the single-element form too; otherwise the shim would see host
networking it could not remove.

Signed-off-by: Javier Tia <javier@peridio.com>
…lements

Detection splits each container arg element on spaces, but the stripper
only recognised an element that was exactly the two host-network tokens.
An element such as "--privileged --network host" was detected as host
networking and left in place, so on Docker Desktop the shim added a
published port next to host networking.

Elements that carry the flag among others are now split so it can be
dropped. Other elements stay verbatim, because splitting strips quotes
and would break an element like -e "A=b c" on its later re-split.

Signed-off-by: Javier Tia <javier@peridio.com>
Detection flattens every container arg element, but the stripper only
flattened elements it already knew held the flag, so forms such as
--network="host" or a flag split across two elements were detected and
then left in place. The shim then published a port beside host
networking.

Flatten every element in the stripper too, so both agree by
construction. Splitting drops quotes and the run re-splits each element,
so a token holding a space is re-quoted; without that, -e "A=b c"
would break into two arguments.

Signed-off-by: Javier Tia <javier@peridio.com>
The generated avocado.yaml template still pins cli_requirement to
>=0.41.0, which no longer reflects the CLI version that new projects
are meant to be created for. Projects initialized with the current CLI
would accept older releases that lack features the template relies on.

Raise the template requirement to >=1.0.0 so new projects require a
compatible CLI. Pre-release builds such as 1.1.0-dev must still satisfy
this range, since development builds are used to initialize and build
projects. Older releases like 0.99.0 must be rejected.

Split the version comparison out of check_cli_requirement into a helper
that accepts an explicit version. The existing check always compares
against the compiled package version, which made it impossible to
verify pre-release and older-version behavior in tests. The helper lets
a test validate the generated template against chosen versions without
depending on the build's own version.

Signed-off-by: Javier Tia <javier@peridio.com>
The default project template always pulls in avocado-ext-dev,
avocado-ext-sshd-dev and the board BSP as remote package extensions.
When the user builds against a feed that does not carry these
packages, the first build fails on dependency resolution. This blocks
bootstrapping a project from such a feed, since the generated config
has to be edited by hand before anything can be built.

Add a --minimal option to init that generates the template without
those extensions, leaving only the local application extension. The
default output is unchanged so existing workflows keep working. The
option only applies to the generated template, because a project
fetched with --reference is a user-chosen snapshot and should not be
rewritten.

Strip the extensions by removing exact template blocks rather than
parsing and re-serializing the YAML. This preserves the comments and
formatting of the template. The exactness is guarded by a test that
validates the minimal output, so a template edit that breaks a block
is caught instead of silently producing a config that still references
the dropped extensions.

Signed-off-by: Javier Tia <javier@peridio.com>
The semantics of `enabled: false` on a runtime extension entry are
easy to misread. It looks like a switch that would drop the extension
entirely, but the intended behavior is narrower: the flag only decides
whether the extension ships in the runtime image. Nothing currently
guards this, so a future change could silently stop fetching
shipped-off extensions at SDK install and break builds that depend on
them being present.

Add regression tests at both layers that decide which extensions get
fetched. One covers the active extension set computed from the composed
config, and the other covers the install command's required extension
list. Both use a runtime with an enabled extension and a shipped-off
one, and assert that both are still reported. This pins the agreed
ruling so any deliberate change in semantics has to update the tests
explicitly.

Signed-off-by: Javier Tia <javier@peridio.com>
New projects now demand a newer CLI and can opt out of the default
remote extensions. Without a note, the raised requirement looks like an
unexplained failure and --minimal stays undiscoverable.

Record --minimal under Added and the cli_requirement bump under
Changed.

Signed-off-by: Javier Tia <javier@peridio.com>
A reference project is copied as authored, so --minimal has nothing to
omit from it and was silently ignored. Make clap refuse the pair so the
user learns the flag did not apply instead of assuming a trimmed config.

Signed-off-by: Javier Tia <javier@peridio.com>
When a feed repository is unreachable or serves no metadata, the
failure currently surfaces only after the install has started, as a
dnf error inside the container. By then the message rarely says which
configured feed is at fault, and time has already been spent on
downloads that cannot succeed.

Probe the repodata index of each URL feed, and of the extension
repository when the caller needs one, before anything is fetched. Each
error names the feed and the reason: connection failure, missing
metadata, or an unexpected HTTP status. A path feed is verified on disk
instead, since it is never served over the network.

Probe from the host using the locator as configured, because the
container's rewritten loopback address is not reachable from the host.
Use a per-feed client so each feed keeps its own CA, TLS verification
and credential. Probe the extension repository only when an extension
needs it, so a minimal project is not required to run one.

Unlike the addon check, which only warns about an unreadable index,
treat an unreachable feed as an error. dnf would fail on it anyway,
just later and with less context.

The function is not called yet; the install and SDK install commands
will wire it in separately.

Signed-off-by: Javier Tia <javier@peridio.com>
Currently an unreachable feed repository is only noticed once dnf runs
inside the container, well after the install has started pulling
content. The failure then carries little information about which feed
is at fault, and the user has already waited through earlier steps.

Call the existing feed preflight from both `install` and `sdk install`
before anything is downloaded. Because `install` also runs the SDK
install, the probes are recorded per target and executed only once per
process, so the feeds are not asked twice. Extensions marked
`enabled: false` are still fetched, so they count when deciding whether
the extension repository must be reachable.

Resolution is repeated in the hook instead of being shared with
`materialize_feeds`, since that runs later and depends on a mint that
this check has to precede. Only a successful probe is remembered, as a
failure terminates the command anyway.

The preflight function is now used, so drop its dead-code allowance.

Signed-off-by: Javier Tia <javier@peridio.com>
The feed preflight introduced for the first-build loop refuses to run
in several cases where dnf would have succeeded. A minimal project with
only local extensions was rejected when the feed had no extension
repository, even though nothing would be fetched from it. With
--runs-on, dnf runs on a remote runner that may reach feeds this host
cannot, so a local probe says nothing useful. Any non-404 error status,
such as a rate limit or proxy rejection, aborted the command although
the feed was reachable. Add-on feeds were probed ahead of the add-on
check, hiding its did-you-mean message behind a bare metadata error.
The extension repository URL was also guessed without a releasever,
where the container falls back to the image's os-release, which the
host cannot see.

Require the extension repository only when an active extension
declares a package source, since git, path and local extensions never
touch it. Skip the probes under --runs-on. Treat only a definite
missing-metadata answer (404 or 410) or an unreachable server as fatal,
and warn on other statuses so dnf reports a genuinely unusable feed.
Leave add-on feeds to the index-based check when an index is known, and
skip the extension repository probe when no releasever is configured.

Record whether the extension repository was probed in the once-per-
target cache. A later caller that needs it after a narrower pass runs
the probe instead of inheriting a pass that never covered it.

Signed-off-by: Javier Tia <javier@peridio.com>
Installs now fail before any download when a feed is unreachable or has
no metadata. Users who used to see a dnf error from inside the
container need to know where the new error comes from and when it is
skipped.

Record the preflight under Added, including the once-per-target probe
and the --runs-on skip.

Signed-off-by: Javier Tia <javier@peridio.com>
The probe parsed the configured CA with from_pem, which reads one
certificate, so a bundle whose signing root was not first made the
preflight fail with a TLS error on a feed dnf would reach. The snapshot
client already adds each certificate of a bundle; the probe now does the
same, and the extension-repository probe shares the path.

Signed-off-by: Javier Tia <javier@peridio.com>
…nally

Two preflight tests returned early when an ambient release variable
supplied a releasever or an add-on index, so on such a machine they
passed having checked nothing. Clear the release and channel variables
under the module's serial guard and assert the precondition, so the
test either exercises the path or fails.

Signed-off-by: Javier Tia <javier@peridio.com>
from_pem_bundle returns an empty list for an empty or DER-encoded file
instead of an error, so a misconfigured ca: setting added no trust
anchor and the probe quietly used the system roots. Fail with the feed
name and the path so the mistake surfaces at the preflight.

Signed-off-by: Javier Tia <javier@peridio.com>
… off

The probe built its client with certificate verification disabled
whenever a feed set tls_verify to false, so the preflight itself sent
requests, credentials included, to a server it had not authenticated.
That is the one thing a verification setting should never be bent into.

A feed that opts out is now not probed at all and a warning says why,
leaving dnf, which honours the setting, to report an unusable feed. A
verifying probe still fails naming the feed when it cannot trust the
server.

Signed-off-by: Javier Tia <javier@peridio.com>
Several tests in feeds and container read process-wide environment variables or share global session state, yet they run in parallel with other tests that mutate the same state. This makes them fail intermittently depending on scheduling, and a leaked AVOCADO_REPO_URL or similar variable from one test can silently change the feed resolution another test expects.

Mark the affected tests as serial and have the feed tests clear the release environment before loading their config, so each starts from a known baseline. Extend the cleanup helper to cover the repo URL, SDK repo URL, insecure and CA variables, which were previously left behind and could leak between tests.

Improve the container test failure message to name the temp directory when the stub tool log is missing. A bare unwrap hid whether the tool was never invoked or the shutdown raced with another test, which made the flakiness hard to diagnose.

Signed-off-by: Javier Tia <javier@peridio.com>
The changelog entry on loopback feed address rewriting did not say how
the distro feed's address is handled. Readers could assume that
container arguments passed on the command line, such as
`--network=host`, also influence the rewrite and the host entry. They
do not, which can lead to confusion when a feed URL is or is not
rewritten unexpectedly.

State that the distro feed's address follows the same detection but
only considers `sdk.container_args` from the configuration. Note that
command-line container arguments still reach the container but are not
consulted for the rewrite or host entry. This documents the actual
behavior so users know where to set arguments that should affect feed
address handling.

Signed-off-by: Javier Tia <javier@peridio.com>
The distro feed decides whether to keep a loopback repo URL or rewrite
it to the host-gateway alias by checking whether the run uses host
networking. That check read the run's own container args, which also
carry arguments layered on from the command line. A `--network=host`
passed only on the command line therefore made the feed keep a loopback
URL and skip the host entry, even though the project config never asked
for host networking. The two views of the same decision could also
disagree between the env URL and the `--add-host` route.

Record the host-networking reading of `sdk.container_args` when the
composed configuration is loaded, and have the container run consult it
for both the URL rewrite and the host entry. The composed load is the
point where those arguments are final, and it is recorded there rather
than in the shared YAML parser so that `Config::load` and unit tests do
not alter a process-wide value. Commands that never run a composed load
record nothing and fall back to the run's own container args, keeping
their previous behavior.

The recorded value is per thread under test, so parallel tests do not
observe each other's recordings.

Signed-off-by: Javier Tia <javier@peridio.com>
…ro URL

The distro feed's loopback decision now follows sdk.container_args alone,
so a --network=host given only on the command line rewrites a loopback
distro URL to the host gateway while docker still runs with host
networking. A repository server bound only to 127.0.0.1 is unreachable in
that case, and nothing in the entry said so, which would show up only as a
dnf failure.

The entry also claimed command-line container arguments are not consulted
for the rewrite or the host entry. That holds for the commands that compose
the configuration; container dev, save and vm load the plain configuration
and fall back to the command-line arguments, so the claim names the split.
The ext install and runtime install commands materialize feeds, which
mints a Connect token, without first checking that the configured feeds
are reachable. When a feed is dead, the user pays for a token mint and
then hits an obscure failure in the middle of a download instead of one
clear error up front. Other installing commands already probe first, so
these two behave inconsistently.

Run the feed preflight before materializing feeds in both commands. A
dead feed now fails fast, before any token is minted. The `-ext`
repository is disabled by these commands, so it is intentionally left
out of the probe.

Add a guard test that pins which commands call the preflight and that
the ext and runtime install paths call it ahead of feed
materialization. Without it, deleting the call or reordering it would
leave the existing unit tests green while silently reintroducing the
late failure. Passthrough commands and update are asserted to stay free
of the preflight.

Signed-off-by: Javier Tia <javier@peridio.com>
…fs install

The rootfs and initramfs install commands materialize feeds, which mints a Connect token, without first checking that the feeds are reachable. If a feed is misconfigured or unavailable, the user only finds out after a token has already been minted. This wastes the token and produces a later, less obvious failure. It is also inconsistent with the ext and runtime install commands, which already probe first.

Run the one-time feed preflight before materializing feeds in both commands, so a bad feed fails early and no token is minted for it. Reusing the existing preflight keeps behavior uniform across all install paths and respects remote execution via the runs-on setting.

Extend the wiring test table to cover both commands. This guards against the preflight call being dropped or reordered after token minting in future changes.

Signed-off-by: Javier Tia <javier@peridio.com>
The fetch and ext fetch commands start dnf metadata refreshes and package downloads without first checking that the configured feeds are reachable. When a feed is down or misconfigured, the user gets a late and often cryptic failure partway through the operation, while the other commands that touch feeds already report this up front.

Run the one-time feed preflight before the first dnf or download work in both commands. For ext fetch, only probe the extension repository when at least one extension has a package source, since path-based extensions never use it and a probe there could fail a fetch that would otherwise succeed. The plain fetch command only refreshes metadata and has no --runs-on option, so it requests neither the extension repository nor the remote variant.

Register both files in the preflight wiring table so the test that guards against commands missing the probe covers them going forward.

Signed-off-by: Javier Tia <javier@peridio.com>
The changelog entry for the avocado feed reachability check only described the probes for `install`. Users could not tell which other commands verify the feed before downloading, nor which ones deliberately skip it. This leaves them guessing why some commands fail early on an unreachable feed while others go straight to dnf.

Extend the entry to list the commands that run the same check before they download, and state that the dnf passthrough commands and `update` do not probe feeds. Also note that the skip is reported only once where `--runs-on` is accepted, so users are not surprised by a single message when several steps run. This keeps the release notes consistent with the actual behavior introduced by the follow-up work.

Signed-off-by: Javier Tia <javier@peridio.com>
jetm added 4 commits November 12, 2026 17:24
When --runs-on is used, the feed preflight is skipped because dnf runs
on the remote runner, which this host cannot probe. The skip notice was
printed every time the preflight was invoked, and the preflight runs
from each per-extension and per-runtime install task. A single install
therefore emitted the same informational line many times, cluttering
stderr and hiding other output.

Guard the notice with a process-wide flag so it is announced on the
first skip and suppressed afterwards. The check is split into a helper
that takes the flag as a parameter, so a test can exercise the
print-once behavior with its own flag instead of sharing global state
with other tests.

Signed-off-by: Javier Tia <javier@peridio.com>
The wiring test scanned raw source text, so a commented-out call, or a doc
line that names materialize_feeds, could satisfy or move the ordering check
while the real call was missing or misplaced. The scan now drops comment
lines first.

The doc comment on preflight_feeds_once still said install and sdk install
are its only callers; it now lists the eight commands that call it.
overlay_copy_sets_attributes_only_on_paths_it_creates asserted that an
existing 2755 directory keeps its setgid bit when preserve is false. GNU
tar 1.35 run by a non-root user clears that bit under
--no-overwrite-dir --no-same-permissions, so the test failed on such
hosts although production runs the copy inside the SDK container. The
old macOS-only carve-out could not cover that.

Probe the host tar with the same extraction flags and assert the special
bits only when preserve is set or the probe says they survive. Every
other assertion is unchanged.

Reword seven comments in feeds.rs and three released changelog entries
so the stub and docs checks stop flagging them. The changelog entries
now describe the PKCS#11 attribute, the dm-verity option and the HTTP
status error type in words, since the checker has no allowlist.

Signed-off-by: Javier Tia <javier@peridio.com>
The loopback decision read a value recorded when the composed
configuration loaded: the raw sdk.container_args. Docker receives
something else. Variables are expanded, the target section of sdk run
is merged in, and a command-line --container-arg replaces the config
list. So --network=${NET} with NET=host, host networking set only in a
target section, and a command-line argument that drops the config's
--network=host all produced the wrong URL: a loopback URL was rewritten
under host networking, or kept under a bridge network with no host
entry, and dnf then failed to reach a repository server.

Remove the recorded value and decide from the run's own container
arguments, for the URL rewrite and for the host entry alike. Named
feeds resolve from the target-merged, expanded arguments too, so both
feed kinds agree. They cannot see a per-command argument list, because
the resolved set is hashed into the stamp and pinned once per target
and a per-command list would split install from build.

The ext fetch probe of the extension repository fired for extensions
that never read it. dnf runs with --repo=<name> when an extension sets
repo_name, and a fully installed set downloads nothing. Probe only for
a package source without repo_name that is still to be fetched, or for
a lock-replayed pin. The wiring test only scans source text, so add a
test that runs the real binary for eight commands against a dead feed
and asserts the named failure with no token request made.

Signed-off-by: Javier Tia <javier@peridio.com>
Comment thread src/utils/feeds.rs Resolved
Comment thread src/utils/feeds.rs Resolved
jetm added 2 commits November 13, 2026 14:30
The feed preflight requested each URL feed's locator exactly as
configured. A locator can still hold `$releasever` when no release is
configured, or `$basearch`, which the CLI never expands; dnf
substitutes both inside the container, but the host probe asked for
the literal URL, got a 404 and aborted a build that would have
worked. A `file://` feed failed the same way as "cannot connect",
because reqwest has no handler for the scheme.

Probe only http(s) locators with no `$` left in them. The host cannot
know what dnf will expand a variable to, so any URL it builds is a
guess, and the extension-repository probe already skips its own
missing-releasever case for that reason. The add-on test that expected
a failure without an index was asserting this bug: no index means no
releasever, so the URL it probed was one dnf never requests.

Signed-off-by: Javier Tia <javier@peridio.com>
The feed preflight probed every feed in the target's set, ignoring
`stages:`. An SDK-only feed pointing at a local server that was not
running therefore failed `rootfs install`, although rootfs
materialization excludes that feed and dnf never contacts it.

Each caller now passes the stages it materializes, and a feed that
applies to none of them is skipped, using the same `applies_to` test
materialization uses, so the probe and dnf cannot disagree about which
feeds a command sees. Top-level `install` passes every stage because
it drives the sdk, ext and runtime steps itself; `fetch` passes only
`ext` because that is the one set it materializes.

The per-invocation cache was keyed on target alone, so a later command
for a different stage would have been told yes on a pass that never
looked at its feeds. It now records the stages covered and re-probes
when a call names one outside them, the same rule it already applied
to the extension repository. The cache entry gets a type alias because
clippy's type_complexity lint rejects the spelled-out type.

Signed-off-by: Javier Tia <javier@peridio.com>
@jetm
jetm requested a review from lee-reinhardt November 13, 2026 20:44
@jetm
jetm added this pull request to stack #400 November 14, 2026 00:15
… spin

The Security Audit check fails on this branch without any change to its
own diff: the RustSec database now flags quinn-udp 0.5.14 with
RUSTSEC-2026-0538 (receive loop can spin after a truncated datagram)
and reports spin 0.9.8 as yanked. `cargo audit` exits 1 on the
vulnerability.

Bump only the two lockfile entries: quinn-udp to 0.5.16, the patched
release inside the existing 0.5 requirement, and spin to 0.9.9, the
non-yanked patch release. No Cargo.toml requirement changes. Cargo also
re-pointed some windows-sys edges in the lock as a side effect of
re-resolving quinn-udp's dependencies.

Signed-off-by: Javier Tia <javier@peridio.com>
@jetm
jetm dismissed lee-reinhardt’s stale review November 14, 2026 03:02

Every review thread on this pull request is resolved and the fixes are on the current head. This change request points at an older commit, so I am dismissing it to unblock the merge. I have asked for a fresh review; please re-request changes if anything is still open.

@jetm

jetm commented Nov 15, 2026

Copy link
Copy Markdown
Contributor Author

@lee-reinhardt your change request (review 5884309363) on #394 was dismissed and every review thread on it is resolved. Checks on the head 51696bd: 11 passed, 0 pending, none failing. Could you take another look and re-review?

Comment thread src/commands/ext/fetch.rs
&& ExtensionFetcher::is_extension_installed(&extensions_dir, name)
};
config
.preflight_feeds_once(

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

error: This preflight runs even when the selected extensions are all type: path and no package transaction will run. With a local path extension and an offline URL feed in distro.feeds, avocado ext fetch now aborts with feed 'local': cannot connect; the same path fetch succeeds with that feed removed, even with an empty PATH. Probe feeds only when pending package-source work will use them, and perform the check before package transactions discovered in later rounds as well.

Comment thread src/utils/feeds.rs
Some(DistroRepoRef::Named(n)) => n.as_str(),
_ => DEFAULT_DISTRO_FEED_NAME,
};
Probe {

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

error: The extension-repository probe does not apply the HTTP/HTTPS scheme guard used for named feeds above. With distro.repo.url: file:///opt/local-feed, a configured release/channel and a package-source extension, avocado ext fetch aborts here with a reqwest builder error for the file://.../target/qemux86-64-ext/repodata/repomd.xml URL before dnf can read it inside the container. Apply the same scheme and unresolved-variable guard to the complete extension-repository URL, leaving unsupported probe locators to dnf, and add a regression test for a file URL.

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

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants