Add size analyzer

README.md

@@ -8,6 +8,7 @@ Status](https://travis-ci.org/GoogleContainerTools/container-diff.svg?branch=mas
 container-diff is a tool for analyzing and comparing container images. container-diff can examine images along several different criteria, including:
 - Docker Image History
 - Image file system
+- Image size
 - Apt packages
 - RPM packages
 - pip packages
@@ -45,6 +46,7 @@ To use `container-diff analyze` to perform analysis on a single image, you need
 container-diff analyze <img>     [Run default analyzers]
 container-diff analyze <img> --type=history  [History]
 container-diff analyze <img> --type=file  [File System]
+container-diff analyze <img> --type=size  [Size]
 container-diff analyze <img> --type=rpm  [RPM]
 container-diff analyze <img> --type=pip  [Pip]
 container-diff analyze <img> --type=apt  [Apt]
@@ -60,6 +62,7 @@ To use container-diff to perform a diff analysis on two images, you need two Doc
 container-diff diff <img1> <img2>     [Run default differs]
 container-diff diff <img1> <img2> --type=history  [History]
 container-diff diff <img1> <img2> --type=file  [File System]
+container-diff diff <img1> <img2> --type=size  [Size]
 container-diff diff <img1> <img2> --type=rpm  [RPM]
 container-diff diff <img1> <img2> --type=pip  [Pip]
 container-diff diff <img1> <img2> --type=apt  [Apt]

cmd/root.go

@@ -208,6 +208,7 @@ func getImageForName(imageName string) (pkgutil.Image, error) {
 			}
 			layers = append(layers, pkgutil.Layer{
 				FSPath: path,
+				Digest: digest,
 			})
 			elapsed := time.Now().Sub(layerStart)
 			logrus.Infof("time elapsed retrieving layer: %fs", elapsed.Seconds())
@@ -216,7 +217,11 @@ func getImageForName(imageName string) (pkgutil.Image, error) {
 		logrus.Infof("time elapsed retrieving image layers: %fs", elapsed.Seconds())
 	}
 
-	path, err := getExtractPathForImage(imageName, img)
+	imageDigest, err := getImageDigest(img)
+	if err != nil {
+		return pkgutil.Image{}, err
+	}
+	path, err := getExtractPathForName(pkgutil.RemoveTag(imageName) + "@" + imageDigest.String())
 	if err != nil {
 		return pkgutil.Image{}, err
 	}
@@ -231,19 +236,20 @@ func getImageForName(imageName string) (pkgutil.Image, error) {
 		Image:  img,
 		Source: imageName,
 		FSPath: path,
+		Digest: imageDigest,
 		Layers: layers,
 	}, nil
 }
 
