only cache remote images

Author: nkubala

cmd/analyze.go

@@ -79,11 +79,11 @@ func analyzeImage(imageName string, analyzerArgs []string) error {
 		return fmt.Errorf("Error performing image analysis: %s", err)
 	}
 
-	output.PrintToStdErr("Retrieving analyses\n")
+	logrus.Info("retrieving analyses")
 	outputResults(analyses)
 
 	if noCache && save {
-		logrus.Infof("Image was saved at %s", image.FSPath)
+		logrus.Infof("image was saved at %s", image.FSPath)
 	}
 
 	return nil

cmd/diff.go

@@ -78,7 +78,7 @@ func diffImages(image1Arg, image2Arg string, diffArgs []string) error {
 	var wg sync.WaitGroup
 	wg.Add(2)
 
-	output.PrintToStdErr("Starting diff on images %s and %s, using differs: %s\n", image1Arg, image2Arg, diffArgs)
+	logrus.Infof("starting diff on images %s and %s, using differs: %s\n", image1Arg, image2Arg, diffArgs)
 
 	imageMap := map[string]*pkgutil.Image{
 		image1Arg: {},
@@ -102,7 +102,7 @@ func diffImages(image1Arg, image2Arg string, diffArgs []string) error {
 		defer pkgutil.CleanupImage(*imageMap[image2Arg])
 	}
 
-	output.PrintToStdErr("Computing diffs\n")
+	logrus.Info("computing diffs")
 	req := differs.DiffRequest{
 		Image1:    *imageMap[image1Arg],
 		Image2:    *imageMap[image2Arg],
@@ -114,7 +114,7 @@ func diffImages(image1Arg, image2Arg string, diffArgs []string) error {
 	outputResults(diffs)
 
 	if filename != "" {
-		output.PrintToStdErr("Computing filename diffs\n")
+		logrus.Info("computing filename diffs")
 		err := diffFile(imageMap[image1Arg], imageMap[image2Arg])
 		if err != nil {
 			return err

cmd/root.go

@@ -161,6 +161,8 @@ func getImageForName(imageName string) (pkgutil.Image, error) {
 		}
 		elapsed := time.Now().Sub(start)
 		logrus.Infof("retrieving image from daemon took %f seconds", elapsed.Seconds())
+		// TODO(nkubala): remove this when we can set compression level in containerregistry
+		noCache = true // force noCache if image is in daemon
 	} else {
 		// either has remote prefix or has no prefix, in which case we force remote
 		imageName = strings.Replace(imageName, RemotePrefix, "", -1)
@@ -191,9 +193,8 @@ func getImageForName(imageName string) (pkgutil.Image, error) {
 		}
 		for _, layer := range imgLayers {
 			layerStart := time.Now()
-			diffID, err := layer.DiffID()
-			logrus.Infof("layer digest: %s", diffID.String())
-			path, err := getExtractPathForName(diffID.String())
+			digest, err := layer.Digest()
+			path, err := getExtractPathForName(digest.String())
 			if err != nil {
 				return pkgutil.Image{
 					Layers: layers,
@@ -214,7 +215,7 @@ func getImageForName(imageName string) (pkgutil.Image, error) {
 		logrus.Infof("time elapsed retrieving image layers: %fs", elapsed.Seconds())
 	}
 
-	path, err := getExtractPathForName(imageName)
+	path, err := getExtractPathForImage(imageName, img)
 	// extract fs into provided dir
 	if err := pkgutil.GetFileSystemForImage(img, path, nil); err != nil {
 		return pkgutil.Image{
@@ -230,6 +231,20 @@ func getImageForName(imageName string) (pkgutil.Image, error) {
 	}, nil
 }
 
+func getExtractPathForImage(imageName string, image v1.Image) (string, error) {
+	if noCache {
+		return getExtractPathForName(imageName)
+	}
+	start := time.Now()
+	digest, err := image.Digest()
+	if err != nil {
+		return "", err
+	}
+	elapsed := time.Now().Sub(start)
+	logrus.Infof("time elapsed retrieving image digest: %fs", elapsed.Seconds())
+	return getExtractPathForName(pkgutil.RemoveTag(imageName) + "@" + digest.String())
+}
+
 func getExtractPathForName(name string) (string, error) {
 	var path string
 	var err error
@@ -244,10 +259,11 @@ func getExtractPathForName(name string) (string, error) {
 			if err != nil {
 				return "", err
 			}
-			logrus.Infof("Image fs cached at %s", path)
+			logrus.Infof("caching filesystem at %s", path)
 		}
 	} else {
 		// otherwise, create tempdir
+		logrus.Infof("skipping caching")
 		path, err = ioutil.TempDir("", strings.Replace(name, "/", "", -1))
 		if err != nil {
 			return "", err

pkg/util/image_utils.go

@@ -33,6 +33,8 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const tagRegexStr = ".*:([^/]+$)"
+
 type Layer struct {
 	FSPath string
 }
@@ -90,7 +92,7 @@ func GetFileSystemForImage(image v1.Image, root string, whitelist []string) erro
 		return err
 	}
 	if !empty {
-		logrus.Infof("Using cached filesystem in %s", root)
+		logrus.Infof("using cached filesystem in %s", root)
 		return nil
 	}
 	if err := unpackTar(tar.NewReader(mutate.Extract(image)), root, whitelist); err != nil {
@@ -143,6 +145,17 @@ func copyToFile(outfile string, r io.Reader) error {
 
 // checks to see if an image string contains a tag.
 func HasTag(image string) bool {
-	tagRegex := regexp.MustCompile(".*:[^/]+$")
+	tagRegex := regexp.MustCompile(tagRegexStr)
 	return tagRegex.MatchString(image)
 }
+
+// returns a raw image name with the tag removed
+func RemoveTag(image string) string {
+	if !HasTag(image) {
+		return image
+	}
+	tagRegex := regexp.MustCompile(tagRegexStr)
+	parts := tagRegex.FindStringSubmatch(image)
+	tag := parts[len(parts)-1]
+	return image[0 : len(image)-len(tag)-1]
+}