851aace Merge pull request #150 from bnema/fix/registry-prune-space-reclaimed · gordon

M internal/adapters/out/filesystem/blob.go +14 -6


@@ -136,26 +136,34 @@ func (s *BlobStorage) PutBlob(digest string, data io.Reader, size int64) error {
136	136		}
137	137
138	138		// DeleteBlob removes a blob by digest.
139		-	func (s *BlobStorage) DeleteBlob(digest string) error {
	139	+	// Returns the size in bytes of the removed blob.
	140	+	func (s *BlobStorage) DeleteBlob(digest string) (int64, error) {
140	141		blobPath, err := s.getBlobPath(digest)
141	142		if err != nil {
142		-	return fmt.Errorf("invalid path: %w", err)
	143	+	return 0, fmt.Errorf("invalid path: %w", err)
143	144		}
144	145
145		-	if err := os.Remove(blobPath); err != nil {
	146	+	info, err := os.Stat(blobPath)
	147	+	if err != nil {
146	148		if os.IsNotExist(err) {
147		-	return fmt.Errorf("blob not found: %s", digest)
	149	+	return 0, fmt.Errorf("blob not found: %s", digest)
148	150		}
149		-	return fmt.Errorf("failed to delete blob: %w", err)
	151	+	return 0, fmt.Errorf("failed to stat blob: %w", err)
	152	+	}
	153	+	size := info.Size()
	154	+
	155	+	if err := os.Remove(blobPath); err != nil {
	156	+	return 0, fmt.Errorf("failed to delete blob: %w", err)
150	157		}
151	158
152	159		s.log.Info().
153	160		Str(zerowrap.FieldLayer, "adapter").
154	161		Str(zerowrap.FieldAdapter, "filesystem").
155	162		Str("digest", digest).
	163	+	Int64(zerowrap.FieldSize, size).
156	164		Msg("blob deleted")
157	165
158		-	return nil
	166	+	return size, nil
159	167		}
160	168
161	169		// BlobExists checks if a blob exists.

 }
 // DeleteBlob removes a blob by digest.
-func (s *BlobStorage) DeleteBlob(digest string) error {
+// Returns the size in bytes of the removed blob.
+func (s *BlobStorage) DeleteBlob(digest string) (int64, error) {
 	blobPath, err := s.getBlobPath(digest)
 	if err != nil {
-		return fmt.Errorf("invalid path: %w", err)
+		return 0, fmt.Errorf("invalid path: %w", err)
 	}
-	if err := os.Remove(blobPath); err != nil {
+	info, err := os.Stat(blobPath)
+	if err != nil {
 		if os.IsNotExist(err) {
-			return fmt.Errorf("blob not found: %s", digest)
+			return 0, fmt.Errorf("blob not found: %s", digest)
 		}
-		return fmt.Errorf("failed to delete blob: %w", err)
+		return 0, fmt.Errorf("failed to stat blob: %w", err)
+	}
+	size := info.Size()
+	if err := os.Remove(blobPath); err != nil {
+		return 0, fmt.Errorf("failed to delete blob: %w", err)
 	}
 	s.log.Info().
 		Str(zerowrap.FieldLayer, "adapter").
 		Str(zerowrap.FieldAdapter, "filesystem").
 		Str("digest", digest).
+		Int64(zerowrap.FieldSize, size).
 		Msg("blob deleted")
-	return nil
+	return size, nil
 }
 // BlobExists checks if a blob exists.

M internal/adapters/out/filesystem/blob_test.go +4 -2


@@ -175,8 +175,9 @@ func TestBlobStorage_DeleteBlob(t *testing.T) {
175	175		assert.True(t, storage.BlobExists(testDigest2))
176	176
177	177		// Delete blob
178		-	err = storage.DeleteBlob(testDigest2)
	178	+	size, err := storage.DeleteBlob(testDigest2)
179	179		require.NoError(t, err)
	180	+	assert.Equal(t, int64(len(blobData)), size)
180	181
181	182		// Verify it's gone
182	183		assert.False(t, storage.BlobExists(testDigest2))

@@ -189,9 +190,10 @@ func TestBlobStorage_DeleteBlob_NotFound(t *testing.T) {
189	190		storage, err := NewBlobStorage(tmpDir, log)
190	191		require.NoError(t, err)
191	192
192		-	err = storage.DeleteBlob(testDigestMissing)
	193	+	size, err := storage.DeleteBlob(testDigestMissing)
193	194
194	195		assert.Error(t, err)
	196	+	assert.Equal(t, int64(0), size)
195	197		assert.Contains(t, err.Error(), "blob not found")
196	198		}
197	199

 	assert.True(t, storage.BlobExists(testDigest2))
 	// Delete blob
-	err = storage.DeleteBlob(testDigest2)
+	size, err := storage.DeleteBlob(testDigest2)
 	require.NoError(t, err)
+	assert.Equal(t, int64(len(blobData)), size)
 	// Verify it's gone
 	assert.False(t, storage.BlobExists(testDigest2))
 	storage, err := NewBlobStorage(tmpDir, log)
 	require.NoError(t, err)
-	err = storage.DeleteBlob(testDigestMissing)
+	size, err := storage.DeleteBlob(testDigestMissing)
 	assert.Error(t, err)
+	assert.Equal(t, int64(0), size)
 	assert.Contains(t, err.Error(), "blob not found")
 }

M internal/boundaries/out/mocks/mock_blob_storage.go +17 -8


@@ -279,20 +279,29 @@ func (_c *MockBlobStorage_CleanupStaleUploads_Call) RunAndReturn(run func(maxAge
279	279		}
280	280
281	281		// DeleteBlob provides a mock function for the type MockBlobStorage
282		-	func (_mock *MockBlobStorage) DeleteBlob(digest string) error {
	282	+	func (_mock *MockBlobStorage) DeleteBlob(digest string) (int64, error) {
283	283		ret := _mock.Called(digest)
284	284
285	285		if len(ret) == 0 {
286	286		panic("no return value specified for DeleteBlob")
287	287		}
288	288
289		-	var r0 error
290		-	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
	289	+	var r0 int64
	290	+	var r1 error
	291	+	if returnFunc, ok := ret.Get(0).(func(string) (int64, error)); ok {
	292	+	return returnFunc(digest)
	293	+	}
	294	+	if returnFunc, ok := ret.Get(0).(func(string) int64); ok {
291	295		r0 = returnFunc(digest)
292	296		} else {
293		-	r0 = ret.Error(0)
	297	+	r0 = ret.Get(0).(int64)
294	298		}
295		-	return r0
	299	+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
	300	+	r1 = returnFunc(digest)
	301	+	} else {
	302	+	r1 = ret.Error(1)
	303	+	}
	304	+	return r0, r1
296	305		}
297	306
298	307		// MockBlobStorage_DeleteBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBlob'

@@ -319,12 +328,12 @@ func (_c MockBlobStorage_DeleteBlob_Call) Run(run func(digest string)) MockBlo
319	328		return _c
320	329		}
321	330
322		-	func (_c MockBlobStorage_DeleteBlob_Call) Return(err error) MockBlobStorage_DeleteBlob_Call {
323		-	_c.Call.Return(err)
	331	+	func (_c MockBlobStorage_DeleteBlob_Call) Return(n int64, err error) MockBlobStorage_DeleteBlob_Call {
	332	+	_c.Call.Return(n, err)
324	333		return _c
325	334		}
326	335
327		-	func (_c MockBlobStorage_DeleteBlob_Call) RunAndReturn(run func(digest string) error) MockBlobStorage_DeleteBlob_Call {
	336	+	func (_c MockBlobStorage_DeleteBlob_Call) RunAndReturn(run func(digest string) (int64, error)) MockBlobStorage_DeleteBlob_Call {
328	337		_c.Call.Return(run)
329	338		return _c
330	339		}

 }
 // DeleteBlob provides a mock function for the type MockBlobStorage
-func (_mock *MockBlobStorage) DeleteBlob(digest string) error {
+func (_mock *MockBlobStorage) DeleteBlob(digest string) (int64, error) {
 	ret := _mock.Called(digest)
 	if len(ret) == 0 {
 		panic("no return value specified for DeleteBlob")
 	}
-	var r0 error
+	var r0 int64
-	if returnFunc, ok := ret.Get(0).(func(string) error); ok {
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(string) (int64, error)); ok {
+		return returnFunc(digest)
+	}
+	if returnFunc, ok := ret.Get(0).(func(string) int64); ok {
 		r0 = returnFunc(digest)
 	} else {
-		r0 = ret.Error(0)
+		r0 = ret.Get(0).(int64)
 	}
-	return r0
+	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
+		r1 = returnFunc(digest)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
 }
 // MockBlobStorage_DeleteBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBlob'
 	return _c
 }
-func (_c *MockBlobStorage_DeleteBlob_Call) Return(err error) *MockBlobStorage_DeleteBlob_Call {
+func (_c *MockBlobStorage_DeleteBlob_Call) Return(n int64, err error) *MockBlobStorage_DeleteBlob_Call {
-	_c.Call.Return(err)
+	_c.Call.Return(n, err)
 	return _c
 }
-func (_c *MockBlobStorage_DeleteBlob_Call) RunAndReturn(run func(digest string) error) *MockBlobStorage_DeleteBlob_Call {
+func (_c *MockBlobStorage_DeleteBlob_Call) RunAndReturn(run func(digest string) (int64, error)) *MockBlobStorage_DeleteBlob_Call {
 	_c.Call.Return(run)
 	return _c
 }

M internal/boundaries/out/storage.go +2 -1


@@ -17,7 +17,8 @@ type BlobStorage interface {
17	17		PutBlob(digest string, data io.Reader, size int64) error
18	18
19	19		// DeleteBlob removes a blob by digest.
20		-	DeleteBlob(digest string) error
	20	+	// Returns the size in bytes of the removed blob.
	21	+	DeleteBlob(digest string) (int64, error)
21	22
22	23		// BlobExists checks if a blob exists.
23	24		BlobExists(digest string) bool


@@ -17,7 +17,8 @@ type BlobStorage interface {
17		PutBlob(digest string, data io.Reader, size int64) error	17		PutBlob(digest string, data io.Reader, size int64) error
18			18
19		// DeleteBlob removes a blob by digest.	19		// DeleteBlob removes a blob by digest.
20	-	DeleteBlob(digest string) error	20	+	// Returns the size in bytes of the removed blob.
			21	+	DeleteBlob(digest string) (int64, error)
21			22
22		// BlobExists checks if a blob exists.	23		// BlobExists checks if a blob exists.
23		BlobExists(digest string) bool	24		BlobExists(digest string) bool

M internal/usecase/images/service.go +3 -1


@@ -243,10 +243,12 @@ func (s *Service) PruneRegistry(ctx context.Context, keepLast int) (domain.Image
243	243		if _, referenced := referencedDigests[digest]; referenced {
244	244		continue
245	245		}
246		-	if err := s.blobStorage.DeleteBlob(digest); err != nil {
	246	+	size, err := s.blobStorage.DeleteBlob(digest)
	247	+	if err != nil {
247	248		return domain.ImagePruneReport{}, log.WrapErr(err, "failed to delete blob")
248	249		}
249	250		report.Registry.BlobsRemoved++
	251	+	report.Registry.SpaceReclaimed += size
250	252		}
251	253
252	254		// Clean up stale uploads (abandoned push operations)

 		if _, referenced := referencedDigests[digest]; referenced {
 			continue
 		}
-		if err := s.blobStorage.DeleteBlob(digest); err != nil {
+		size, err := s.blobStorage.DeleteBlob(digest)
+		if err != nil {
 			return domain.ImagePruneReport{}, log.WrapErr(err, "failed to delete blob")
 		}
 		report.Registry.BlobsRemoved++
+		report.Registry.SpaceReclaimed += size
 	}
 	// Clean up stale uploads (abandoned push operations)

M internal/usecase/images/service_test.go +12 -3


@@ -318,13 +318,17 @@ func TestService_PruneRegistry_GarbageCollectsUnreferencedBlobs(t *testing.T) {
318	318		manifestStorage.modTimes[manifestRefKey("gordon/api", "latest")] = time.Date(2026, 2, 8, 12, 0, 0, 0, time.UTC)
319	319		manifestStorage.manifests[manifestRefKey("gordon/api", "latest")] = mustManifestJSON(t, "sha256:cfg-live", "sha256:layer-live")
320	320
321		-	blobStorage := &fakeBlobStorage{blobs: []string{"sha256:cfg-live", "sha256:layer-live", "sha256:orphan"}}
	321	+	blobStorage := &fakeBlobStorage{
	322	+	blobs: []string{"sha256:cfg-live", "sha256:layer-live", "sha256:orphan"},
	323	+	blobSizes: map[string]int64{"sha256:orphan": 4096},
	324	+	}
322	325		svc := NewService(&fakeRuntime{}, manifestStorage, blobStorage, zerowrap.Default())
323	326
324	327		report, err := svc.PruneRegistry(context.Background(), 1)
325	328
326	329		require.NoError(t, err)
327	330		assert.Equal(t, 1, report.Registry.BlobsRemoved)
	331	+	assert.Equal(t, int64(4096), report.Registry.SpaceReclaimed)
328	332		assert.Equal(t, []string{"sha256:orphan"}, blobStorage.deletedBlobs)
329	333		}
330	334

@@ -663,6 +667,7 @@ type fakeBlobStorage struct {
663	667		out.BlobStorage
664	668
665	669		blobs []string
	670	+	blobSizes map[string]int64
666	671		deletedBlobs []string
667	672		}
668	673

@@ -789,8 +794,12 @@ func (f *fakeBlobStorage) ListBlobs() ([]string, error) {
789	794		return append([]string(nil), f.blobs...), nil
790	795		}
791	796
792		-	func (f *fakeBlobStorage) DeleteBlob(digest string) error {
	797	+	func (f *fakeBlobStorage) DeleteBlob(digest string) (int64, error) {
793	798		f.deletedBlobs = append(f.deletedBlobs, digest)
	799	+	var size int64
	800	+	if f.blobSizes != nil {
	801	+	size = f.blobSizes[digest]
	802	+	}
794	803		for i, existing := range f.blobs {
795	804		if existing != digest {
796	805		continue

@@ -798,7 +807,7 @@ func (f *fakeBlobStorage) DeleteBlob(digest string) error {
798	807		f.blobs = append(f.blobs[:i], f.blobs[i+1:]...)
799	808		break
800	809		}
801		-	return nil
	810	+	return size, nil
802	811		}
803	812
804	813		func (f *fakeBlobStorage) CleanupStaleUploads(_ time.Duration) (int, int64, error) {

 	manifestStorage.modTimes[manifestRefKey("gordon/api", "latest")] = time.Date(2026, 2, 8, 12, 0, 0, 0, time.UTC)
 	manifestStorage.manifests[manifestRefKey("gordon/api", "latest")] = mustManifestJSON(t, "sha256:cfg-live", "sha256:layer-live")
-	blobStorage := &fakeBlobStorage{blobs: []string{"sha256:cfg-live", "sha256:layer-live", "sha256:orphan"}}
+	blobStorage := &fakeBlobStorage{
+		blobs:     []string{"sha256:cfg-live", "sha256:layer-live", "sha256:orphan"},
+		blobSizes: map[string]int64{"sha256:orphan": 4096},
+	}
 	svc := NewService(&fakeRuntime{}, manifestStorage, blobStorage, zerowrap.Default())
 	report, err := svc.PruneRegistry(context.Background(), 1)
 	require.NoError(t, err)
 	assert.Equal(t, 1, report.Registry.BlobsRemoved)
+	assert.Equal(t, int64(4096), report.Registry.SpaceReclaimed)
 	assert.Equal(t, []string{"sha256:orphan"}, blobStorage.deletedBlobs)
 }
 	out.BlobStorage
 	blobs        []string
+	blobSizes    map[string]int64
 	deletedBlobs []string
 }
 	return append([]string(nil), f.blobs...), nil
 }
-func (f *fakeBlobStorage) DeleteBlob(digest string) error {
+func (f *fakeBlobStorage) DeleteBlob(digest string) (int64, error) {
 	f.deletedBlobs = append(f.deletedBlobs, digest)
+	var size int64
+	if f.blobSizes != nil {
+		size = f.blobSizes[digest]
+	}
 	for i, existing := range f.blobs {
 		if existing != digest {
 			continue
 		f.blobs = append(f.blobs[:i], f.blobs[i+1:]...)
 		break
 	}
-	return nil
+	return size, nil
 }
 func (f *fakeBlobStorage) CleanupStaleUploads(_ time.Duration) (int, int64, error) {