blob: c05bfd13a181f9dd2d3fbf176635497377407264 [file] [edit]
package containerd
import (
"fmt"
"path/filepath"
"testing"
c8dimages "github.com/containerd/containerd/v2/core/images"
"github.com/containerd/containerd/v2/core/snapshots"
"github.com/containerd/containerd/v2/pkg/namespaces"
cerrdefs "github.com/containerd/errdefs"
"github.com/containerd/log/logtest"
"github.com/containerd/platforms"
"github.com/moby/moby/v2/daemon/server/imagebackend"
"github.com/moby/moby/v2/internal/testutil/specialimage"
"github.com/opencontainers/image-spec/identity"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"gotest.tools/v3/assert"
is "gotest.tools/v3/assert/cmp"
)
func TestImageInspect(t *testing.T) {
ctx := namespaces.WithNamespace(t.Context(), "testing")
blobsDir := t.TempDir()
toContainerdImage := func(t *testing.T, imageFunc specialimage.SpecialImageFunc) c8dimages.Image {
idx, err := imageFunc(blobsDir)
assert.NilError(t, err)
return imagesFromIndex(idx)[0]
}
missingMultiPlatform := toContainerdImage(t, func(dir string) (*ocispec.Index, error) {
idx, _, err := specialimage.PartialMultiPlatform(dir, "missingmp:latest", specialimage.PartialOpts{
Stored: nil,
Missing: []ocispec.Platform{
{OS: "linux", Architecture: "arm64"},
{OS: "linux", Architecture: "amd64"},
},
})
return idx, err
})
cs := &blobsDirContentStore{blobs: filepath.Join(blobsDir, "blobs/sha256")}
t.Run("inspect image with manifests but missing platform blobs", func(t *testing.T) {
ctx := logtest.WithT(ctx, t)
service := fakeImageService(t, ctx, cs)
_, err := service.images.Create(ctx, missingMultiPlatform)
assert.NilError(t, err)
for _, manifests := range []bool{true, false} {
t.Run(fmt.Sprintf("manifests=%t", manifests), func(t *testing.T) {
inspect, err := service.ImageInspect(ctx, missingMultiPlatform.Name, imagebackend.ImageInspectOpts{Manifests: manifests})
assert.NilError(t, err)
if manifests {
assert.Check(t, is.Len(inspect.Manifests, 2))
} else {
assert.Check(t, is.Len(inspect.Manifests, 0))
}
})
}
})
t.Run("inspect image with one layer missing", func(t *testing.T) {
ctx := logtest.WithT(ctx, t)
service := fakeImageService(t, ctx, cs)
img := toContainerdImage(t, specialimage.MultiLayer)
_, err := service.images.Create(ctx, img)
assert.NilError(t, err)
// Get the manifest to access the layers
mfst, err := c8dimages.Manifest(ctx, cs, img.Target, nil)
assert.NilError(t, err)
assert.Check(t, len(mfst.Layers) > 0, "image should have at least one layer")
// Delete the last layer from the content store
lastLayer := mfst.Layers[len(mfst.Layers)-1]
err = cs.Delete(ctx, lastLayer.Digest)
assert.NilError(t, err)
for name, platform := range map[string]*ocispec.Platform{
"no platform": nil,
"host platform": new(platforms.DefaultSpec()),
} {
t.Run(name, func(t *testing.T) {
inspect, err := service.ImageInspect(ctx, img.Name, imagebackend.ImageInspectOpts{Platform: platform})
assert.NilError(t, err)
assert.Check(t, inspect.Config != nil)
assert.Check(t, is.Len(inspect.RootFS.Layers, len(mfst.Layers)))
})
}
})
t.Run("inspect falls back to a pulled platform and rejects a requested platform that was not pulled", func(t *testing.T) {
ctx := logtest.WithT(ctx, t)
service := fakeImageService(t, ctx, cs)
host := ocispec.Platform{OS: "linux", Architecture: "amd64"}
service.defaultPlatformOverride = &host
img := toContainerdImage(t, func(dir string) (*ocispec.Index, error) {
idx, _, err := specialimage.PartialMultiPlatform(dir, "only386:latest", specialimage.PartialOpts{
Stored: []ocispec.Platform{{OS: "linux", Architecture: "386"}},
Missing: []ocispec.Platform{host},
})
return idx, err
})
_, err := service.images.Create(ctx, img)
assert.NilError(t, err)
inspect, err := service.ImageInspect(ctx, img.Name, imagebackend.ImageInspectOpts{})
assert.NilError(t, err)
assert.Check(t, is.Equal(inspect.Architecture, "386"))
assert.Check(t, is.Equal(inspect.RootFS.Type, "layers"))
_, err = service.ImageInspect(ctx, img.Name, imagebackend.ImageInspectOpts{Platform: &host})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
})
t.Run("inspect image whose only present manifest has no config", func(t *testing.T) {
ctx := logtest.WithT(ctx, t)
service := fakeImageService(t, ctx, cs)
host := ocispec.Platform{OS: "linux", Architecture: "riscv64"}
service.defaultPlatformOverride = &host
img := toContainerdImage(t, func(dir string) (*ocispec.Index, error) {
idx, _, err := specialimage.PartialMultiPlatform(dir, "noconfig:latest", specialimage.PartialOpts{
Stored: []ocispec.Platform{host},
})
return idx, err
})
_, err := service.images.Create(ctx, img)
assert.NilError(t, err)
mfst, err := c8dimages.Manifest(ctx, cs, img.Target, platforms.Only(host))
assert.NilError(t, err)
err = cs.Delete(ctx, mfst.Config.Digest)
assert.NilError(t, err)
// The manifest isn't picked as the best match, so inspect describes
// the index without any image data.
inspect, err := service.ImageInspect(ctx, img.Name, imagebackend.ImageInspectOpts{})
assert.NilError(t, err)
assert.Check(t, is.Equal(inspect.ID, img.Target.Digest.String()))
assert.Check(t, is.Equal(inspect.Architecture, ""))
assert.Check(t, is.Len(inspect.RootFS.Layers, 0))
_, err = service.ImageInspect(ctx, img.Name, imagebackend.ImageInspectOpts{Platform: &host})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
})
t.Run("inspect image size by platform", func(t *testing.T) {
ctx := logtest.WithT(ctx, t)
service := fakeImageService(t, ctx, cs)
idx, manifestDescs, err := specialimage.MultiPlatform(blobsDir, "multiplatform:latest", []ocispec.Platform{
{OS: "linux", Architecture: "amd64"},
{OS: "linux", Architecture: "arm64"},
})
assert.NilError(t, err)
multiPlatformImage := imagesFromIndex(idx)[0]
_, err = service.images.Create(ctx, multiPlatformImage)
assert.NilError(t, err)
snapshotSizeByArch := map[string]int64{
"amd64": 10_000_000,
"arm64": 20_000_000,
}
snapshotter, ok := service.snapshotterServices[service.snapshotter].(*testSnapshotterService)
assert.Assert(t, ok)
snapshotter.usageByKey = make(map[string]snapshots.Usage, len(manifestDescs))
for _, desc := range manifestDescs {
assert.Assert(t, desc.Platform != nil)
platformImage, err := service.NewImageManifest(ctx, multiPlatformImage, desc)
assert.NilError(t, err)
diffIDs, err := platformImage.RootFS(ctx)
assert.NilError(t, err)
snapshotter.usageByKey[identity.ChainID(diffIDs).String()] = snapshots.Usage{
Size: snapshotSizeByArch[desc.Platform.Architecture],
}
}
inspectAll, err := service.ImageInspect(ctx, multiPlatformImage.Name, imagebackend.ImageInspectOpts{Manifests: true})
assert.NilError(t, err)
assert.Check(t, is.Len(inspectAll.Manifests, 2))
totalSizeByArch := make(map[string]int64, len(inspectAll.Manifests))
for _, manifest := range inspectAll.Manifests {
assert.Assert(t, manifest.ImageData != nil)
arch := manifest.ImageData.Platform.Architecture
snapshotSize, ok := snapshotSizeByArch[arch]
assert.Assert(t, ok)
assert.Equal(t, manifest.ImageData.Size.Unpacked, snapshotSize)
assert.Equal(t, manifest.Size.Total, manifest.Size.Content+snapshotSize)
totalSizeByArch[arch] = manifest.Size.Total
}
selectedSize, ok := totalSizeByArch[inspectAll.Architecture]
assert.Assert(t, ok)
assert.Equal(t, inspectAll.Size, selectedSize)
// Test with amd64 platform
amd64Platform := &ocispec.Platform{OS: "linux", Architecture: "amd64"}
inspectAmd64, err := service.ImageInspect(ctx, multiPlatformImage.Name, imagebackend.ImageInspectOpts{
Platform: amd64Platform,
})
assert.NilError(t, err)
assert.Equal(t, inspectAmd64.Architecture, "amd64")
assert.Equal(t, inspectAmd64.Os, "linux")
assert.Equal(t, inspectAmd64.Size, totalSizeByArch["amd64"])
// Test with arm64 platform
arm64Platform := &ocispec.Platform{OS: "linux", Architecture: "arm64"}
inspectArm64, err := service.ImageInspect(ctx, multiPlatformImage.Name, imagebackend.ImageInspectOpts{
Platform: arm64Platform,
})
assert.NilError(t, err)
assert.Equal(t, inspectArm64.Architecture, "arm64")
assert.Equal(t, inspectArm64.Os, "linux")
assert.Equal(t, inspectArm64.Size, totalSizeByArch["arm64"])
})
}