Merge pull request #3319 from austinvazquez/feat-add-image-prune-filter

Add image prune --filter support

cmd/nerdctl/image_list_test.go

@@ -79,6 +79,7 @@ func TestImages(t *testing.T) {
 
 func TestImagesFilter(t *testing.T) {
 	testutil.RequiresBuild(t)
+	testutil.RegisterBuildCacheCleanup(t)
 	t.Parallel()
 	base := testutil.NewBase(t)
 	tempName := testutil.Identifier(base.T)
@@ -121,6 +122,7 @@ LABEL version=0.1`, testutil.CommonImage)
 
 func TestImagesFilterDangling(t *testing.T) {
 	testutil.RequiresBuild(t)
+	testutil.RegisterBuildCacheCleanup(t)
 	base := testutil.NewBase(t)
 	base.Cmd("images", "prune", "--all").AssertOK()
 

cmd/nerdctl/image_prune.go

@@ -38,6 +38,7 @@ func newImagePruneCommand() *cobra.Command {
 	}
 
 	imagePruneCommand.Flags().BoolP("all", "a", false, "Remove all unused images, not just dangling ones")
+	imagePruneCommand.Flags().StringSlice("filter", []string{}, "Filter output based on conditions provided")
 	imagePruneCommand.Flags().BoolP("force", "f", false, "Do not prompt for confirmation")
 	return imagePruneCommand
 }
@@ -52,6 +53,14 @@ func processImagePruneOptions(cmd *cobra.Command) (types.ImagePruneOptions, erro
 		return types.ImagePruneOptions{}, err
 	}
 
+	var filters []string
+	if cmd.Flags().Changed("filter") {
+		filters, err = cmd.Flags().GetStringSlice("filter")
+		if err != nil {
+			return types.ImagePruneOptions{}, err
+		}
+	}
+
 	force, err := cmd.Flags().GetBool("force")
 	if err != nil {
 		return types.ImagePruneOptions{}, err
@@ -61,6 +70,7 @@ func processImagePruneOptions(cmd *cobra.Command) (types.ImagePruneOptions, erro
 		Stdout:   cmd.OutOrStdout(),
 		GOptions: globalOptions,
 		All:      all,
+		Filters:  filters,
 		Force:    force,
 	}, err
 }

cmd/nerdctl/image_prune_test.go

@@ -19,6 +19,7 @@ package main
 import (
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/containerd/nerdctl/v2/pkg/testutil"
 )
@@ -71,3 +72,57 @@ func TestImagePruneAll(t *testing.T) {
 	base.Cmd("image", "prune", "--force", "--all").AssertOutContains(imageName)
 	base.Cmd("images").AssertOutNotContains(imageName)
 }
+
+func TestImagePruneFilterLabel(t *testing.T) {
+	testutil.RequiresBuild(t)
+	testutil.RegisterBuildCacheCleanup(t)
+
+	base := testutil.NewBase(t)
+	imageName := testutil.Identifier(t)
+	t.Cleanup(func() { base.Cmd("rmi", "--force", imageName) })
+
+	dockerfile := fmt.Sprintf(`FROM %s
+CMD ["echo", "nerdctl-test-image-prune-filter-label"]
+LABEL foo=bar
+LABEL version=0.1`, testutil.CommonImage)
+
+	buildCtx := createBuildContext(t, dockerfile)
+
+	base.Cmd("build", "-t", imageName, buildCtx).AssertOK()
+	base.Cmd("images", "--all").AssertOutContains(imageName)
+
+	base.Cmd("image", "prune", "--force", "--all", "--filter", "label=foo=baz").AssertOK()
+	base.Cmd("images", "--all").AssertOutContains(imageName)
+
+	base.Cmd("image", "prune", "--force", "--all", "--filter", "label=foo=bar").AssertOK()
+	base.Cmd("images", "--all").AssertOutNotContains(imageName)
+}
+
+func TestImagePruneFilterUntil(t *testing.T) {
+	testutil.RequiresBuild(t)
+	testutil.RegisterBuildCacheCleanup(t)
+
+	// Docker image's created timestamp is set based on base image creation time.
+	testutil.DockerIncompatible(t)
+
+	base := testutil.NewBase(t)
+	imageName := testutil.Identifier(t)
+	t.Cleanup(func() { base.Cmd("rmi", "--force", imageName) })
+
+	dockerfile := fmt.Sprintf(`FROM %s
+CMD ["echo", "nerdctl-test-image-prune-filter-until"]`, testutil.CommonImage)
+
+	buildCtx := createBuildContext(t, dockerfile)
+
+	base.Cmd("build", "-t", imageName, buildCtx).AssertOK()
+	base.Cmd("images", "--all").AssertOutContains(imageName)
+
+	base.Cmd("image", "prune", "--force", "--all", "--filter", "until=12h").AssertOK()
+	base.Cmd("images", "--all").AssertOutContains(imageName)
+
+	// Pause to ensure enough time has passed for the image to be cleaned on next prune.
+	time.Sleep(3 * time.Second)
+
+	base.Cmd("image", "prune", "--force", "--all", "--filter", "until=10ms").AssertOK()
+	base.Cmd("images", "--all").AssertOutNotContains(imageName)
+}

docs/command-reference.md

@@ -746,7 +746,7 @@ Flags:
   - :nerd_face: `--format=wide`: Wide table
   - :nerd_face: `--format=json`: Alias of `--format='{{json .}}'`
 - :whale: `--digests`: Show digests (compatible with Docker, unlike ID)
-- :whale: `-f, --filter`: Filter the images. For now, only 'before=<image:tag>' and 'since=<image:tag>' is supported.
+- :whale: `-f, --filter`: Filter the images.
   - :whale: `--filter=before=<image:tag>`: Images created before given image (exclusive)
   - :whale: `--filter=since=<image:tag>`: Images created after given image (exclusive)
   - :whale: `--filter=label<key>=<value>`: Matches images based on the presence of a label alone or a label and a value
@@ -886,10 +886,11 @@ Usage: `nerdctl image prune [OPTIONS]`
 Flags:
 
 - :whale: `-a, --all`: Remove all unused images, not just dangling ones
+- :whale: `-f, --filter`: Filter the images.
+  - :whale: `--filter=until=<timestamp>`: Images created before given date formatted timestamps or Go duration strings. Currently does not support Unix timestamps.
+  - :whale: `--filter=label<key>=<value>`: Matches images based on the presence of a label alone or a label and a value
 - :whale: `-f, --force`: Do not prompt for confirmation
 
-Unimplemented `docker image prune` flags: `--filter`
-
 ### :nerd_face: nerdctl image convert
 
 Convert an image format.

pkg/api/types/image_types.go

@@ -236,6 +236,8 @@ type ImagePruneOptions struct {
 	GOptions GlobalCommandOptions
 	// All Remove all unused images, not just dangling ones.
 	All bool
+	// Filters output based on conditions provided for the --filter argument
+	Filters []string
 	// Force will not prompt for confirmation.
 	Force bool
 }

pkg/cmd/image/list.go

@@ -80,36 +80,29 @@ func List(ctx context.Context, client *containerd.Client, filters, nameAndRefFil
 			return nil, err
 		}
 
-		if f.Dangling != nil {
-			imageList = imgutil.FilterDangling(imageList, *f.Dangling)
+		filters := []imgutil.Filter{}
+		if f.Dangling != nil && *f.Dangling {
+			filters = append(filters, imgutil.FilterDanglingImages())
+		} else if f.Dangling != nil {
+			filters = append(filters, imgutil.FilterTaggedImages())
 		}
 
-		imageList, err = imgutil.FilterByLabel(ctx, client, imageList, f.Labels)
-		if err != nil {
-			return nil, err
+		if len(f.Labels) > 0 {
+			filters = append(filters, imgutil.FilterByLabel(ctx, client, f.Labels))
 		}
 
-		imageList, err = imgutil.FilterByReference(imageList, f.Reference)
-		if err != nil {
-			return nil, err
+		if len(f.Reference) > 0 {
+			filters = append(filters, imgutil.FilterByReference(f.Reference))
 		}
 
-		var beforeImages []images.Image
-		if len(f.Before) > 0 {
-			beforeImages, err = imageStore.List(ctx, f.Before...)
-			if err != nil {
-				return nil, err
-			}
-		}
-		var sinceImages []images.Image
-		if len(f.Since) > 0 {
-			sinceImages, err = imageStore.List(ctx, f.Since...)
-			if err != nil {
-				return nil, err
-			}
+		if len(f.Before) > 0 || len(f.Since) > 0 {
+			filters = append(filters, imgutil.FilterByCreatedAt(ctx, client, f.Before, f.Since))
 		}
 
-		imageList = imgutil.FilterImages(imageList, beforeImages, sinceImages)
+		imageList, err = imgutil.ApplyFilters(imageList, filters...)
+		if err != nil {
+			return []images.Image{}, err
+		}
 	}
 
 	sort.Slice(imageList, func(i, j int) bool {

pkg/cmd/image/prune.go

@@ -34,42 +34,43 @@ import (
 // Prune will remove all dangling images. If all is specified, will also remove all images not referenced by any container.
 func Prune(ctx context.Context, client *containerd.Client, options types.ImagePruneOptions) error {
 	var (
-		imageStore     = client.ImageService()
-		contentStore   = client.ContentStore()
-		containerStore = client.ContainerService()
+		imageStore   = client.ImageService()
+		contentStore = client.ContentStore()
 	)
 
-	imageList, err := imageStore.List(ctx)
-	if err != nil {
-		return err
-	}
-
-	var filteredImages []images.Image
+	var (
+		imagesToBeRemoved []images.Image
+		err               error
+	)
 
-	if options.All {
-		containerList, err := containerStore.List(ctx)
+	filters := []imgutil.Filter{}
+	if len(options.Filters) > 0 {
+		parsedFilters, err := imgutil.ParseFilters(options.Filters)
 		if err != nil {
 			return err
 		}
-		usedImages := make(map[string]struct{})
-		for _, container := range containerList {
-			usedImages[container.Image] = struct{}{}
+		if len(parsedFilters.Labels) > 0 {
+			filters = append(filters, imgutil.FilterByLabel(ctx, client, parsedFilters.Labels))
 		}
-
-		for _, image := range imageList {
-			if _, ok := usedImages[image.Name]; ok {
-				continue
-			}
-
-			filteredImages = append(filteredImages, image)
+		if len(parsedFilters.Until) > 0 {
+			filters = append(filters, imgutil.FilterUntil(parsedFilters.Until))
 		}
+	}
+
+	if options.All {
+		// Remove all unused images; not just dangling ones
+		imagesToBeRemoved, err = imgutil.GetUnusedImages(ctx, client, filters...)
 	} else {
-		filteredImages = imgutil.FilterDangling(imageList, true)
+		// Remove dangling images only
+		imagesToBeRemoved, err = imgutil.GetDanglingImages(ctx, client, filters...)
+	}
+	if err != nil {
+		return err
 	}
 
 	delOpts := []images.DeleteOpt{images.SynchronousDelete()}
 	removedImages := make(map[string][]digest.Digest)
-	for _, image := range filteredImages {
+	for _, image := range imagesToBeRemoved {
 		digests, err := image.RootFS(ctx, contentStore, platforms.DefaultStrict())
 		if err != nil {
 			log.G(ctx).WithError(err).Warnf("failed to enumerate rootfs")