move functions supporting rmi command to libkpod/image

Signed-off-by: Ryan Cole <rcyoalne@gmail.com>

libkpod/image/CopyRef.go

@@ -211,7 +211,7 @@ func (c *CopyRef) NewImageSource(sc *types.SystemContext, manifestTypes []string
 			continue
 		}
 		// Start reading the layer.
-		rc, err := i.store.Diff("", layerID, nil)
+		rc, err := c.store.Diff("", layerID, nil)
 		if err != nil {
 			return nil, errors.Wrapf(err, "error extracting layer %q", layerID)
 		}

libkpod/image/image.go

@@ -150,7 +150,7 @@ func matchesSinceImage(image storage.Image, name string, params *FilterParams) b
 
 // MatchesID returns true if argID is a full or partial match for id
 func MatchesID(id, argID string) bool {
-	return strings.HasPrefix(id, argID)
+	return strings.HasPrefix(argID, id)
 }
 
 // MatchesReference returns true if argName is a full or partial match for name
@@ -264,9 +264,6 @@ func GetImagesMatchingFilter(store storage.Store, filter *FilterParams, argName
 	if err != nil {
 		return nil, err
 	}
-	if filter == nil {
-		return images, nil
-	}
 	for _, image := range images {
 		names := []string{}
 		if len(image.Names) > 0 {
@@ -275,7 +272,7 @@ func GetImagesMatchingFilter(store storage.Store, filter *FilterParams, argName
 			names = append(names, "<none>")
 		}
 		for _, name := range names {
-			if matchesFilter(store, image, name, filter) || MatchesReference(name, argName) {
+			if filter == nil || (matchesFilter(store, image, name, filter) || MatchesReference(name, argName)) {
 				newImage := image
 				newImage.Names = []string{name}
 				filteredImages = append(filteredImages, newImage)

libkpod/image/imageData.go

@@ -12,6 +12,7 @@ import (
 )
 
 // ImageData handles the data used when inspecting a container
+// nolint
 type ImageData struct {
 	ID              string
 	Names           []string

libkpod/image/rmi.go

@@ -0,0 +1,124 @@
+package image
+
+import (
+	"fmt"
+
+	is "github.com/containers/image/storage"
+	"github.com/containers/image/transports"
+	"github.com/containers/image/transports/alltransports"
+	"github.com/containers/image/types"
+	"github.com/containers/storage"
+	"github.com/pkg/errors"
+)
+
+// If it's looks like a proper image reference, parse it and check if it
+// corresponds to an image that actually exists.
+func properImageRef(id string) (types.ImageReference, error) {
+	var ref types.ImageReference
+	var err error
+	if ref, err = alltransports.ParseImageName(id); err == nil {
+		if img, err2 := ref.NewImage(nil); err2 == nil {
+			img.Close()
+			return ref, nil
+		}
+		return nil, fmt.Errorf("error confirming presence of image reference %q: %v", transports.ImageName(ref), err)
+	}
+	return nil, fmt.Errorf("error parsing %q as an image reference: %v", id, err)
+}
+
+// If it's looks like an image reference that's relative to our storage, parse
+// it and check if it corresponds to an image that actually exists.
+func storageImageRef(store storage.Store, id string) (types.ImageReference, error) {
+	var ref types.ImageReference
+	var err error
+	if ref, err = is.Transport.ParseStoreReference(store, id); err == nil {
+		if img, err2 := ref.NewImage(nil); err2 == nil {
+			img.Close()
+			return ref, nil
+		}
+		return nil, fmt.Errorf("error confirming presence of storage image reference %q: %v", transports.ImageName(ref), err)
+	}
+	return nil, fmt.Errorf("error parsing %q as a storage image reference: %v", id, err)
+}
+
+// If it might be an ID that's relative to our storage, parse it and check if it
+// corresponds to an image that actually exists.  This _should_ be redundant,
+// since we already tried deleting the image using the ID directly above, but it
+// can't hurt either.
+func storageImageID(store storage.Store, id string) (types.ImageReference, error) {
+	var ref types.ImageReference
+	var err error
+	if ref, err = is.Transport.ParseStoreReference(store, "@"+id); err == nil {
+		if img, err2 := ref.NewImage(nil); err2 == nil {
+			img.Close()
+			return ref, nil
+		}
+		return nil, fmt.Errorf("error confirming presence of storage image reference %q: %v", transports.ImageName(ref), err)
+	}
+	return nil, fmt.Errorf("error parsing %q as a storage image reference: %v", "@"+id, err)
+}
+
+// GetImage TODO: Ask Nalin if this or FindImage() is better
+func GetImage(store storage.Store, id string) (*storage.Image, error) {
+	var ref types.ImageReference
+	ref, err := properImageRef(id)
+	if err != nil {
+		//logrus.Debug(err)
+	}
+	if ref == nil {
+		if ref, err = storageImageRef(store, id); err != nil {
+			//logrus.Debug(err)
+		}
+	}
+	if ref == nil {
+		if ref, err = storageImageID(store, id); err != nil {
+			//logrus.Debug(err)
+		}
+	}
+	if ref != nil {
+		image, err2 := is.Transport.GetStoreImage(store, ref)
+		if err2 != nil {
+			return nil, err2
+		}
+		return image, nil
+	}
+	return nil, err
+}
+
+// UntagImage removes the tag from the given image
+func UntagImage(store storage.Store, image *storage.Image, imgArg string) (string, error) {
+	// Remove name from image.Names and set the new name in the ImageStore
+	imgStore, err := store.ImageStore()
+	if err != nil {
+		return "", errors.Wrap(err, "could not untag image")
+	}
+	newNames := []string{}
+	removedName := ""
+	for _, name := range image.Names {
+		if MatchesReference(name, imgArg) {
+			removedName = name
+			continue
+		}
+		newNames = append(newNames, name)
+	}
+	imgStore.SetNames(image.ID, newNames)
+	err = imgStore.Save()
+	return removedName, err
+}
+
+// RemoveImage removes the given image from storage
+func RemoveImage(image *storage.Image, store storage.Store) (string, error) {
+	imgStore, err := store.ImageStore()
+	if err != nil {
+		return "", errors.Wrapf(err, "could not open image store")
+	}
+	err = imgStore.Delete(image.ID)
+	if err != nil {
+		return "", errors.Wrapf(err, "could not remove image")
+	}
+	err = imgStore.Save()
+	if err != nil {
+		return "", errors.Wrapf(err, "could not save image store")
+	}
+	return image.ID, nil
+}