move image filters under libpod/images

to make things more effecient for the api work we are doing, we should
process image filters internally (as opposed to in main).  this allows
for better api responses and more closely affiliated functions.

Signed-off-by: baude <bbaude@redhat.com>

2 files changed, 189 insertions, 0 deletions

diff --git a/libpod/image/filters.go b/libpod/image/filters.go
new file mode 100644
index 000000000..d545f1bfc
--- /dev/null
+++ b/libpod/image/filters.go
@@ -0,0 +1,176 @@
+package image
+
+import (
+	"context"
+	"fmt"
+	"github.com/pkg/errors"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/containers/libpod/pkg/inspect"
+	"github.com/sirupsen/logrus"
+)
+
+// ResultFilter is a mock function for image filtering
+type ResultFilter func(*Image) bool
+
+// Filter is a function to determine whether an image is included in
+// command output. Images to be outputted are tested using the function. A true
+// return will include the image, a false return will exclude it.
+type Filter func(*Image, *inspect.ImageData) bool
+
+// CreatedBeforeFilter allows you to filter on images created before
+// the given time.Time
+func CreatedBeforeFilter(createTime time.Time) ResultFilter {
+	return func(i *Image) bool {
+		return i.Created().Before(createTime)
+	}
+}
+
+// CreatedAfterFilter allows you to filter on images created after
+// the given time.Time
+func CreatedAfterFilter(createTime time.Time) ResultFilter {
+	return func(i *Image) bool {
+		return i.Created().After(createTime)
+	}
+}
+
+// DanglingFilter allows you to filter images for dangling images
+func DanglingFilter(danglingImages bool) ResultFilter {
+	return func(i *Image) bool {
+		if danglingImages {
+			return i.Dangling()
+		}
+		return !i.Dangling()
+	}
+}
+
+// ReadOnlyFilter allows you to filter images based on read/only and read/write
+func ReadOnlyFilter(readOnly bool) ResultFilter {
+	return func(i *Image) bool {
+		if readOnly {
+			return i.IsReadOnly()
+		}
+		return !i.IsReadOnly()
+	}
+}
+
+// LabelFilter allows you to filter by images labels key and/or value
+func LabelFilter(ctx context.Context, labelfilter string) ResultFilter {
+	// We need to handle both label=key and label=key=value
+	return func(i *Image) bool {
+		var value string
+		splitFilter := strings.Split(labelfilter, "=")
+		key := splitFilter[0]
+		if len(splitFilter) > 1 {
+			value = splitFilter[1]
+		}
+		labels, err := i.Labels(ctx)
+		if err != nil {
+			return false
+		}
+		if len(strings.TrimSpace(labels[key])) > 0 && len(strings.TrimSpace(value)) == 0 {
+			return true
+		}
+		return labels[key] == value
+	}
+}
+
+// ReferenceFilter allows you to filter by image name
+// Replacing all '/' with '|' so that filepath.Match() can work
+// '|' character is not valid in image name, so this is safe
+func ReferenceFilter(ctx context.Context, referenceFilter string) ResultFilter {
+	filter := fmt.Sprintf("*%s*", referenceFilter)
+	filter = strings.Replace(filter, "/", "|", -1)
+	return func(i *Image) bool {
+		if len(referenceFilter) < 1 {
+			return true
+		}
+		for _, name := range i.Names() {
+			newName := strings.Replace(name, "/", "|", -1)
+			match, err := filepath.Match(filter, newName)
+			if err != nil {
+				logrus.Errorf("failed to match %s and %s, %q", name, referenceFilter, err)
+			}
+			if match {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// OutputImageFilter allows you to filter by an a specific image name
+func OutputImageFilter(userImage *Image) ResultFilter {
+	return func(i *Image) bool {
+		return userImage.ID() == i.ID()
+	}
+}
+
+// FilterImages filters images using a set of predefined filter funcs
+func FilterImages(images []*Image, filters []ResultFilter) []*Image {
+	var filteredImages []*Image
+	for _, image := range images {
+		include := true
+		for _, filter := range filters {
+			include = include && filter(image)
+		}
+		if include {
+			filteredImages = append(filteredImages, image)
+		}
+	}
+	return filteredImages
+}
+
+// createFilterFuncs returns an array of filter functions based on the user inputs
+// and is later used to filter images for output
+func (ir *Runtime) createFilterFuncs(filters []string, img *Image) ([]ResultFilter, error) {
+	var filterFuncs []ResultFilter
+	ctx := context.Background()
+	for _, filter := range filters {
+		splitFilter := strings.Split(filter, "=")
+		if len(splitFilter) < 2 {
+			return nil, errors.Errorf("invalid filter syntax %s", filter)
+		}
+		switch splitFilter[0] {
+		case "before":
+			before, err := ir.NewFromLocal(splitFilter[1])
+			if err != nil {
+				return nil, errors.Wrapf(err, "unable to find image %s in local stores", splitFilter[1])
+			}
+			filterFuncs = append(filterFuncs, CreatedBeforeFilter(before.Created()))
+		case "after":
+			after, err := ir.NewFromLocal(splitFilter[1])
+			if err != nil {
+				return nil, errors.Wrapf(err, "unable to find image %s in local stores", splitFilter[1])
+			}
+			filterFuncs = append(filterFuncs, CreatedAfterFilter(after.Created()))
+		case "readonly":
+			readonly, err := strconv.ParseBool(splitFilter[1])
+			if err != nil {
+				return nil, errors.Wrapf(err, "invalid filter readonly=%s", splitFilter[1])
+			}
+			filterFuncs = append(filterFuncs, ReadOnlyFilter(readonly))
+		case "dangling":
+			danglingImages, err := strconv.ParseBool(splitFilter[1])
+			if err != nil {
+				return nil, errors.Wrapf(err, "invalid filter dangling=%s", splitFilter[1])
+			}
+			filterFuncs = append(filterFuncs, DanglingFilter(danglingImages))
+		case "label":
+			labelFilter := strings.Join(splitFilter[1:], "=")
+			filterFuncs = append(filterFuncs, LabelFilter(ctx, labelFilter))
+		case "reference":
+			referenceFilter := strings.Join(splitFilter[1:], "=")
+			filterFuncs = append(filterFuncs, ReferenceFilter(ctx, referenceFilter))
+		default:
+			return nil, errors.Errorf("invalid filter %s ", splitFilter[0])
+		}
+	}
+	if img != nil {
+		filterFuncs = append(filterFuncs, OutputImageFilter(img))
+	}
+	return filterFuncs, nil
+}
diff --git a/libpod/image/image.go b/libpod/image/image.go
index 129ccd376..c8583a1c5 100644
--- a/libpod/image/image.go
+++ b/libpod/image/image.go
@@ -216,6 +216,19 @@ func (ir *Runtime) Shutdown(force bool) error {
 	return err
 }
 
+// GetImagesWithFilters gets images with a series of filters applied
+func (ir *Runtime) GetImagesWithFilters(filters []string) ([]*Image, error) {
+	filterFuncs, err := ir.createFilterFuncs(filters, nil)
+	if err != nil {
+		return nil, err
+	}
+	images, err := ir.GetImages()
+	if err != nil {
+		return nil, err
+	}
+	return FilterImages(images, filterFuncs), nil
+}
+
 func (i *Image) reloadImage() error {
 	newImage, err := i.imageruntime.getImage(i.ID())
 	if err != nil {