-func getExtractPathForImage(imageName string, image v1.Image) (string, error) {
+func getImageDigest(image v1.Image) (digest v1.Hash, err error) {
 	start := time.Now()
-	digest, err := image.Digest()
+	digest, err = image.Digest()
 	if err != nil {
-		return "", err
+		return digest, err
 	}
 	elapsed := time.Now().Sub(start)
 	logrus.Infof("time elapsed retrieving image digest: %fs", elapsed.Seconds())
-	return getExtractPathForName(pkgutil.RemoveTag(imageName) + "@" + digest.String())
+	return digest, nil
 }
 
 func getExtractPathForName(name string) (string, error) {

differs/differs.go

@@ -28,6 +28,8 @@ const historyAnalyzer = "history"
 const metadataAnalyzer = "metadata"
 const fileAnalyzer = "file"
 const layerAnalyzer = "layer"
+const sizeAnalyzer = "size"
+const sizeLayerAnalyzer = "sizelayer"
 const aptAnalyzer = "apt"
 const aptLayerAnalyzer = "aptlayer"
 const rpmAnalyzer = "rpm"
@@ -53,19 +55,21 @@ type Analyzer interface {
 }
 
 var Analyzers = map[string]Analyzer{
-	historyAnalyzer:  HistoryAnalyzer{},
-	metadataAnalyzer: MetadataAnalyzer{},
-	fileAnalyzer:     FileAnalyzer{},
-	layerAnalyzer:    FileLayerAnalyzer{},
-	aptAnalyzer:      AptAnalyzer{},
-	aptLayerAnalyzer: AptLayerAnalyzer{},
-	rpmAnalyzer:      RPMAnalyzer{},
-	rpmLayerAnalyzer: RPMLayerAnalyzer{},
-	pipAnalyzer:      PipAnalyzer{},
-	nodeAnalyzer:     NodeAnalyzer{},
+	historyAnalyzer:   HistoryAnalyzer{},
+	metadataAnalyzer:  MetadataAnalyzer{},
+	fileAnalyzer:      FileAnalyzer{},
+	layerAnalyzer:     FileLayerAnalyzer{},
+	sizeAnalyzer:      SizeAnalyzer{},
+	sizeLayerAnalyzer: SizeLayerAnalyzer{},
+	aptAnalyzer:       AptAnalyzer{},
+	aptLayerAnalyzer:  AptLayerAnalyzer{},
+	rpmAnalyzer:       RPMAnalyzer{},
+	rpmLayerAnalyzer:  RPMLayerAnalyzer{},
+	pipAnalyzer:       PipAnalyzer{},
+	nodeAnalyzer:      NodeAnalyzer{},
 }
 
-var LayerAnalyzers = [...]string{layerAnalyzer, aptLayerAnalyzer, rpmLayerAnalyzer}
+var LayerAnalyzers = [...]string{layerAnalyzer, sizeLayerAnalyzer, aptLayerAnalyzer, rpmLayerAnalyzer}
 
 func (req DiffRequest) GetDiff() (map[string]util.Result, error) {
 	img1 := req.Image1

differs/size_diff.go

@@ -0,0 +1,129 @@
+/*
+Copyright 2018 Google, Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package differs
+
+import (
+	"strconv"
+
+	pkgutil "github.com/GoogleContainerTools/container-diff/pkg/util"
+	"github.com/GoogleContainerTools/container-diff/util"
+)
+
+type SizeAnalyzer struct {
+}
+
+func (a SizeAnalyzer) Name() string {
+	return "SizeAnalyzer"
+}
+
+// SizeDiff diffs two images and compares their size
+func (a SizeAnalyzer) Diff(image1, image2 pkgutil.Image) (util.Result, error) {
+	diff := []util.SizeDiff{}
+	size1 := pkgutil.GetSize(image1.FSPath)
+	size2 := pkgutil.GetSize(image2.FSPath)
+
+	if size1 != size2 {
+		diff = append(diff, util.SizeDiff{
+			Size1: size1,
+			Size2: size2,
+		})
+	}
+
+	return &util.SizeDiffResult{
+		Image1:   image1.Source,
+		Image2:   image2.Source,
+		DiffType: "Size",
+		Diff:     diff,
+	}, nil
+}
+
+func (a SizeAnalyzer) Analyze(image pkgutil.Image) (util.Result, error) {
+	entries := []util.SizeEntry{
+		{
+			Name:   image.Source,
+			Digest: image.Digest,
+			Size:   pkgutil.GetSize(image.FSPath),
+		},
+	}
+
+	return &util.SizeAnalyzeResult{
+		Image:       image.Source,
+		AnalyzeType: "Size",
+		Analysis:    entries,
+	}, nil
+}
+
+type SizeLayerAnalyzer struct {
+}
+
+func (a SizeLayerAnalyzer) Name() string {
+	return "SizeLayerAnalyzer"
+}
+
+// SizeLayerDiff diffs the layers of two images and compares their size
+func (a SizeLayerAnalyzer) Diff(image1, image2 pkgutil.Image) (util.Result, error) {
+	var layerDiffs []util.SizeDiff
+
+	maxLayer := len(image1.Layers)
+	if len(image2.Layers) > maxLayer {
+		maxLayer = len(image2.Layers)
+	}
+
+	for index := 0; index < maxLayer; index++ {
+		var size1, size2 int64 = -1, -1
+		if index < len(image1.Layers) {
+			size1 = pkgutil.GetSize(image1.Layers[index].FSPath)
+		}
+		if index < len(image2.Layers) {
+			size2 = pkgutil.GetSize(image2.Layers[index].FSPath)
+		}
+
+		if size1 != size2 {
+			diff := util.SizeDiff{
+				Name:  strconv.Itoa(index),
+				Size1: size1,
+				Size2: size2,
+			}
+			layerDiffs = append(layerDiffs, diff)
+		}
+	}
+
+	return &util.SizeLayerDiffResult{
+		Image1:   image1.Source,
+		Image2:   image2.Source,
+		DiffType: "SizeLayer",
+		Diff:     layerDiffs,
+	}, nil
+}
+
+func (a SizeLayerAnalyzer) Analyze(image pkgutil.Image) (util.Result, error) {
+	var entries []util.SizeEntry
+	for index, layer := range image.Layers {
+		entry := util.SizeEntry{
+			Name:   strconv.Itoa(index),
+			Digest: layer.Digest,
+			Size:   pkgutil.GetSize(layer.FSPath),
+		}
+		entries = append(entries, entry)
+	}
+
+	return &util.SizeLayerAnalyzeResult{
+		Image:       image.Source,
+		AnalyzeType: "SizeLayer",
+		Analysis:    entries,
+	}, nil
+}

pkg/util/image_utils.go

@@ -37,12 +37,14 @@ const tagRegexStr = ".*:([^/]+$)"
 
 type Layer struct {
 	FSPath string
+	Digest v1.Hash
 }
 
 type Image struct {
 	Image  v1.Image
 	Source string
 	FSPath string
+	Digest v1.Hash
 	Layers []Layer
 }
 

tests/integration_test.go

@@ -117,6 +117,22 @@ func TestDiffAndAnalysis(t *testing.T) {
 			differFlags:  []string{"--type=layer", "--no-cache"},
 			expectedFile: "file_layer_diff_expected.json",
 		},
+		{
+			description:  "size differ",
+			subcommand:   "diff",
+			imageA:       diffLayerBase,
+			imageB:       diffLayerModifed,
+			differFlags:  []string{"--type=size", "--no-cache"},
+			expectedFile: "size_diff_expected.json",
+		},
+		{
+			description:  "size layer differ",
+			subcommand:   "diff",
+			imageA:       diffLayerBase,
+			imageB:       diffLayerModifed,
+			differFlags:  []string{"--type=sizelayer", "--no-cache"},
+			expectedFile: "size_layer_diff_expected.json",
+		},
 		{
 			description:  "apt differ",
 			subcommand:   "diff",
@@ -209,6 +225,20 @@ func TestDiffAndAnalysis(t *testing.T) {
 			differFlags:  []string{"--type=layer", "--no-cache"},
 			expectedFile: "file_layer_analysis_expected.json",
 		},
+		{
+			description:  "size analysis",
+			subcommand:   "analyze",
+			imageA:       diffBase,
+			differFlags:  []string{"--type=size", "--no-cache"},
+			expectedFile: "size_analysis_expected.json",
+		},
+		{
+			description:  "size layer analysis",
+			subcommand:   "analyze",
+			imageA:       diffLayerBase,
+			differFlags:  []string{"--type=sizelayer", "--no-cache"},
+			expectedFile: "size_layer_analysis_expected.json",
+		},
 		{
 			description:  "pip analysis",
 			subcommand:   "analyze",

tests/size_analysis_expected.json

@@ -0,0 +1,13 @@
+[
+  {
+    "Image": "gcr.io/gcp-runtimes/diff-base",
+    "AnalyzeType": "Size",
+    "Analysis": [
+      {
+        "Name": "gcr.io/gcp-runtimes/diff-base",
+        "Digest": "sha256:d4e51212be9fffca8d3573a35ac12a69d050c3f65f706e053d24f41317762cca",
+        "Size": 383043168
+      }
+    ]
+  }
+]

tests/size_diff_expected.json

@@ -0,0 +1,14 @@
+[
+  {
+    "Image1": "gcr.io/gcp-runtimes/diff-layer-base",
+    "Image2": "gcr.io/gcp-runtimes/diff-layer-modified",
+    "DiffType": "Size",
+    "Diff": [
+      {
+        "Name": "",
+        "Size1": 19,
+        "Size2": 15
+      }
+    ]
+  }
+]

tests/size_layer_analysis_expected.json

@@ -0,0 +1,23 @@
+[
+  {
+    "Image": "gcr.io/gcp-runtimes/diff-layer-base",
+    "AnalyzeType": "SizeLayer",
+    "Analysis": [
+      {
+        "Name": "0",
+        "Digest": "sha256:74a9fa414ff7212ca555a1024826b94e27ec6a436fd971f8e6c2a909b23630a2",
+        "Size": 6
+      },
+      {
+        "Name": "1",
+        "Digest": "sha256:e39d9b94d5c118b34cce2f4af7efd4c7ed2553e697d7f676e24c4091e42a4998",
+        "Size": 7
+      },
+      {
+        "Name": "2",
+        "Digest": "sha256:bda36409f35ed9e71049d22abdce890d6335056ca15bfed9f323be69b0607e24",
+        "Size": 6
+      }
+    ]
+  }
+]

tests/size_layer_diff_expected.json

@@ -0,0 +1,19 @@
+[
+  {
+    "Image1": "gcr.io/gcp-runtimes/diff-layer-base",
+    "Image2": "gcr.io/gcp-runtimes/diff-layer-modified",
+    "DiffType": "SizeLayer",
+    "Diff": [
+      {
+        "Name": "1",
+        "Size1": 7,
+        "Size2": 9
+      },
+      {
+        "Name": "2",
+        "Size1": 6,
+        "Size2": -1
+      }
+    ]
+  }
+]