layer: remove unused error return from .Size() and .DiffSize()

thaJeztah · thaJeztah · commit e1ea911abac7 · 2022-01-24T18:45:47.000+01:00
None of the implementations used return an error, so removing the error
return can simplify using these.

Signed-off-by: Sebastiaan van Stijn &lt;github@gone.nl&gt;
diff --git a/builder/builder-next/adapters/snapshot/snapshot.go b/builder/builder-next/adapters/snapshot/snapshot.go
@@ -405,11 +405,7 @@ func (s *snapshotter) Usage(ctx context.Context, key string) (us snapshots.Usage
 	if l, err := s.getLayer(key, true); err != nil {
 		return usage, err
 	} else if l != nil {
-		s, err := l.DiffSize()
-		if err != nil {
-			return usage, err
-		}
-		usage.Size = s
+		usage.Size = l.DiffSize()
 		return usage, nil
 	}
 
diff --git a/daemon/images/image_history.go b/daemon/images/image_history.go
@@ -40,12 +40,8 @@ func (i *ImageService) ImageHistory(name string) ([]*image.HistoryResponseItem,
 			if err != nil {
 				return nil, err
 			}
-			layerSize, err = l.DiffSize()
+			layerSize = l.DiffSize()
 			layer.ReleaseAndLog(i.layerStore, l)
-			if err != nil {
-				return nil, err
-			}
-
 			layerCounter++
 		}
 
diff --git a/daemon/images/image_inspect.go b/daemon/images/image_inspect.go
@@ -42,11 +42,7 @@ func (i *ImageService) LookupImage(name string) (*types.ImageInspect, error) {
 			return nil, err
 		}
 		defer layer.ReleaseAndLog(i.layerStore, l)
-		size, err = l.Size()
-		if err != nil {
-			return nil, err
-		}
-
+		size = l.Size()
 		layerMetadata, err = l.Metadata()
 		if err != nil {
 			return nil, err
diff --git a/daemon/images/image_prune.go b/daemon/images/image_prune.go
@@ -143,12 +143,7 @@ deleteImagesLoop:
 		if d.Deleted != "" {
 			chid := layer.ChainID(d.Deleted)
 			if l, ok := allLayers[chid]; ok {
-				diffSize, err := l.DiffSize()
-				if err != nil {
-					logrus.Warnf("failed to get layer %s size: %v", chid, err)
-					continue
-				}
-				rep.SpaceReclaimed += uint64(diffSize)
+				rep.SpaceReclaimed += uint64(l.DiffSize())
 			}
 		}
 	}
diff --git a/daemon/images/image_unix.go b/daemon/images/image_unix.go
@@ -33,10 +33,8 @@ func (i *ImageService) GetContainerLayerSize(containerID string) (int64, int64)
 	}
 
 	if parent := rwlayer.Parent(); parent != nil {
-		sizeRootfs, err = parent.Size()
-		if err != nil {
-			sizeRootfs = -1
-		} else if sizeRw != -1 {
+		sizeRootfs = parent.Size()
+		if sizeRw != -1 {
 			sizeRootfs += sizeRw
 		}
 	}
diff --git a/daemon/images/images.go b/daemon/images/images.go
@@ -128,11 +128,8 @@ func (i *ImageService) Images(_ context.Context, opts types.ImageListOptions) ([
 				return nil, err
 			}
 
-			size, err = l.Size()
+			size = l.Size()
 			layer.ReleaseAndLog(i.layerStore, l)
-			if err != nil {
-				return nil, err
-			}
 		}
 
 		summary := newImageSummary(img, size)
@@ -244,11 +241,7 @@ func (i *ImageService) Images(_ context.Context, opts types.ImageListOptions) ([
 					if _, ok := allLayers[chid]; !ok {
 						return nil, fmt.Errorf("layer %v was not found (corruption?)", chid)
 					}
-					diffSize, err := allLayers[chid].DiffSize()
-					if err != nil {
-						return nil, err
-					}
-					summary.SharedSize += diffSize
+					summary.SharedSize += allLayers[chid].DiffSize()
 				}
 			}
 		}
