dive/internal/source/source.go
Alex Goodman e97febbeb6
port image loading and analysis to stereoscope (#727)
* [wip] port to stereoscope

* revert wip stereoscope port

- the v1/v2 split behind `dev.use-stereoscope` is being replaced by an in-place port onto stereoscope
- reusable pieces (progress handlers, bubbletea setup) get pulled back from f14b994 as needed

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add docker-free image fixture builder

- `internal/imagefixture` writes deterministic image tarballs from handwritten layer specs: legacy `docker save`, docker 25+ OCI `docker save` (uncompressed, gzip or zstd layers) and plain oci-archive
- named fixture set covering whiteouts (file, dir, opaque, missing target), links, history edge cases, mode/uid only changes and duplicated files, plus the checked in `.data` save tarballs

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* record export and CI parity goldens from the current parser

- `internal/imagefixture/testdata/golden/<fixture>.export.json` and `<fixture>.ci.json` capture what the pre-stereoscope code produces for every fixture, so the stereoscope port can be checked against them without the old code
- regenerate with `UPDATE_GOLDEN=true go test ./cmd/dive/cli/internal/command/...`

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add stereoscope v0.3.4 and wire its bus and logger

- stereoscope publishes on dive's partybus and logs through dive's logger (nested under `from-lib=stereoscope`)
- `go` directive moves to 1.26.8 (stereoscope's minimum), CI bootstraps go 1.26.x to match
- `docker/cli` moves to v29.8.2 (via stereoscope), `docker/docker` to v28.5.2 so the existing resolver still builds against the newer `go-connections`
- `scylladb/go-set` stays on the pseudo version stereoscope pins (386 fix, never tagged); a `replace` back to v1.0.2 would break `go install ...@latest`

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* build linux releases with containers-storage support

- linux builds get `-tags containers_image_openpgp,exclude_graphdriver_btrfs` (same as syft), which compiles in stereoscope's containers-storage provider for podman/buildah stores
- still `CGO_ENABLED=0` and static; darwin/windows are unchanged since there's no local store there
- linux/amd64 binary grows about 7MB (21MB to 28MB)

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add stereoscope based image analysis

- `dive.Analyze(ctx, ref, img)` derives layer info (diff ID, history command, size) and efficiency stats from a
  stereoscope image, exposing the image itself on `Analysis`
- efficiency walks each layer's own tree and sizes whiteouts from the squashed tree of the layers below, no
  restacking
- a whiteout of a path no lower layer has is skipped instead of cutting the layer's walk short
- inefficiencies come sorted largest first with ties ordered by path
- `imagefixture.Load` reads a fixture through stereoscope

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* cover stereoscope efficiency on fixture images

duplicates, removed files and dirs, opaque dirs, whiteouts of missing paths and hardlinks

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add JSON export from the stereoscope analysis

`export.NewExportFromAnalysis` sits alongside `NewExport` with the same JSON shape:
- `layer[].id` and `layer[].digestId` are both the diff ID
- file lists walk each layer's own tree using the tar header as written, so hardlinks stay links
- implicit parent dirs (no tar header) are left out instead of showing up as empty entries
- `FileInfo` is now export's own type rather than `dive/filetree`'s

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* evaluate CI rules from a stats value

rules and the report read `ci.Stats` (efficiency, wasted bytes, user wasted percent, inefficient files) instead of
`*image.Analysis`, so both analyses can feed the evaluator. `ci.NewStats` reads the stereoscope analysis,
`ci.NewStatsFromImageAnalysis` the old one. Rules and report text are unchanged

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* check export and CI goldens against the stereoscope path

the golden tests now load every fixture through stereoscope and run `dive.Analyze`, `NewExportFromAnalysis` and
the CI evaluator. The old parser versions of these tests are gone (git history has their goldens).

every difference from the old goldens is intentional:
- all 17 `*.export.json`: `layer[].id` is now the diff ID (was the legacy layer dir hash, or `"blobs"` for OCI saves)
- `history-fewer-than-layers.export.json`, `no-history.export.json`: `digestId` is the diff ID even without a
  history entry (was `""`)
- `implicit-parent-dirs.export.json`: implicit parent dirs no longer show up as empty `path: ""` entries
- `duplicate-files-across-layers.{export,ci}.json`, `test-docker-image.{export,ci}.json`,
  `test-oci-docker-image.{export,ci}.json`: equal size inefficient files are ordered by path (was `sort.Sort` order)
- `whiteout-missing-target.{export,ci}.json`: a whiteout of a path no lower layer has no longer aborts the layer's
  efficiency walk, so `/opt/a` counts as 250 wasted bytes, efficiency goes 0.99 -> 0.5 and both rule sets now fail
  `lowestEfficiency` and `highestUserWastedPercent`
- `oci-archive-gzip`: layer order comes from the index now, but the fixture has one layer so only `id` changes

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add stereoscope based image source loading

- `source.Load` resolves a reference to a stereoscope image, caller owns `img.Cleanup()`
- accepts dive's `docker://` style and stereoscope's `docker:` style schemes
- new sources: oci-archive, oci-dir, registry (`oci-registry`), containerd, containers-storage, auto
- docker client keeps dive's host resolution (`DOCKER_HOST`, `DOCKER_CONTEXT`, config context, ssh hosts)
- podman reads containers-storage first on linux, then the podman socket
- `source.Build` wraps `docker build` / `podman build` and returns a loadable reference

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* accept the new image sources and add --platform

- `--source` / `container-engine` accept every `source.Sources` value plus the `docker-tar` and `oci-registry` aliases
- new `--platform` / `platform` option
- `Analysis.Reference` keeps the image argument as given (scheme included) for `source.Load`
- the old resolver path keeps working off `Analysis.Source` and `Analysis.Image`

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add bubbletea progress handlers copied from syft

- depend on `github.com/anchore/bubbly` v0.2.2 (brings in bubbletea v1.3.10)
- handlers for stereoscope's pull docker, pull containerd, fetch image and read image events, copied from syft v1.55.0 without the cataloger/SBOM parts
- per layer rows from the new `ReadLayer` event, nested under the read image row and dropped once each layer is indexed
- dive's `TaskStarted` events render as one task tree; tasks that reuse an ID (dive passes the image name for several tasks) still get their own row

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add a bubbletea progress UI that hands off to the TUI

- `ui.New` picks the bubbletea progress UI on an interactive terminal and the existing line based UI otherwise (no TTY, piped stdin, `--quiet`, `-v`, `NO_TTY`, or `CI` set)
- on `ExploreAnalysis` the progress program quits and restores the terminal before the gocui TUI starts; both UIs share one handoff function
- reports and notifications are held until the progress UI exits, the report text on stdout matches the line based UI
- ctrl-c / esc while the progress UI owns the terminal publishes an interrupt exit event
- console log output (dive's and stereoscope's, which share a logger) is muted while a UI draws, file logging is left alone

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* add a UI-only file tree built from stereoscope trees

- ported the view parts of `dive/filetree` (nodes, view info, render, sort, diff marks) into `ui/v1/filetree`
- the bottom of a layer range is the layer's precomputed `SquashedTree`, each top layer's own tree is compared in turn, same marks as before
- compare trees are built on demand per range and cached, instead of eagerly for every range
- "modified" content checks hash lazily through the image file catalog, only for files present on both sides with equal metadata, cached per file reference
- file metadata comes from the original tar header so hardlinks, sizes and modes look the same as before

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* run the TUI and extract on the stereoscope analysis

- `ExploreAnalysis` now carries a `*dive.Analysis` and blocks the publisher until the TUI is done with it, so the caller can clean up the image afterwards (the payload type sits in the `event` package for now, `payload` importing `dive` is an import cycle until the old resolvers go)
- layer views derive the id, short id and "FROM <id>" from the layer diff ID; image details list inefficiencies in their new (largest first) order
- extract reads the selected layer's files under the selected path from the loaded image instead of re-saving it, and writes them relative to the cwd as before, refusing absolute or `..` tar names, paths through symlinks that leave the cwd, and existing symlinks at a file's own path. It now matches the selected path exactly instead of as a string prefix
- temporary bridge: the old command path loads the image again through `dive/source` for the TUI

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* run dive and dive build on the stereoscope path

- both commands now go options -> `source.Load` -> `dive.Analyze` -> `--json` export, `--ci` evaluation or the TUI, the temporary bridge and the old resolver/adapter calls are gone
- `dive build` runs `source.Build` and loads the built image by its ID; `auto` builds with docker. It keeps the line UI since the build subprocess writes to the terminal
- `dive` uses `ui.New` (bubbletea progress UI where the terminal allows it)
- same task rows as before (Loading, Analyzing, Exporting, Evaluating, Building), and a failed task now stops its spinner
- every `source.Load` temp dir hangs off one generator and `source.Cleanup()` runs after `app.Run()`, so an interrupt (which skips the command's own cleanup) no longer leaves the image copy behind
- the "this can take a while" notification is dropped
- `--json` truncates an existing file instead of writing over its start
- `options.Analysis` keeps only `Image` (the raw reference), `V1UI` is now `LineUI`

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* delete the old image parser and file tree

- `dive/filetree`, `dive/image` (docker and podman resolvers included), `dive.GetImageResolver` and `command/adapter` are gone, stereoscope is the only image model now
- `export.NewExportFromAnalysis` is now `export.NewExport`, `ci.NewStatsFromImageAnalysis` is gone
- the `ExploreAnalysis` payload moves back to `internal/bus/event/payload`
- `docker/docker` is no longer a dependency

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* move the TUI from ui/v1 to ui/tui

- package `v1` is now `tui`, the line UI lives in `ui/line_ui.go`, no behavior change

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* deprecate --ignore-errors

- path errors no longer block the TUI, so the flag gates nothing. It is still accepted (flag and `ignore-errors` config) and warns when set

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* make the CLI tests run without docker

- tests that need docker or podman skip with the reason when the engine (or dive's docker config) isn't reachable
- new docker-free tests run the real command against docker-archive and oci-archive fixtures for `--json` (checked against the export goldens) and `--ci` pass/fail
- the default CI config test now runs `--ci` on the archive instead of relying on a load failure
- snapshots no longer embed the repo path; layer `id` in the JSON snapshot is now the diff ID, and inefficient file ties are ordered by path

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* move to golangci-lint v2

- v1.64.8 is built with go1.24 and refuses the go 1.26 module, binny now pins v2.14.0
- `.golangci.yaml` migrated with `golangci-lint migrate` (same funlen limits, default linters)
- fixes the staticcheck findings v2 reports

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* document the new image sources

- sources table with the new values, both scheme forms, `auto` and `--platform`
- podman reads containers-storage on linux (build tag, on in linux release builds) and the socket elsewhere
- pulls go through the docker API, layer `id` in the JSON is the diff ID, `ignore-errors` is deprecated

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* address review feedback on the stereoscope port

- `dive/source` moves to `internal/source`, and `dive.WalkTree` / `dive.TarHeader` are replaced by an internal `layertree` walker, so the only public surface left is `dive.Analyze` (which now honors ctx)
- docker client is built from the context endpoint (context TLS and ssh kept), `DOCKER_TLS` / `DOCKER_TLS_VERIFY` honored for env hosts
- podman client is built in dive and refuses ssh destinations, since stereoscope's fallback skipped host key checks
- registry http fallback limited to `localhost` and loopback literals, User-Agent no longer carries the binary path
- ctx reaches the TUI, cleanup waits for in-flight loads, and a second ctrl-c during cleanup no longer kills dive
- notifications always print (quiet aside), are escaped, show above the progress frame, and are drained on teardown
- extract writes with `O_EXCL` inside an `os.Root` and reports problems after the TUI exits instead of ending it
- TUI marks opaque whiteouts and their ancestors, implicit dirs no longer render Modified, failed hash reads aren't cached

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* keep go.uber.org/atomic v1.11.0 from main

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* allow CC0-1.0 licensed dependencies

`github.com/therootcompany/xz` (pulled in through stereoscope) is CC0-1.0, a public domain dedication like the already allowed `Unlicense`.

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* escape untrusted text in the final command error

Load errors carry text a registry or daemon controls (response bodies, pull messages), and clio prints the command's error raw, so a registry could drive the terminal (e.g. OSC 52 to set the clipboard).

- root and `build` errors now go through the same escaping as notifications, wrapped so `errors.Is` / `errors.As` still work
- the shared filter also escapes Unicode format characters (bidi overrides, zero width), so a path can't display as something else

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* find the podman machine socket on macOS

Since the ssh fallback was dropped, `--source podman` (and `dive build` with podman) on macOS found nothing unless `CONTAINER_HOST` was set, because podman machine only records ssh destinations in its config.

When no other socket is found, dive now asks `podman machine inspect` for the default machine's API socket and uses it if it exists.

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* check the snapshot cleanup error in the CLI tests

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* point the acceptance tests at the renamed snapshot build dirs

Splitting the goreleaser builds into `linux-build` and `build` changed the snapshot output dirs (`linux-build_linux_amd64_v1`, `build_darwin_amd64_v1`, `build_windows_amd64_v1`), so the acceptance jobs couldn't find the binaries.

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

* read OCI archives through docker-archive too

main's parser accepted an OCI archive under `--source docker-archive`, stereoscope's docker-archive provider needs a `manifest.json`. `docker-archive` now falls back to the oci-archive provider, so existing invocations keep working.

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>

---------

Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
2026-10-30 10:37:51 -04:00

279 lines
10 KiB
Go

// Package source resolves a user provided image reference to a stereoscope image.
package source
import (
"context"
"errors"
"fmt"
"net"
"os"
"runtime"
"slices"
"strings"
"sync"
"time"
"github.com/google/go-containerregistry/pkg/name"
"github.com/anchore/stereoscope/pkg/file"
"github.com/anchore/stereoscope/pkg/image"
"github.com/anchore/stereoscope/pkg/image/containerd"
"github.com/anchore/stereoscope/pkg/image/containerstorage"
"github.com/anchore/stereoscope/pkg/image/docker"
"github.com/anchore/stereoscope/pkg/image/oci"
"github.com/anchore/stereoscope/pkg/image/podman"
"github.com/wagoodman/dive/internal/bus"
)
// image sources selectable with a reference scheme or the --source flag
const (
Docker = "docker"
Podman = "podman"
DockerArchive = "docker-archive"
OCIArchive = "oci-archive"
OCIDir = "oci-dir"
Registry = "registry"
Containerd = "containerd"
ContainersStorage = "containers-storage"
// Auto tries every source in stereoscope's detection order: files (so a file or dir in the working directory
// named like the reference wins), then daemons and stores, then a registry pull, which means an image no local
// daemon has can quietly come from Docker Hub. The source it lands on is reported. It is only valid as a --source
// value, never as a reference scheme.
Auto = "auto"
)
// Sources lists every valid --source value (aliases excluded).
var Sources = []string{Docker, Podman, DockerArchive, OCIArchive, OCIDir, Registry, Containerd, ContainersStorage, Auto}
var aliases = map[string]string{
"docker-tar": DockerArchive,
"oci-registry": Registry,
}
// sources whose reference is a path, the only ones "<source>:<ref>" (no "//") selects. Any other source name followed
// by a colon reads as an image name and tag ("docker:dind", "registry:2.8")
var pathSources = []string{DockerArchive, OCIArchive, OCIDir}
// Config controls how Load resolves a reference.
type Config struct {
// Source is used when the reference has no scheme. Empty means Docker.
Source string
// Platform selects an image from a multi-platform index (e.g. "linux/arm64"). Empty means the default.
Platform string
}
// Normalize maps aliases to their canonical source name and reports whether the result is a valid source.
func Normalize(s string) (string, bool) {
if a, ok := aliases[s]; ok {
s = a
}
return s, slices.Contains(Sources, s)
}
// Parse splits a user reference into a source and the reference to hand to that source. "<source>://<ref>" works
// for every source, stereoscope's "<source>:<ref>" only for the file based ones (e.g. "oci-dir:./img"). Without a
// known scheme the (normalized) defaultSource is returned with the input untouched; an empty defaultSource means
// Docker.
func Parse(input, defaultSource string) (src, ref string) {
if scheme, rest, ok := strings.Cut(input, "://"); ok {
if s, ok := schemeSource(scheme); ok {
return s, rest
}
}
if scheme, rest, ok := strings.Cut(input, ":"); ok {
if s, ok := schemeSource(scheme); ok && slices.Contains(pathSources, s) {
return s, rest
}
}
if defaultSource == "" {
defaultSource = Docker
}
src, _ = Normalize(defaultSource)
return src, input
}
func schemeSource(scheme string) (string, bool) {
s, ok := Normalize(scheme)
return s, ok && s != Auto
}
// tempDirs parents the temp dirs of every Load, so Cleanup can remove them even when the caller never got the
// image back (e.g. an interrupt while a provider is still copying the image).
var tempDirs = file.NewTempDirGenerator("dive")
// loading counts the Loads still running, Cleanup waits for them
var loading sync.WaitGroup
// Cleanup removes the temp dirs of every image Load has read (or is still reading). Loads still running get up to
// wait to return first, since a provider that is still copying would otherwise start a fresh temp dir after the
// cleanup. It is safe to call more than once and concurrently with img.Cleanup(). Meant for the end of the process,
// when interrupted work never returned.
func Cleanup(wait time.Duration) error {
done := make(chan struct{})
go func() {
loading.Wait()
close(done)
}()
select {
case <-done:
case <-time.After(wait):
}
return tempDirs.Cleanup()
}
// Load resolves the user reference (see Parse) and reads the image with stereoscope. The caller owns the returned
// image and should call img.Cleanup() when done with it; Cleanup is the backstop for paths that never get there.
func Load(ctx context.Context, input string, cfg Config) (*image.Image, error) {
loading.Add(1)
defer loading.Done()
src, ref := Parse(input, cfg.Source)
var platform *image.Platform
if cfg.Platform != "" {
p, err := image.NewPlatform(cfg.Platform)
if err != nil {
return nil, err
}
platform = p
}
tmp := tempDirs.NewGenerator()
ps, err := providers(src, ref, runtime.GOOS, platform, tmp)
if err != nil {
return nil, err
}
var errs []error
for _, p := range ps {
if ctx.Err() != nil {
errs = append(errs, ctx.Err())
break
}
img, err := p.Provide(ctx)
if err != nil {
errs = append(errs, fmt.Errorf("%s: %w", p.Name(), err))
continue
}
if src == Auto {
bus.Notify(fmt.Sprintf("auto detected the image source: %s", p.Name()))
}
if platform != nil && !platformMatches(img.Metadata, platform) {
bus.Notify(fmt.Sprintf("the %s source has no %s image, using %s", p.Name(), platform, metadataPlatform(img.Metadata)))
}
return img, nil
}
// providers that failed may have left temp dirs behind
errs = append(errs, tmp.Cleanup())
return nil, fmt.Errorf("unable to load image %q from %s: %w", ref, src, errors.Join(errs...))
}
// platformMatches reports whether the image is the requested platform. Some providers (docker-archive) can't select
// a platform and read whatever the archive holds.
func platformMatches(m image.Metadata, p *image.Platform) bool {
return m.OS == p.OS && m.Architecture == p.Architecture && (p.Variant == "" || m.Variant == p.Variant)
}
func metadataPlatform(m image.Metadata) string {
s := m.OS + "/" + m.Architecture
if m.Variant != "" {
s += "/" + m.Variant
}
return s
}
// plainHTTPRegistry reports an error for a registry the registry client would reach over plain http. It falls back
// to http for private IP registries too, which would send docker config credentials in the clear and accept whatever
// image answers. Only "localhost" and loopback IP literals are allowed, nothing leaves the machine there. Other
// "*.localhost" names are refused: release builds use the pure go resolver, which sends them to /etc/hosts and DNS.
func plainHTTPRegistry(ref string) error {
r, err := name.ParseReference(ref)
if err != nil {
// the registry provider reports the bad reference itself
return nil
}
reg := r.Context().Registry
if reg.Scheme() != "http" {
return nil
}
host := reg.RegistryStr()
if h, _, err := net.SplitHostPort(host); err == nil {
host = h
}
// a bare "[::1]" has no port for SplitHostPort to strip the brackets with
host = strings.TrimSuffix(strings.TrimPrefix(host, "["), "]")
if ip := net.ParseIP(host); host == "localhost" || (ip != nil && ip.IsLoopback()) {
return nil
}
return fmt.Errorf("refusing to pull %q: the registry client would fall back to plain http for %s", ref, reg.RegistryStr())
}
// localName is the "localhost/" name podman gives a short name it built or tagged locally ("podman build -t myapp"
// stores localhost/myapp), which containers-storage won't find from the short name: it reads that as
// docker.io/library/myapp. It reports false for a reference that already names a registry.
func localName(ref string) (string, bool) {
first, _, hasPath := strings.Cut(ref, "/")
if hasPath && (first == "localhost" || strings.ContainsAny(first, ".:")) {
return "", false
}
return "localhost/" + ref, true
}
// providers returns the stereoscope providers to try, in order, for the given source. Constructing them is cheap,
// nothing connects until Provide.
func providers(src, ref, goos string, platform *image.Platform, tmp *file.TempDirGenerator) ([]image.Provider, error) {
var (
// the docker client is built by dive so that docker contexts are honored (see newDockerClient)
dockerDaemon = docker.NewAPIClientProvider(Docker, tmp, ref, platform, newDockerClient)
// same as podman.NewDaemonProvider, without its ssh fallback (see newPodmanClient)
podmanDaemon = docker.NewAPIClientProvider(string(podman.Daemon), tmp, ref, platform, newPodmanClient)
// a stub that always errors unless built with the containers_image_openpgp tag
store = containerstorage.NewProvider(tmp, ref, platform)
dockerArchive = docker.NewArchiveProvider(tmp, ref)
ociArchive = oci.NewArchiveProviderWithPlatform(tmp, ref, platform)
ociDir = oci.NewDirectoryProviderWithPlatform(tmp, ref, platform)
// zero registry options mean credentials come from the docker config keychain
registry = oci.NewRegistryProvider(tmp, image.RegistryOptions{}, ref, platform)
containerdDaemon = containerd.NewDaemonProvider(tmp, image.RegistryOptions{}, os.Getenv("CONTAINERD_NAMESPACE"), ref, platform)
)
switch src {
case Docker:
return []image.Provider{dockerDaemon}, nil
case Podman:
// on linux the local store is readable without a socket. Elsewhere podman runs in a VM
if goos == "linux" {
ps := []image.Provider{store}
if local, ok := localName(ref); ok {
ps = append(ps, containerstorage.NewProvider(tmp, local, platform))
}
return append(ps, podmanDaemon), nil
}
return []image.Provider{podmanDaemon}, nil
case DockerArchive:
// main's own parser read OCI archives as docker-archive too
return []image.Provider{dockerArchive, ociArchive}, nil
case OCIArchive:
return []image.Provider{ociArchive}, nil
case OCIDir:
return []image.Provider{ociDir}, nil
case Registry:
if err := plainHTTPRegistry(ref); err != nil {
return nil, err
}
return []image.Provider{registry}, nil
case Containerd:
return []image.Provider{containerdDaemon}, nil
case ContainersStorage:
return []image.Provider{store}, nil
case Auto:
// same order as stereoscope's own detection, with dive's docker client
ps := []image.Provider{dockerArchive, ociArchive, ociDir, dockerDaemon, podmanDaemon, containerdDaemon, store}
if plainHTTPRegistry(ref) == nil {
ps = append(ps, registry)
}
return ps, nil
}
return nil, fmt.Errorf("unknown image source %q (valid sources: %s)", src, strings.Join(Sources, ", "))
}