Skip to content

Modern Docker Management, Designed for Everyone

fix: image counts are incorrectly calculated (#1760)

Kyle Mendell0efdd8033ec9
diff --git a/backend/internal/services/docker_client_service.go b/backend/internal/services/docker_client_service.go
index 892671f3c..8a8024a83 100644
--- a/backend/internal/services/docker_client_service.go
+++ b/backend/internal/services/docker_client_service.go
@@ -100,21 +100,39 @@ func (s *DockerClientService) GetAllImages(ctx context.Context) ([]image.Summary
defer cancel()
images, err := dockerClient.ImageList(apiCtx, image.ListOptions{All: true})
+ if err != nil {
+ return nil, 0, 0, 0, fmt.Errorf("failed to list Docker images: %w", err)
+ }
+
+ containers, err := dockerClient.ContainerList(apiCtx, container.ListOptions{All: true})
if err != nil {
return nil, 0, 0, 0, fmt.Errorf("failed to list Docker containers: %w", err)
}
- var inuse, unused, total int
- for _, i := range images {
+ inuse, unused, total := countImageUsageInternal(images, containers)
+
+ return images, inuse, unused, total, nil
+}
+
+func countImageUsageInternal(images []image.Summary, containers []container.Summary) (inuse int, unused int, total int) {
+ inUseImageIDs := make(map[string]struct{}, len(containers))
+ for _, c := range containers {
+ if c.ImageID == "" {
+ continue
+ }
+ inUseImageIDs[c.ImageID] = struct{}{}
+ }
+
+ for _, img := range images {
total++
- if i.Containers >= 1 {
+ if _, ok := inUseImageIDs[img.ID]; ok {
inuse++
- } else {
- unused++
+ continue
}
+ unused++
}
- return images, inuse, unused, total, nil
+ return inuse, unused, total
}
func (s *DockerClientService) GetAllNetworks(ctx context.Context) (_ []network.Summary, inuseNetworks int, unusedNetworks int, totalNetworks int, error error) {
diff --git a/backend/internal/services/docker_client_service_test.go b/backend/internal/services/docker_client_service_test.go
new file mode 100644
index 000000000..06a784ed1
--- /dev/null
+++ b/backend/internal/services/docker_client_service_test.go
@@ -0,0 +1,38 @@
+package services
+
+import (
+ "testing"
+
+ "github.com/docker/docker/api/types/container"
+ "github.com/docker/docker/api/types/image"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestCountImageUsage_UsesContainerImageIDs(t *testing.T) {
+ images := []image.Summary{
+ {ID: "sha256:image-a", Containers: -1},
+ {ID: "sha256:image-b", Containers: 0},
+ {ID: "sha256:image-c", Containers: 99},
+ }
+
+ containers := []container.Summary{
+ {ImageID: "sha256:image-a"},
+ {ImageID: "sha256:image-c"},
+ {ImageID: "sha256:image-a"}, // duplicate container ref should not affect counts
+ {ImageID: ""},
+ }
+
+ inuse, unused, total := countImageUsageInternal(images, containers)
+
+ assert.Equal(t, 2, inuse)
+ assert.Equal(t, 1, unused)
+ assert.Equal(t, 3, total)
+}
+
+func TestCountImageUsage_NoImages(t *testing.T) {
+ inuse, unused, total := countImageUsageInternal(nil, []container.Summary{{ImageID: "sha256:image-a"}})
+
+ assert.Equal(t, 0, inuse)
+ assert.Equal(t, 0, unused)
+ assert.Equal(t, 0, total)
+}
diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.go
index 37a6c8c81..cdef886c1 100644
--- a/backend/internal/services/image_service.go
+++ b/backend/internal/services/image_service.go
@@ -132,6 +132,12 @@ func (s *ImageService) RemoveImage(ctx context.Context, id string, force bool, u
}
}
+ if s.imageUpdateService != nil {
+ if err := s.imageUpdateService.CleanupOrphanedRecords(ctx); err != nil {
+ slog.WarnContext(ctx, "failed to cleanup orphaned image update records after image remove", "id", id, "error", err)
+ }
+ }
+
// Clean up vulnerability scan records for the deleted image
if s.vulnerabilityService != nil {
if err := s.vulnerabilityService.DeleteScanResult(ctx, id); err != nil {
@@ -414,34 +420,10 @@ func (s *ImageService) PruneImages(ctx context.Context, dangling bool) (*image.P
return nil, fmt.Errorf("failed to prune images: %w", err)
}
- // Clean up database records for deleted images
- if s.db != nil && len(report.ImagesDeleted) > 0 {
- var idsToDelete []string
- for _, img := range report.ImagesDeleted {
- if img.Deleted != "" {
- idsToDelete = append(idsToDelete, img.Deleted)
- } else if img.Untagged != "" {
- idsToDelete = append(idsToDelete, img.Untagged)
- }
- }
-
- if len(idsToDelete) > 0 {
- if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- return tx.Where("id IN ?", idsToDelete).Delete(&models.ImageUpdateRecord{}).Error
- }); err != nil {
- slog.WarnContext(ctx, "failed to clean up image update records after prune", "error", err)
- }
-
- // Clean up vulnerability scan records for pruned images
- if s.vulnerabilityService != nil {
- for _, imgID := range idsToDelete {
- if err := s.vulnerabilityService.DeleteScanResult(ctx, imgID); err != nil {
- slog.WarnContext(ctx, "failed to delete vulnerability scan record after prune", "id", imgID, "error", err)
- }
- }
- }
- }
- }
+ idsToDelete := getPrunedImageIDsInternal(report)
+ s.cleanupImageUpdateRecordsAfterPruneInternal(ctx, idsToDelete)
+ s.cleanupVulnerabilityRecordsAfterPruneInternal(ctx, idsToDelete)
+ s.cleanupOrphanedImageUpdatesAfterPruneInternal(ctx)
metadata := models.JSON{
"action": "prune",
@@ -456,6 +438,58 @@ func (s *ImageService) PruneImages(ctx context.Context, dangling bool) (*image.P
return &report, nil
}
+func getPrunedImageIDsInternal(report image.PruneReport) []string {
+ if len(report.ImagesDeleted) == 0 {
+ return nil
+ }
+
+ idsToDelete := make([]string, 0, len(report.ImagesDeleted))
+ for _, img := range report.ImagesDeleted {
+ if img.Deleted != "" {
+ idsToDelete = append(idsToDelete, img.Deleted)
+ continue
+ }
+ if img.Untagged != "" {
+ idsToDelete = append(idsToDelete, img.Untagged)
+ }
+ }
+ return idsToDelete
+}
+
+func (s *ImageService) cleanupImageUpdateRecordsAfterPruneInternal(ctx context.Context, idsToDelete []string) {
+ if s.db == nil || len(idsToDelete) == 0 {
+ return
+ }
+
+ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+ return tx.Where("id IN ?", idsToDelete).Delete(&models.ImageUpdateRecord{}).Error
+ }); err != nil {
+ slog.WarnContext(ctx, "failed to clean up image update records after prune", "error", err)
+ }
+}
+
+func (s *ImageService) cleanupVulnerabilityRecordsAfterPruneInternal(ctx context.Context, idsToDelete []string) {
+ if s.vulnerabilityService == nil || len(idsToDelete) == 0 {
+ return
+ }
+
+ for _, imgID := range idsToDelete {
+ if err := s.vulnerabilityService.DeleteScanResult(ctx, imgID); err != nil {
+ slog.WarnContext(ctx, "failed to delete vulnerability scan record after prune", "id", imgID, "error", err)
+ }
+ }
+}
+
+func (s *ImageService) cleanupOrphanedImageUpdatesAfterPruneInternal(ctx context.Context) {
+ if s.imageUpdateService == nil {
+ return
+ }
+
+ if err := s.imageUpdateService.CleanupOrphanedRecords(ctx); err != nil {
+ slog.WarnContext(ctx, "failed to cleanup orphaned image update records after prune", "error", err)
+ }
+}
+
// GetUpdateInfoByImageIDs returns a map of image ID to UpdateInfo for the given image IDs.
// This is used by the container service to populate update info for containers.
func (s *ImageService) GetUpdateInfoByImageIDs(ctx context.Context, imageIDs []string) (map[string]*imagetypes.UpdateInfo, error) {
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 108340d5a..3b5e81435 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -1043,10 +1043,23 @@ func (s *ImageUpdateService) CheckAllImages(ctx context.Context, limit int, exte
return make(map[string]*imageupdate.Response), nil
}
- return s.CheckMultipleImages(ctx, imageRefs, externalCreds)
+ results, err := s.CheckMultipleImages(ctx, imageRefs, externalCreds)
+ if err != nil {
+ return nil, err
+ }
+
+ if err := s.CleanupOrphanedRecords(ctx); err != nil {
+ slog.WarnContext(ctx, "failed to cleanup orphaned image update records after check-all", "error", err.Error())
+ }
+
+ return results, nil
}
func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {
+ if s.db == nil {
+ return nil
+ }
+
dockerClient, err := s.dockerService.GetClient()
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
@@ -1089,40 +1102,67 @@ func (s *ImageUpdateService) CleanupOrphanedRecords(ctx context.Context) error {
}
func (s *ImageUpdateService) GetUpdateSummary(ctx context.Context) (*imageupdate.Summary, error) {
+ dockerClient, err := s.dockerService.GetClient()
+ if err != nil {
+ return nil, fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+
+ dockerImages, err := dockerClient.ImageList(ctx, image.ListOptions{})
+ if err != nil {
+ return nil, fmt.Errorf("failed to list Docker images: %w", err)
+ }
+
+ liveImageIDs := make([]string, 0, len(dockerImages))
+ for _, img := range dockerImages {
+ liveImageIDs = append(liveImageIDs, img.ID)
+ }
+
+ return s.getUpdateSummaryForImageIDsInternal(ctx, liveImageIDs)
+}
+
+func (s *ImageUpdateService) getUpdateSummaryForImageIDsInternal(ctx context.Context, imageIDs []string) (*imageupdate.Summary, error) {
+ summary := &imageupdate.Summary{
+ TotalImages: len(imageIDs),
+ }
+
+ if s.db == nil || len(imageIDs) == 0 {
+ return summary, nil
+ }
+
var (
- totalImages int64
imagesWithUpdates int64
digestUpdates int64
- tagUpdates int64
errorsCount int64
)
g, groupCtx := errgroup.WithContext(ctx)
g.Go(func() error {
- return s.db.WithContext(groupCtx).Model(&models.ImageUpdateRecord{}).Count(&totalImages).Error
- })
- g.Go(func() error {
- return s.db.WithContext(groupCtx).Model(&models.ImageUpdateRecord{}).Where("has_update = ?", true).Count(&imagesWithUpdates).Error
+ return s.db.WithContext(groupCtx).
+ Model(&models.ImageUpdateRecord{}).
+ Where("id IN ? AND has_update = ?", imageIDs, true).
+ Count(&imagesWithUpdates).Error
})
g.Go(func() error {
- return s.db.WithContext(groupCtx).Model(&models.ImageUpdateRecord{}).Where("has_update = ? AND update_type = ?", true, "digest").Count(&digestUpdates).Error
+ return s.db.WithContext(groupCtx).
+ Model(&models.ImageUpdateRecord{}).
+ Where("id IN ? AND has_update = ? AND update_type = ?", imageIDs, true, "digest").
+ Count(&digestUpdates).Error
})
g.Go(func() error {
- return s.db.WithContext(groupCtx).Model(&models.ImageUpdateRecord{}).Where("has_update = ? AND update_type = ?", true, "tag").Count(&tagUpdates).Error
- })
- g.Go(func() error {
- return s.db.WithContext(groupCtx).Model(&models.ImageUpdateRecord{}).Where("last_error IS NOT NULL").Count(&errorsCount).Error
+ return s.db.WithContext(groupCtx).
+ Model(&models.ImageUpdateRecord{}).
+ Where("id IN ? AND last_error IS NOT NULL AND last_error != ''", imageIDs).
+ Count(&errorsCount).Error
})
if err := g.Wait(); err != nil {
return nil, err
}
- return &imageupdate.Summary{
- TotalImages: int(totalImages),
- ImagesWithUpdates: int(imagesWithUpdates),
- DigestUpdates: int(digestUpdates),
- ErrorsCount: int(errorsCount),
- }, nil
+ summary.ImagesWithUpdates = int(imagesWithUpdates)
+ summary.DigestUpdates = int(digestUpdates)
+ summary.ErrorsCount = int(errorsCount)
+
+ return summary, nil
}
diff --git a/backend/internal/services/image_update_service_test.go b/backend/internal/services/image_update_service_test.go
index 5523d3f74..ba44da361 100644
--- a/backend/internal/services/image_update_service_test.go
+++ b/backend/internal/services/image_update_service_test.go
@@ -2,6 +2,7 @@ package services
import (
"context"
+ "fmt"
"testing"
"time"
@@ -344,7 +345,8 @@ func TestStringToPtr(t *testing.T) {
// setupImageUpdateTestDB creates an in-memory SQLite database for testing
func setupImageUpdateTestDB(t *testing.T) *database.DB {
t.Helper()
- db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})
+ dsn := fmt.Sprintf("file:image-update-test-%d?mode=memory&cache=shared", time.Now().UnixNano())
+ db, err := gorm.Open(glsqlite.Open(dsn), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(&models.ImageUpdateRecord{}))
return &database.DB{DB: db}
@@ -656,3 +658,68 @@ func TestImageUpdateService_MarkUpdatesAsNotified_EmptyList(t *testing.T) {
err = svc.MarkUpdatesAsNotified(ctx, nil)
require.NoError(t, err)
}
+
+func TestImageUpdateService_GetUpdateSummaryForImageIDs_FiltersToLiveImages(t *testing.T) {
+ ctx := context.Background()
+ db := setupImageUpdateTestDB(t)
+ svc := &ImageUpdateService{db: db}
+ now := time.Now()
+
+ records := []models.ImageUpdateRecord{
+ {
+ ID: "sha256:live-1",
+ Repository: "docker.io/library/nginx",
+ Tag: "latest",
+ HasUpdate: true,
+ UpdateType: "digest",
+ CurrentVersion: "latest",
+ CheckTime: now,
+ },
+ {
+ ID: "sha256:live-2",
+ Repository: "docker.io/library/redis",
+ Tag: "latest",
+ HasUpdate: false,
+ UpdateType: "digest",
+ CurrentVersion: "latest",
+ LastError: stringToPtr("rate limited"),
+ CheckTime: now,
+ },
+ {
+ ID: "sha256:stale-1",
+ Repository: "docker.io/library/postgres",
+ Tag: "latest",
+ HasUpdate: true,
+ UpdateType: "digest",
+ CurrentVersion: "latest",
+ LastError: stringToPtr("stale failure"),
+ CheckTime: now,
+ },
+ }
+ for i := range records {
+ err := db.Create(&records[i]).Error
+ require.NoError(t, err)
+ }
+
+ summary, err := svc.getUpdateSummaryForImageIDsInternal(ctx, []string{"sha256:live-1", "sha256:live-2"})
+ require.NoError(t, err)
+
+ assert.Equal(t, 2, summary.TotalImages)
+ assert.Equal(t, 1, summary.ImagesWithUpdates)
+ assert.Equal(t, 1, summary.DigestUpdates)
+ assert.Equal(t, 1, summary.ErrorsCount)
+}
+
+func TestImageUpdateService_GetUpdateSummaryForImageIDs_EmptyLiveSet(t *testing.T) {
+ ctx := context.Background()
+ db := setupImageUpdateTestDB(t)
+ svc := &ImageUpdateService{db: db}
+
+ summary, err := svc.getUpdateSummaryForImageIDsInternal(ctx, nil)
+ require.NoError(t, err)
+
+ assert.Equal(t, 0, summary.TotalImages)
+ assert.Equal(t, 0, summary.ImagesWithUpdates)
+ assert.Equal(t, 0, summary.DigestUpdates)
+ assert.Equal(t, 0, summary.ErrorsCount)
+}
diff --git a/tests/spec/image-updates.spec.ts b/tests/spec/image-updates.spec.ts
index 76bc7372b..b46cd8de4 100644
--- a/tests/spec/image-updates.spec.ts
+++ b/tests/spec/image-updates.spec.ts
@@ -45,6 +45,20 @@ async function navigateToImages(page: Page) {
await page.waitForLoadState("networkidle");
}
+async function fetchImagesTotal(page: Page, updatesFilter?: string): Promise<number> {
+ const params = new URLSearchParams({ start: "0", limit: "1" });
+ if (updatesFilter) {
+ params.set("updates", updatesFilter);
+ }
+
+ const res = await page.request.get(`/api/environments/0/images?${params.toString()}`);
+ expect(res.status()).toBe(200);
+
+ const body = await res.json().catch(() => null as any);
+ const totalItems = Number(body?.pagination?.totalItems ?? 0);
+ return Number.isFinite(totalItems) ? totalItems : 0;
+}
+
let realImages: any[] = [];
test.beforeEach(async ({ page }) => {
@@ -251,6 +265,14 @@ test.describe("Image Update API Endpoints", () => {
expect(typeof json.data.imagesWithUpdates).toBe("number");
expect(typeof json.data.digestUpdates).toBe("number");
expect(typeof json.data.errorsCount).toBe("number");
+
+ const [imagesTotal, hasUpdateTotal] = await Promise.all([
+ fetchImagesTotal(page),
+ fetchImagesTotal(page, "has_update"),
+ ]);
+
+ expect(json.data.totalImages).toBe(imagesTotal);
+ expect(json.data.imagesWithUpdates).toBe(hasUpdateTotal);
});
});
diff --git a/tests/spec/images.spec.ts b/tests/spec/images.spec.ts
index b7d9e30c5..28a963679 100644
--- a/tests/spec/images.spec.ts
+++ b/tests/spec/images.spec.ts
@@ -12,6 +12,32 @@ async function navigateToImages(page: Page) {
await page.waitForLoadState('networkidle');
}
+async function fetchAllImagesForUsage(page: Page): Promise<any[]> {
+ const limit = 200;
+ let start = 0;
+ const all: any[] = [];
+
+ while (true) {
+ const res = await page.request.get(`${ROUTES.apiImages}?start=${start}&limit=${limit}`);
+ if (!res.ok()) {
+ throw new Error(`HTTP ${res.status()}`);
+ }
+
+ const body = await res.json().catch(() => null as any);
+ const data = Array.isArray(body?.data) ? body.data : [];
+ all.push(...data);
+
+ const totalItems = Number(body?.pagination?.totalItems ?? all.length);
+ if (data.length === 0 || all.length >= totalItems) {
+ break;
+ }
+
+ start += limit;
+ }
+
+ return all;
+}
+
let realImages: any[] = [];
let imageCounts: ImageUsageCounts = { imagesInuse: 0, imagesUnused: 0, totalImages: 0, totalImageSize: 0 };
@@ -42,6 +68,18 @@ test.describe('Images Page', () => {
await expect(page.getByText(/Total Size/i)).toBeVisible();
});
+ test('should align /images/counts with usage derived from /images list', async ({ page }) => {
+ await navigateToImages(page);
+
+ const allImages = await fetchAllImagesForUsage(page);
+ const derivedInUse = allImages.filter((img) => !!img.inUse).length;
+ const derivedUnused = allImages.length - derivedInUse;
+
+ expect(imageCounts.totalImages).toBe(allImages.length);
+ expect(imageCounts.imagesInuse).toBe(derivedInUse);
+ expect(imageCounts.imagesUnused).toBe(derivedUnused);
+ });
+
test('should display the image table when images exist', async ({ page }) => {
await navigateToImages(page);
diff --git a/types/imageupdate/image_update.go b/types/imageupdate/image_update.go
index 7c7bcfabf..94ca0808b 100644
--- a/types/imageupdate/image_update.go
+++ b/types/imageupdate/image_update.go
@@ -74,7 +74,7 @@ type Response struct {
}
type Summary struct {
- // TotalImages is the total number of images checked.
+ // TotalImages is the total number of current Docker images considered.
//
// Required: true
TotalImages int `json:"totalImages"`