diff --git a/daemon/images/service.go b/daemon/images/service.go
@@ -209,13 +209,9 @@ func (i *ImageService) LayerDiskUsage(ctx context.Context) (int64, error) {
 			case <-ctx.Done():
 				return allLayersSize, ctx.Err()
 			default:
-				size, err := l.DiffSize()
-				if err == nil {
-					if _, ok := layerRefs[l.ChainID()]; ok {
-						allLayersSize += size
-					}
-				} else {
-					logrus.Warnf("failed to get diff size for layer %v", l.ChainID())
+				size := l.DiffSize()
+				if _, ok := layerRefs[l.ChainID()]; ok {
+					allLayersSize += size
 				}
 			}
 		}
diff --git a/distribution/config.go b/distribution/config.go
@@ -230,7 +230,7 @@ func (l *storeLayer) Open() (io.ReadCloser, error) {
 }
 
 func (l *storeLayer) Size() (int64, error) {
-	return l.Layer.DiffSize()
+	return l.Layer.DiffSize(), nil
 }
 
 func (l *storeLayer) MediaType() string {
diff --git a/distribution/xfer/download_test.go b/distribution/xfer/download_test.go
@@ -48,12 +48,12 @@ func (ml *mockLayer) Parent() layer.Layer {
 	return ml.parent
 }
 
-func (ml *mockLayer) Size() (size int64, err error) {
-	return 0, nil
+func (ml *mockLayer) Size() int64 {
+	return 0
 }
 
-func (ml *mockLayer) DiffSize() (size int64, err error) {
-	return 0, nil
+func (ml *mockLayer) DiffSize() int64 {
+	return 0
 }
 
 func (ml *mockLayer) Metadata() (map[string]string, error) {
diff --git a/layer/empty.go b/layer/empty.go
@@ -42,12 +42,12 @@ func (el *emptyLayer) Parent() Layer {
 	return nil
 }
 
-func (el *emptyLayer) Size() (size int64, err error) {
-	return 0, nil
+func (el *emptyLayer) Size() int64 {
+	return 0
 }
 
-func (el *emptyLayer) DiffSize() (size int64, err error) {
-	return 0, nil
+func (el *emptyLayer) DiffSize() int64 {
+	return 0
 }
 
 func (el *emptyLayer) Metadata() (map[string]string, error) {
diff --git a/layer/empty_test.go b/layer/empty_test.go
@@ -20,11 +20,11 @@ func TestEmptyLayer(t *testing.T) {
 		t.Fatal("expected no parent for empty layer")
 	}
 
-	if size, err := EmptyLayer.Size(); err != nil || size != 0 {
+	if size := EmptyLayer.Size(); size != 0 {
 		t.Fatal("expected zero size for empty layer")
 	}
 
-	if diffSize, err := EmptyLayer.DiffSize(); err != nil || diffSize != 0 {
+	if diffSize := EmptyLayer.DiffSize(); diffSize != 0 {
 		t.Fatal("expected zero diffsize for empty layer")
 	}
 
diff --git a/layer/layer.go b/layer/layer.go
@@ -102,11 +102,11 @@ type Layer interface {
 
 	// Size returns the size of the entire layer chain. The size
 	// is calculated from the total size of all files in the layers.
-	Size() (int64, error)
+	Size() int64
 
 	// DiffSize returns the size difference of the top layer
 	// from parent layer.
-	DiffSize() (int64, error)
+	DiffSize() int64
 
 	// Metadata returns the low level storage metadata associated
 	// with layer.
diff --git a/layer/layer_store.go b/layer/layer_store.go
@@ -439,7 +439,7 @@ func (ls *layerStore) deleteLayer(layer *roLayer, metadata *Metadata) error {
 	}
 	metadata.DiffID = layer.diffID
 	metadata.ChainID = layer.chainID
-	metadata.Size, err = layer.Size()
+	metadata.Size = layer.Size()
 	if err != nil {
 		return err
 	}
diff --git a/layer/layer_test.go b/layer/layer_test.go
@@ -173,14 +173,9 @@ func getCachedLayer(l Layer) *roLayer {
 func createMetadata(layers ...Layer) []Metadata {
 	metadata := make([]Metadata, len(layers))
 	for i := range layers {
-		size, err := layers[i].Size()
-		if err != nil {
-			panic(err)
-		}
-
 		metadata[i].ChainID = layers[i].ChainID()
 		metadata[i].DiffID = layers[i].DiffID()
-		metadata[i].Size = size
+		metadata[i].Size = layers[i].Size()
 		metadata[i].DiffSize = getCachedLayer(layers[i]).size
 	}
 
@@ -229,15 +224,8 @@ func assertLayerEqual(t *testing.T, l1, l2 Layer) {
 		t.Fatalf("Mismatched DiffID: %s vs %s", l1.DiffID(), l2.DiffID())
 	}
 
-	size1, err := l1.Size()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	size2, err := l2.Size()
-	if err != nil {
-		t.Fatal(err)
-	}
+	size1 := l1.Size()
+	size2 := l2.Size()
 
 	if size1 != size2 {
 		t.Fatalf("Mismatched size: %d vs %d", size1, size2)
@@ -266,7 +254,7 @@ func TestMountAndRegister(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	size, _ := layer.Size()
+	size := layer.Size()
 	t.Logf("Layer size: %d", size)
 
 	mount2, err := ls.CreateRWLayer("new-test-mount", layer.ChainID(), nil)
diff --git a/layer/layer_unix_test.go b/layer/layer_unix_test.go
@@ -44,11 +44,7 @@ func TestLayerSize(t *testing.T) {
 		t.Fatalf("Unexpected diff size %d, expected %d", layer1DiffSize, len(content1))
 	}
 
-	layer1Size, err := layer1.Size()
-	if err != nil {
-		t.Fatal(err)
-	}
-
+	layer1Size := layer1.Size()
 	if expected := len(content1); int(layer1Size) != expected {
 		t.Fatalf("Unexpected size %d, expected %d", layer1Size, expected)
 	}
@@ -62,10 +58,7 @@ func TestLayerSize(t *testing.T) {
 		t.Fatalf("Unexpected diff size %d, expected %d", layer2DiffSize, len(content2))
 	}
 
-	layer2Size, err := layer2.Size()
-	if err != nil {
-		t.Fatal(err)
-	}
+	layer2Size := layer2.Size()
 
 	if expected := len(content1) + len(content2); int(layer2Size) != expected {
 		t.Fatalf("Unexpected size %d, expected %d", layer2Size, expected)
diff --git a/layer/ro_layer.go b/layer/ro_layer.go
@@ -73,19 +73,17 @@ func (rl *roLayer) Parent() Layer {
 	return rl.parent
 }
 
-func (rl *roLayer) Size() (size int64, err error) {
+func (rl *roLayer) Size() int64 {
+	size := rl.size
 	if rl.parent != nil {
-		size, err = rl.parent.Size()
-		if err != nil {
-			return
-		}
+		size += rl.parent.Size()
 	}
 
-	return size + rl.size, nil
+	return size
 }
 
-func (rl *roLayer) DiffSize() (size int64, err error) {
-	return rl.size, nil
+func (rl *roLayer) DiffSize() int64 {
+	return rl.size
 }
 
 func (rl *roLayer) Metadata() (map[string]string, error) {

Original file line number	Diff line number	Diff line change
`@@ -40,12 +40,8 @@ func (i ImageService) ImageHistory(name string) ([]image.HistoryResponseItem,`
`40`	`40`	`if err != nil {`
`41`	`41`	`return nil, err`
`42`	`42`	`}`
`43`		`- layerSize, err = l.DiffSize()`
	`43`	`+ layerSize = l.DiffSize()`
`44`	`44`	`layer.ReleaseAndLog(i.layerStore, l)`
`45`		`- if err != nil {`
`46`		`- return nil, err`
`47`		`- }`
`48`		`-`
`49`	`45`	`layerCounter++`
`50`	`46`	`}`
`51`	`47`
Original file line number	Diff line number	Diff line change
`@@ -143,12 +143,7 @@ deleteImagesLoop:`
`143`	`143`	`if d.Deleted != "" {`
`144`	`144`	`chid := layer.ChainID(d.Deleted)`
`145`	`145`	`if l, ok := allLayers[chid]; ok {`
`146`		`- diffSize, err := l.DiffSize()`
`147`		`- if err != nil {`
`148`		`- logrus.Warnf("failed to get layer %s size: %v", chid, err)`
`149`		`- continue`
`150`		`- }`
`151`		`- rep.SpaceReclaimed += uint64(diffSize)`
	`146`	`+ rep.SpaceReclaimed += uint64(l.DiffSize())`
`152`	`147`	`}`
`153`	`148`	`}`
`154`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,8 @@ func (i *ImageService) GetContainerLayerSize(containerID string) (int64, int64)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`if parent := rwlayer.Parent(); parent != nil {`
`36`		`- sizeRootfs, err = parent.Size()`
`37`		`- if err != nil {`
`38`		`- sizeRootfs = -1`
`39`		`- } else if sizeRw != -1 {`
	`36`	`+ sizeRootfs = parent.Size()`
	`37`	`+ if sizeRw != -1 {`
`40`	`38`	`sizeRootfs += sizeRw`
`41`	`39`	`}`
`42`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,11 +128,8 @@ func (i *ImageService) Images(_ context.Context, opts types.ImageListOptions) ([`
`128`	`128`	`return nil, err`
`129`	`129`	`}`
`130`	`130`
`131`		`- size, err = l.Size()`
	`131`	`+ size = l.Size()`
`132`	`132`	`layer.ReleaseAndLog(i.layerStore, l)`
`133`		`- if err != nil {`
`134`		`- return nil, err`
`135`		`- }`
`136`	`133`	`}`
`137`	`134`
`138`	`135`	`summary := newImageSummary(img, size)`
`@@ -244,11 +241,7 @@ func (i *ImageService) Images(_ context.Context, opts types.ImageListOptions) ([`
`244`	`241`	`if _, ok := allLayers[chid]; !ok {`
`245`	`242`	`return nil, fmt.Errorf("layer %v was not found (corruption?)", chid)`
`246`	`243`	`}`
`247`		`- diffSize, err := allLayers[chid].DiffSize()`
`248`		`- if err != nil {`
`249`		`- return nil, err`
`250`		`- }`
`251`		`- summary.SharedSize += diffSize`
	`244`	`+ summary.SharedSize += allLayers[chid].DiffSize()`
`252`	`245`	`}`
`253`	`246`	`}`
`254`	`247`	`}`
Original file line number	Diff line number	Diff line change
`@@ -209,13 +209,9 @@ func (i *ImageService) LayerDiskUsage(ctx context.Context) (int64, error) {`
`209`	`209`	`case <-ctx.Done():`
`210`	`210`	`return allLayersSize, ctx.Err()`
`211`	`211`	`default:`
`212`		`- size, err := l.DiffSize()`
`213`		`- if err == nil {`
`214`		`- if _, ok := layerRefs[l.ChainID()]; ok {`
`215`		`- allLayersSize += size`
`216`		`- }`
`217`		`- } else {`
`218`		`- logrus.Warnf("failed to get diff size for layer %v", l.ChainID())`
	`212`	`+ size := l.DiffSize()`
	`213`	`+ if _, ok := layerRefs[l.ChainID()]; ok {`
	`214`	`+ allLayersSize += size`
`219`	`215`	`}`
`220`	`216`	`}`
`221`	`217`	`}`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ func (l *storeLayer) Open() (io.ReadCloser, error) {`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`func (l *storeLayer) Size() (int64, error) {`
`233`		`- return l.Layer.DiffSize()`
	`233`	`+ return l.Layer.DiffSize(), nil`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`func (l *storeLayer) MediaType() string {`
Original file line number	Diff line number	Diff line change
`@@ -48,12 +48,12 @@ func (ml *mockLayer) Parent() layer.Layer {`
`48`	`48`	`return ml.parent`
`49`	`49`	`}`
`50`	`50`
`51`		`-func (ml *mockLayer) Size() (size int64, err error) {`
`52`		`- return 0, nil`
	`51`	`+func (ml *mockLayer) Size() int64 {`
	`52`	`+ return 0`
`53`	`53`	`}`
`54`	`54`
`55`		`-func (ml *mockLayer) DiffSize() (size int64, err error) {`
`56`		`- return 0, nil`
	`55`	`+func (ml *mockLayer) DiffSize() int64 {`
	`56`	`+ return 0`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`func (ml *mockLayer) Metadata() (map[string]string, error) {`
Original file line number	Diff line number	Diff line change
`@@ -42,12 +42,12 @@ func (el *emptyLayer) Parent() Layer {`
`42`	`42`	`return nil`
`43`	`43`	`}`
`44`	`44`
`45`		`-func (el *emptyLayer) Size() (size int64, err error) {`
`46`		`- return 0, nil`
	`45`	`+func (el *emptyLayer) Size() int64 {`
	`46`	`+ return 0`
`47`	`47`	`}`
`48`	`48`
`49`		`-func (el *emptyLayer) DiffSize() (size int64, err error) {`
`50`		`- return 0, nil`
	`49`	`+func (el *emptyLayer) DiffSize() int64 {`
	`50`	`+ return 0`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`func (el *emptyLayer) Metadata() (map[string]string, error) {`