Add image and layer size analyzer

peter-evans · peter-evans · commit 4ab93c854e5f · 2018-09-06T19:55:18.000+09:00
diff --git a/differs/differs.go b/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
diff --git a/differs/size_diff.go b/differs/size_diff.go
@@ -0,0 +1,122 @@
+/*
+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.EntryDiff{
+		{
+			Name:  "*",
+			Size1: pkgutil.GetSize(image1.FSPath),
+			Size2: pkgutil.GetSize(image2.FSPath),
+		},
+	}
+
+	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 := []pkgutil.DirectoryEntry{
+		{
+			Name: "*",
+			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.EntryDiff
+
+	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)
+		}
+
+		diff := util.EntryDiff{
+			Name:  strconv.Itoa(index),
+			Size1: size1,
+			Size2: size2,
+		}
+		layerDiffs = append(layerDiffs, diff)
+	}
+
+	return &util.SizeDiffResult{
+		Image1:   image1.Source,
+		Image2:   image2.Source,
+		DiffType: "SizeLayer",
+		Diff:     layerDiffs,
+	}, nil
+}
+
+func (a SizeLayerAnalyzer) Analyze(image pkgutil.Image) (util.Result, error) {
+	var entries []pkgutil.DirectoryEntry
+	for index, layer := range image.Layers {
+		entry := pkgutil.DirectoryEntry{
+			Name: strconv.Itoa(index),
+			Size: pkgutil.GetSize(layer.FSPath),
+		}
+		entries = append(entries, entry)
+	}
+
+	return &util.SizeAnalyzeResult{
+		Image:       image.Source,
+		AnalyzeType: "SizeLayer",
+		Analysis:    entries,
+	}, nil
+}
diff --git a/tests/integration_test.go b/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",
diff --git a/tests/size_analysis_expected.json b/tests/size_analysis_expected.json
@@ -0,0 +1,12 @@
+[
+  {
+    "Image": "gcr.io/gcp-runtimes/diff-base",
+    "AnalyzeType": "Size",
+    "Analysis": [
+      {
+        "Name": "*",
+        "Size": 383043168
+      }
+    ]
+  }
+]
diff --git a/tests/size_diff_expected.json b/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
+      }
+    ]
+  }
+]
diff --git a/tests/size_layer_analysis_expected.json b/tests/size_layer_analysis_expected.json
@@ -0,0 +1,20 @@
+[
+  {
+    "Image": "gcr.io/gcp-runtimes/diff-layer-base",
+    "AnalyzeType": "SizeLayer",
+    "Analysis": [
+      {
+        "Name": "0",
+        "Size": 6
+      },
+      {
+        "Name": "1",
+        "Size": 7
+      },
+      {
+        "Name": "2",
+        "Size": 6
+      }
+    ]
+  }
+]
diff --git a/tests/size_layer_diff_expected.json b/tests/size_layer_diff_expected.json
@@ -0,0 +1,24 @@
+[
+  {
+    "Image1": "gcr.io/gcp-runtimes/diff-layer-base",
+    "Image2": "gcr.io/gcp-runtimes/diff-layer-modified",
+    "DiffType": "SizeLayer",
+    "Diff": [
+      {
+        "Name": "0",
+        "Size1": 6,
+        "Size2": 6
+      },
+      {
+        "Name": "1",
+        "Size1": 7,
+        "Size2": 9
+      },
+      {
+        "Name": "2",
+        "Size1": 6,
+        "Size2": -1
+      }
+    ]
+  }
+]
diff --git a/util/analyze_output_utils.go b/util/analyze_output_utils.go
@@ -340,3 +340,36 @@ func (r FileLayerAnalyzeResult) OutputText(analyzeType string, format string) er
 	}
 	return TemplateOutputFromFormat(strResult, "FileLayerAnalyze", format)
 }
+
+type SizeAnalyzeResult AnalyzeResult
+
+func (r SizeAnalyzeResult) OutputStruct() interface{} {
+	analysis, valid := r.Analysis.([]util.DirectoryEntry)
+	if !valid {
+		logrus.Error("Unexpected structure of Analysis.  Should be of type []DirectoryEntry")
+		return errors.New("Could not output SizeAnalyzer analysis result")
+	}
+	r.Analysis = analysis
+	return r
+}
+
+func (r SizeAnalyzeResult) OutputText(analyzeType string, format string) error {
+	analysis, valid := r.Analysis.([]util.DirectoryEntry)
+	if !valid {
+		logrus.Error("Unexpected structure of Analysis.  Should be of type []DirectoryEntry")
+		return errors.New("Could not output SizeAnalyzer analysis result")
+	}
+
+	strAnalysis := stringifyDirectoryEntries(analysis)
+
+	strResult := struct {
+		Image       string
+		AnalyzeType string
+		Analysis    []StrDirectoryEntry
+	}{
+		Image:       r.Image,
+		AnalyzeType: r.AnalyzeType,
+		Analysis:    strAnalysis,
+	}
+	return TemplateOutputFromFormat(strResult, "SizeAnalyze", format)
+}
diff --git a/util/diff_output_utils.go b/util/diff_output_utils.go
@@ -297,6 +297,42 @@ func (r DirDiffResult) OutputText(diffType string, format string) error {
 	return TemplateOutputFromFormat(strResult, "DirDiff", format)
 }
 
+type SizeDiffResult DiffResult
+
+func (r SizeDiffResult) OutputStruct() interface{} {
+	diff, valid := r.Diff.([]EntryDiff)
+	if !valid {
+		logrus.Error("Unexpected structure of Diff.  Should be of type []EntryDiff")
+		return errors.New("Could not output SizeAnalyzer diff result")
+	}
+
+	r.Diff = diff
+	return r
+}
+
+func (r SizeDiffResult) OutputText(diffType string, format string) error {
+	diff, valid := r.Diff.([]EntryDiff)
+	if !valid {
+		logrus.Error("Unexpected structure of Diff.  Should be of type []EntryDiff")
+		return errors.New("Could not output SizeAnalyzer diff result")
+	}
+
+	strDiff := stringifyEntryDiffs(diff)
+
+	strResult := struct {
+		Image1   string
+		Image2   string
+		DiffType string
+		Diff     []StrEntryDiff
+	}{
+		Image1:   r.Image1,
+		Image2:   r.Image2,
+		DiffType: r.DiffType,
+		Diff:     strDiff,
+	}
+	return TemplateOutputFromFormat(strResult, "SizeDiff", format)
+}
+
 type MultipleDirDiffResult DiffResult
 
 func (r MultipleDirDiffResult) OutputStruct() interface{} {
diff --git a/util/format_utils.go b/util/format_utils.go
@@ -39,6 +39,8 @@ var templates = map[string]string{
 	"ListAnalyze":                      ListAnalysisOutput,
 	"FileAnalyze":                      FileAnalysisOutput,
 	"FileLayerAnalyze":                 FileLayerAnalysisOutput,
+	"SizeAnalyze":                      SizeAnalysisOutput,
+	"SizeDiff":                         SizeDiffOutput,
 	"MultiVersionPackageAnalyze":       MultiVersionPackageOutput,
 	"SingleVersionPackageAnalyze":      SingleVersionPackageOutput,
 	"SingleVersionPackageLayerAnalyze": SingleVersionPackageLayerOutput,
diff --git a/util/template_utils.go b/util/template_utils.go
