* [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>
501 lines
19 KiB
Go
501 lines
19 KiB
Go
package source
|
|
|
|
import (
|
|
"context"
|
|
"encoding/pem"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/anchore/stereoscope/pkg/file"
|
|
cliconfig "github.com/docker/cli/cli/config"
|
|
ddocker "github.com/docker/cli/cli/context/docker"
|
|
ctxstore "github.com/docker/cli/cli/context/store"
|
|
"github.com/moby/moby/client"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/wagoodman/dive/internal/imagefixture"
|
|
)
|
|
|
|
func TestParse(t *testing.T) {
|
|
tests := []struct {
|
|
input, defaultSource string
|
|
wantSource, wantRef string
|
|
}{
|
|
// no scheme: the default source, input untouched
|
|
{"alpine:3.20", "", Docker, "alpine:3.20"},
|
|
{"alpine:3.20", Docker, Docker, "alpine:3.20"},
|
|
{"alpine:3.20", Podman, Podman, "alpine:3.20"},
|
|
{"alpine:3.20", Auto, Auto, "alpine:3.20"},
|
|
{"img.tar", DockerArchive, DockerArchive, "img.tar"},
|
|
{"img.tar", "docker-tar", DockerArchive, "img.tar"},
|
|
{"img.tar", OCIArchive, OCIArchive, "img.tar"},
|
|
{"./layout", OCIDir, OCIDir, "./layout"},
|
|
{"alpine", Registry, Registry, "alpine"},
|
|
{"alpine", "oci-registry", Registry, "alpine"},
|
|
{"alpine", Containerd, Containerd, "alpine"},
|
|
{"alpine", ContainersStorage, ContainersStorage, "alpine"},
|
|
// unknown defaults pass through so Load can report them
|
|
{"alpine", "nope", "nope", "alpine"},
|
|
|
|
// dive "://" schemes beat the default
|
|
{"docker://alpine", Podman, Docker, "alpine"},
|
|
{"podman://alpine", Docker, Podman, "alpine"},
|
|
{"docker-archive://img.tar", Docker, DockerArchive, "img.tar"},
|
|
{"docker-tar://img.tar", Docker, DockerArchive, "img.tar"},
|
|
{"oci-archive://img.tar", Docker, OCIArchive, "img.tar"},
|
|
{"oci-dir:///abs/layout", Docker, OCIDir, "/abs/layout"},
|
|
{"registry://alpine", Docker, Registry, "alpine"},
|
|
{"oci-registry://alpine", Docker, Registry, "alpine"},
|
|
{"containerd://alpine", Docker, Containerd, "alpine"},
|
|
{"containers-storage://alpine", Docker, ContainersStorage, "alpine"},
|
|
{"registry://localhost:5000/img:tag", Docker, Registry, "localhost:5000/img:tag"},
|
|
|
|
// stereoscope ":" schemes, for the file based sources only
|
|
{"docker-archive:img.tar", Docker, DockerArchive, "img.tar"},
|
|
{"docker-tar:img.tar", Docker, DockerArchive, "img.tar"},
|
|
{"oci-archive:img.tar", Docker, OCIArchive, "img.tar"},
|
|
{"oci-dir:/abs/layout", Docker, OCIDir, "/abs/layout"},
|
|
|
|
// any other source name before a ":" is an image named like that source, with a tag
|
|
{"docker:dind", Podman, Podman, "docker:dind"},
|
|
{"docker:27-cli", Docker, Docker, "docker:27-cli"},
|
|
{"registry:2.8", Docker, Docker, "registry:2.8"},
|
|
{"registry:latest", Docker, Docker, "registry:latest"},
|
|
{"podman:alpine", Docker, Docker, "podman:alpine"},
|
|
{"containerd:alpine", Docker, Docker, "containerd:alpine"},
|
|
{"oci-registry:alpine", Docker, Docker, "oci-registry:alpine"},
|
|
{"containers-storage:latest", Podman, Podman, "containers-storage:latest"},
|
|
|
|
// "auto" is a --source value, not a scheme
|
|
{"auto://alpine", Docker, Docker, "auto://alpine"},
|
|
{"auto:alpine", Docker, Docker, "auto:alpine"},
|
|
|
|
// registry hosts with a port are not schemes, even when the host is named like a source
|
|
{"localhost:5000/img:tag", Docker, Docker, "localhost:5000/img:tag"},
|
|
{"localhost:5000/img:tag", Registry, Registry, "localhost:5000/img:tag"},
|
|
{"registry:5000/img:tag", Docker, Docker, "registry:5000/img:tag"},
|
|
{"docker:5000/img", Podman, Podman, "docker:5000/img"},
|
|
{"registry:5000", Docker, Docker, "registry:5000"},
|
|
{"myhost.io:443/team/img@sha256:abc", Docker, Docker, "myhost.io:443/team/img@sha256:abc"},
|
|
|
|
// unknown schemes are part of the reference
|
|
{"https://example.com/img", Docker, Docker, "https://example.com/img"},
|
|
{"sha256:9f5a0b6c", Docker, Docker, "sha256:9f5a0b6c"},
|
|
{"docker://sha256:9f5a0b6c", Podman, Docker, "sha256:9f5a0b6c"},
|
|
{`C:\images\img.tar`, DockerArchive, DockerArchive, `C:\images\img.tar`},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.input+" default="+tt.defaultSource, func(t *testing.T) {
|
|
src, ref := Parse(tt.input, tt.defaultSource)
|
|
assert.Equal(t, tt.wantSource, src)
|
|
assert.Equal(t, tt.wantRef, ref)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNormalize(t *testing.T) {
|
|
for _, s := range Sources {
|
|
got, ok := Normalize(s)
|
|
assert.True(t, ok, s)
|
|
assert.Equal(t, s, got)
|
|
}
|
|
got, ok := Normalize("docker-tar")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, DockerArchive, got)
|
|
got, ok = Normalize("oci-registry")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, Registry, got)
|
|
_, ok = Normalize("nope")
|
|
assert.False(t, ok)
|
|
_, ok = Normalize("")
|
|
assert.False(t, ok)
|
|
}
|
|
|
|
func TestProviders(t *testing.T) {
|
|
tests := []struct {
|
|
src, goos string
|
|
want []string
|
|
wantErr bool
|
|
}{
|
|
{src: Docker, goos: "linux", want: []string{"docker"}},
|
|
// the short name is also tried as podman's localhost/ name
|
|
{src: Podman, goos: "linux", want: []string{"containers-storage", "containers-storage", "podman"}},
|
|
{src: Podman, goos: "darwin", want: []string{"podman"}},
|
|
{src: Podman, goos: "windows", want: []string{"podman"}},
|
|
{src: DockerArchive, goos: "linux", want: []string{"docker-archive", "oci-archive"}},
|
|
{src: OCIArchive, goos: "linux", want: []string{"oci-archive"}},
|
|
{src: OCIDir, goos: "linux", want: []string{"oci-dir"}},
|
|
{src: Registry, goos: "linux", want: []string{"oci-registry"}},
|
|
{src: Containerd, goos: "linux", want: []string{"containerd"}},
|
|
{src: ContainersStorage, goos: "darwin", want: []string{"containers-storage"}},
|
|
{src: Auto, goos: "linux", want: []string{
|
|
"docker-archive", "oci-archive", "oci-dir", "docker", "podman", "containerd", "containers-storage", "oci-registry",
|
|
}},
|
|
{src: "nope", goos: "linux", wantErr: true},
|
|
{src: "", goos: "linux", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.src+"/"+tt.goos, func(t *testing.T) {
|
|
ps, err := providers(tt.src, "alpine", tt.goos, nil, file.NewTempDirGenerator("dive-test"))
|
|
if tt.wantErr {
|
|
require.Error(t, err)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
var names []string
|
|
for _, p := range ps {
|
|
names = append(names, p.Name())
|
|
}
|
|
assert.Equal(t, tt.want, names)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoad(t *testing.T) {
|
|
dockerSave := imagefixture.Path(t, "oci-save")
|
|
ociArchive := imagefixture.Path(t, "oci-archive-gzip")
|
|
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
cfg Config
|
|
wantLayers int
|
|
wantErr bool
|
|
}{
|
|
{name: "docker-archive scheme", input: "docker-archive://" + dockerSave, wantLayers: 3},
|
|
{name: "docker-tar default", input: dockerSave, cfg: Config{Source: "docker-tar"}, wantLayers: 3},
|
|
{name: "oci-archive stereoscope scheme", input: "oci-archive:" + ociArchive, wantLayers: 1},
|
|
{name: "docker-archive reads an OCI archive", input: ociArchive, cfg: Config{Source: DockerArchive}, wantLayers: 1},
|
|
{name: "auto detects an archive", input: ociArchive, cfg: Config{Source: Auto}, wantLayers: 1},
|
|
{name: "missing archive", input: "docker-archive://" + filepath.Join(t.TempDir(), "nope.tar"), wantErr: true},
|
|
{name: "unknown source", input: dockerSave, cfg: Config{Source: "nope"}, wantErr: true},
|
|
{name: "bad platform", input: dockerSave, cfg: Config{Source: DockerArchive, Platform: "a/b/c/d"}, wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
img, err := Load(context.Background(), tt.input, tt.cfg)
|
|
if tt.wantErr {
|
|
require.Error(t, err)
|
|
assert.Nil(t, img)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() { require.NoError(t, img.Cleanup()) })
|
|
assert.Len(t, img.Layers, tt.wantLayers)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoad_interrupted(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
// auto has a provider list to walk. A cancelled load stops before the first, so no provider reports an error
|
|
// (and nothing is pulled)
|
|
img, err := Load(ctx, "dive-test/does-not-exist:never", Config{Source: Auto})
|
|
require.ErrorIs(t, err, context.Canceled)
|
|
assert.Nil(t, img)
|
|
ps, perr := providers(Auto, "alpine", "linux", nil, file.NewTempDirGenerator("dive-test"))
|
|
require.NoError(t, perr)
|
|
for _, p := range ps {
|
|
assert.NotContains(t, err.Error(), p.Name()+":")
|
|
}
|
|
}
|
|
|
|
func TestProviders_plainHTTPRegistry(t *testing.T) {
|
|
tmp := file.NewTempDirGenerator("dive-test")
|
|
for _, ref := range []string{"10.0.5.20:5000/app", "192.168.1.2/app:1", "172.16.0.9:443/team/app", "build.localhost:5000/app", "build.localhost/app"} {
|
|
_, err := providers(Registry, ref, "linux", nil, tmp)
|
|
assert.ErrorContains(t, err, "plain http", ref)
|
|
|
|
// auto never gets as far as a registry pull for these
|
|
ps, err := providers(Auto, ref, "linux", nil, tmp)
|
|
require.NoError(t, err)
|
|
assert.NotEqual(t, "oci-registry", ps[len(ps)-1].Name(), ref)
|
|
}
|
|
for _, ref := range []string{"alpine", "ghcr.io/org/app:1", "localhost:5000/app", "127.0.0.1:5000/app", "[::1]:5000/app", "[::1]/app"} {
|
|
_, err := providers(Registry, ref, "linux", nil, tmp)
|
|
assert.NoError(t, err, ref)
|
|
}
|
|
}
|
|
|
|
func TestLocalName(t *testing.T) {
|
|
tests := []struct {
|
|
ref, want string
|
|
ok bool
|
|
}{
|
|
{"myapp", "localhost/myapp", true},
|
|
{"myapp:1.0", "localhost/myapp:1.0", true},
|
|
{"team/myapp", "localhost/team/myapp", true},
|
|
{"localhost/myapp", "", false},
|
|
{"quay.io/team/myapp", "", false},
|
|
{"registry:5000/myapp", "", false},
|
|
}
|
|
for _, tt := range tests {
|
|
got, ok := localName(tt.ref)
|
|
assert.Equal(t, tt.ok, ok, tt.ref)
|
|
assert.Equal(t, tt.want, got, tt.ref)
|
|
}
|
|
}
|
|
|
|
func TestCleanup(t *testing.T) {
|
|
path := imagefixture.Path(t, "oci-save-gzip")
|
|
tmp := t.TempDir()
|
|
t.Setenv("TMPDIR", tmp) // unix
|
|
t.Setenv("TMP", tmp) // windows
|
|
|
|
// an image whose owner never got to img.Cleanup() (an interrupt) still gets removed
|
|
img, err := Load(context.Background(), "docker-archive:"+path, Config{})
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, img.Layers)
|
|
entries, err := os.ReadDir(tmp)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, entries, "expected the image to hold temp dirs")
|
|
|
|
require.NoError(t, Cleanup(time.Second))
|
|
entries, err = os.ReadDir(tmp)
|
|
require.NoError(t, err)
|
|
assert.Empty(t, entries)
|
|
|
|
// the owner cleaning up afterwards is fine
|
|
require.NoError(t, img.Cleanup())
|
|
}
|
|
|
|
func TestCleanup_waitsForLoad(t *testing.T) {
|
|
// stands in for a Load still running
|
|
loading.Add(1)
|
|
done := make(chan struct{})
|
|
go func() {
|
|
assert.NoError(t, Cleanup(10*time.Second))
|
|
close(done)
|
|
}()
|
|
select {
|
|
case <-done:
|
|
t.Fatal("Cleanup returned while a load was still running")
|
|
case <-time.After(100 * time.Millisecond):
|
|
}
|
|
loading.Done()
|
|
select {
|
|
case <-done:
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatal("Cleanup did not return after the load finished")
|
|
}
|
|
|
|
// a load that never returns only holds Cleanup up for the wait
|
|
loading.Add(1)
|
|
defer loading.Done()
|
|
start := time.Now()
|
|
require.NoError(t, Cleanup(50*time.Millisecond))
|
|
assert.Less(t, time.Since(start), 5*time.Second)
|
|
}
|
|
|
|
func TestDockerHost(t *testing.T) {
|
|
newConfigDir := func(t *testing.T, currentContext string, contexts map[string]string) string {
|
|
t.Helper()
|
|
dir := t.TempDir()
|
|
if currentContext != "" {
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "config.json"), []byte(`{"currentContext":"`+currentContext+`"}`), 0o600))
|
|
}
|
|
st := ctxstore.New(filepath.Join(dir, "contexts"), ctxstore.NewConfig(
|
|
func() any { return &ddocker.EndpointMeta{} },
|
|
ctxstore.EndpointTypeGetter(ddocker.DockerEndpoint, func() any { return &ddocker.EndpointMeta{} }),
|
|
))
|
|
for name, host := range contexts {
|
|
require.NoError(t, st.CreateOrUpdate(ctxstore.Metadata{
|
|
Name: name,
|
|
Endpoints: map[string]any{ddocker.DockerEndpoint: ddocker.EndpointMeta{Host: host}},
|
|
}))
|
|
}
|
|
return dir
|
|
}
|
|
|
|
contexts := map[string]string{
|
|
"remote": "tcp://10.0.0.1:2376",
|
|
"ssh": "ssh://user@builder",
|
|
"colima": "unix:///Users/me/.colima/default/docker.sock",
|
|
"no-host": "",
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
dockerHost string
|
|
dockerContext string
|
|
currentContext string
|
|
want string
|
|
wantErr bool
|
|
}{
|
|
{name: "nothing set", want: client.DefaultDockerHost},
|
|
{name: "DOCKER_HOST", dockerHost: "tcp://1.2.3.4:2375", want: "tcp://1.2.3.4:2375"},
|
|
{name: "DOCKER_HOST beats DOCKER_CONTEXT", dockerHost: "tcp://1.2.3.4:2375", dockerContext: "remote", want: "tcp://1.2.3.4:2375"},
|
|
{name: "DOCKER_HOST beats config context", dockerHost: "tcp://1.2.3.4:2375", currentContext: "remote", want: "tcp://1.2.3.4:2375"},
|
|
{name: "DOCKER_CONTEXT", dockerContext: "remote", want: "tcp://10.0.0.1:2376"},
|
|
{name: "DOCKER_CONTEXT ssh", dockerContext: "ssh", want: "ssh://user@builder"},
|
|
{name: "DOCKER_CONTEXT beats config context", dockerContext: "colima", currentContext: "remote", want: "unix:///Users/me/.colima/default/docker.sock"},
|
|
{name: "config context", currentContext: "colima", want: "unix:///Users/me/.colima/default/docker.sock"},
|
|
{name: "context with empty host", currentContext: "no-host", want: client.DefaultDockerHost},
|
|
{name: "DOCKER_CONTEXT default", dockerContext: "default", currentContext: "remote", want: client.DefaultDockerHost},
|
|
{name: "config context default", currentContext: "default", want: client.DefaultDockerHost},
|
|
{name: "missing context", dockerContext: "missing", wantErr: true},
|
|
{name: "missing config context", currentContext: "missing", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Setenv("DOCKER_HOST", tt.dockerHost)
|
|
t.Setenv("DOCKER_CONTEXT", tt.dockerContext)
|
|
ep, _, err := dockerEndpoint(newConfigDir(t, tt.currentContext, contexts))
|
|
if tt.wantErr {
|
|
require.Error(t, err)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tt.want, ep.Host)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDockerHost_badConfig(t *testing.T) {
|
|
t.Setenv("DOCKER_HOST", "")
|
|
t.Setenv("DOCKER_CONTEXT", "")
|
|
dir := t.TempDir()
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "config.json"), []byte("{not json"), 0o600))
|
|
_, _, err := dockerEndpoint(dir)
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestNewDockerClient_TLS(t *testing.T) {
|
|
// a TLS only daemon, a client that skips TLS gets a 400 from it
|
|
srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.Header().Set("Api-Version", "1.44")
|
|
w.WriteHeader(http.StatusOK)
|
|
}))
|
|
srv.Config.ErrorLog = log.New(io.Discard, "", 0)
|
|
srv.StartTLS()
|
|
defer srv.Close()
|
|
host := "tcp://" + srv.Listener.Addr().String()
|
|
ca := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: srv.Certificate().Raw})
|
|
|
|
newConfigDir := func(t *testing.T, withCA bool) string {
|
|
dir := t.TempDir()
|
|
st := ctxstore.New(filepath.Join(dir, "contexts"), ctxstore.NewConfig(
|
|
func() any { return &ddocker.EndpointMeta{} },
|
|
ctxstore.EndpointTypeGetter(ddocker.DockerEndpoint, func() any { return &ddocker.EndpointMeta{} }),
|
|
))
|
|
require.NoError(t, st.CreateOrUpdate(ctxstore.Metadata{
|
|
Name: "secure",
|
|
Endpoints: map[string]any{ddocker.DockerEndpoint: ddocker.EndpointMeta{Host: host}},
|
|
}))
|
|
require.NoError(t, st.CreateOrUpdate(ctxstore.Metadata{
|
|
Name: "plain",
|
|
Endpoints: map[string]any{ddocker.DockerEndpoint: ddocker.EndpointMeta{Host: host}},
|
|
}))
|
|
require.NoError(t, st.ResetTLSMaterial("secure", &ctxstore.ContextTLSData{
|
|
Endpoints: map[string]ctxstore.EndpointTLSData{ddocker.DockerEndpoint: {Files: map[string][]byte{"ca.pem": ca}}},
|
|
}))
|
|
if withCA {
|
|
require.NoError(t, os.WriteFile(filepath.Join(dir, "ca.pem"), ca, 0o600))
|
|
}
|
|
return dir
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
env map[string]string
|
|
withCA bool
|
|
wantErr bool
|
|
}{
|
|
{name: "context TLS material", env: map[string]string{"DOCKER_CONTEXT": "secure"}},
|
|
{name: "context without TLS material", env: map[string]string{"DOCKER_CONTEXT": "plain"}, wantErr: true},
|
|
{name: "DOCKER_TLS_VERIFY with config dir CA", env: map[string]string{"DOCKER_HOST": host, "DOCKER_TLS_VERIFY": "1"}, withCA: true},
|
|
{name: "DOCKER_TLS_VERIFY without a CA", env: map[string]string{"DOCKER_HOST": host, "DOCKER_TLS_VERIFY": "1"}, wantErr: true},
|
|
{name: "DOCKER_TLS unverified", env: map[string]string{"DOCKER_HOST": host, "DOCKER_TLS": "1"}},
|
|
{name: "DOCKER_HOST without TLS", env: map[string]string{"DOCKER_HOST": host}, wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
for _, k := range []string{"DOCKER_HOST", "DOCKER_CONTEXT", "DOCKER_TLS", "DOCKER_TLS_VERIFY", "DOCKER_CERT_PATH"} {
|
|
t.Setenv(k, tt.env[k])
|
|
}
|
|
// cliconfig.Dir() reads DOCKER_CONFIG once per process
|
|
prev := cliconfig.Dir()
|
|
cliconfig.SetDir(newConfigDir(t, tt.withCA))
|
|
t.Cleanup(func() { cliconfig.SetDir(prev) })
|
|
|
|
c, err := newDockerClient()
|
|
if err == nil {
|
|
defer c.Close()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
_, err = c.Ping(ctx, client.PingOptions{})
|
|
}
|
|
if tt.wantErr {
|
|
require.Error(t, err)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPodmanHost(t *testing.T) {
|
|
writeConf := func(t *testing.T, content string) string {
|
|
p := filepath.Join(t.TempDir(), "containers.conf")
|
|
require.NoError(t, os.WriteFile(p, []byte(content), 0o600))
|
|
return p
|
|
}
|
|
sshOnly := writeConf(t, `[engine]
|
|
active_service = "remote"
|
|
[engine.service_destinations.remote]
|
|
uri = "ssh://core@build:22/run/podman/podman.sock"
|
|
identity = "/home/me/.ssh/id_ed25519"
|
|
`)
|
|
activeSSH := writeConf(t, `[engine]
|
|
active_service = "remote"
|
|
[engine.service_destinations.remote]
|
|
uri = "ssh://core@build:22/run/podman/podman.sock"
|
|
[engine.service_destinations.local]
|
|
uri = "unix:///run/user/1000/podman/podman.sock"
|
|
`)
|
|
runtimeDir := t.TempDir()
|
|
require.NoError(t, os.MkdirAll(filepath.Join(runtimeDir, "podman"), 0o700))
|
|
require.NoError(t, os.WriteFile(filepath.Join(runtimeDir, "podman", "podman.sock"), nil, 0o600))
|
|
|
|
// podman 5 on macOS puts the machine's API socket under $TMPDIR
|
|
machineSock := filepath.Join(t.TempDir(), "podman-machine-default-api.sock")
|
|
require.NoError(t, os.WriteFile(machineSock, nil, 0o600))
|
|
|
|
tests := []struct {
|
|
name string
|
|
containerHost string
|
|
configs []string
|
|
runtimeDir string
|
|
machineSocket string
|
|
want string
|
|
wantErr string
|
|
}{
|
|
{name: "CONTAINER_HOST unix", containerHost: "unix:///tmp/podman.sock", configs: []string{activeSSH}, want: "unix:///tmp/podman.sock"},
|
|
{name: "CONTAINER_HOST ssh", containerHost: "ssh://core@build:22/run/podman/podman.sock", runtimeDir: runtimeDir, wantErr: "ssh"},
|
|
{name: "config unix destination over an active ssh one", configs: []string{activeSSH}, want: "unix:///run/user/1000/podman/podman.sock"},
|
|
{name: "config with only ssh", configs: []string{sshOnly}, runtimeDir: t.TempDir(), wantErr: "no podman socket"},
|
|
{name: "rootless default socket", configs: []string{sshOnly}, runtimeDir: runtimeDir, machineSocket: machineSock, want: "unix://" + filepath.Join(runtimeDir, "podman", "podman.sock")},
|
|
{name: "macOS machine with only ssh in config", configs: []string{sshOnly}, runtimeDir: t.TempDir(), machineSocket: machineSock, want: "unix://" + machineSock},
|
|
{name: "machine socket missing (machine stopped)", configs: []string{sshOnly}, runtimeDir: t.TempDir(), machineSocket: filepath.Join(t.TempDir(), "gone.sock"), wantErr: "no podman socket"},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Setenv("CONTAINER_HOST", tt.containerHost)
|
|
got, err := podmanHost(tt.configs, tt.runtimeDir, func() string { return tt.machineSocket })
|
|
if tt.wantErr != "" {
|
|
require.ErrorContains(t, err, tt.wantErr)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tt.want, got)
|
|
})
|
|
}
|
|
}
|