kandev/apps/backend/internal/agent/docker/storage.go

package docker

import (
	"context"
	"fmt"
	"math"
	"strconv"
	"time"

	"github.com/moby/moby/client"
)

type storageAPI interface {
	DiskUsage(context.Context, client.DiskUsageOptions) (client.DiskUsageResult, error)
	BuildCachePrune(context.Context, client.BuildCachePruneOptions) (client.BuildCachePruneResult, error)
	ImagePrune(context.Context, client.ImagePruneOptions) (client.ImagePruneResult, error)
}

type ImageUsage struct {
	ID         string    `json:"id"`
	SizeBytes  int64     `json:"size_bytes"`
	Containers int64     `json:"containers"`
	CreatedAt  time.Time `json:"created_at"`
}

type ContainerUsage struct {
	ID            string            `json:"id"`
	WritableBytes int64             `json:"writable_bytes"`
	Labels        map[string]string `json:"labels"`
}

type DiskUsage struct {
	ImageLayerBytes int64            `json:"image_layer_bytes"`
	BuildCacheBytes int64            `json:"build_cache_bytes"`
	Images          []ImageUsage     `json:"images"`
	Containers      []ContainerUsage `json:"containers"`
}

type BuildCachePruneOptions struct {
	KeepBytes    int64
	UnusedBefore time.Time
}

type PruneResult struct {
	Deleted        int   `json:"deleted"`
	BytesReclaimed int64 `json:"bytes_reclaimed"`
}

func (c *Client) DiskUsage(ctx context.Context) (DiskUsage, error) {
	// Verbose is required for the daemon to return per-image and per-container
	// records alongside the aggregate totals.
	usage, err := c.storageClient().DiskUsage(ctx, client.DiskUsageOptions{
		Containers: true,
		Images:     true,
		BuildCache: true,
		Verbose:    true,
	})
	if err != nil {
		return DiskUsage{}, fmt.Errorf("read Docker disk usage: %w", err)
	}
	result := DiskUsage{
		ImageLayerBytes: usage.Images.TotalSize,
		Images:          make([]ImageUsage, 0, len(usage.Images.Items)),
		Containers:      make([]ContainerUsage, 0, len(usage.Containers.Items)),
	}
	for _, cache := range usage.BuildCache.Items {
		if cache.Size > 0 {
			result.BuildCacheBytes += cache.Size
		}
	}
	for _, item := range usage.Images.Items {
		result.Images = append(result.Images, ImageUsage{
			ID: item.ID, SizeBytes: item.Size, Containers: item.Containers,
			CreatedAt: time.Unix(item.Created, 0).UTC(),
		})
	}
	for _, item := range usage.Containers.Items {
		result.Containers = append(result.Containers, ContainerUsage{
			ID: item.ID, WritableBytes: item.SizeRw, Labels: item.Labels,
		})
	}
	return result, nil
}

func (c *Client) PruneBuildCache(ctx context.Context, options BuildCachePruneOptions) (PruneResult, error) {
	// The client translates ReservedSpace into the legacy "keep-storage"
	// parameter when talking to daemons on API <= 1.47.
	result, err := c.storageClient().BuildCachePrune(ctx, client.BuildCachePruneOptions{
		All:           true,
		ReservedSpace: options.KeepBytes,
		Filters:       make(client.Filters).Add("until", unixFilter(options.UnusedBefore)),
	})
	if err != nil {
		return PruneResult{}, fmt.Errorf("prune Docker build cache: %w", err)
	}
	return PruneResult{
		Deleted:        len(result.Report.CachesDeleted),
		BytesReclaimed: reclaimedBytes(result.Report.SpaceReclaimed),
	}, nil
}

func (c *Client) PruneUnusedImages(ctx context.Context, unusedBefore time.Time) (PruneResult, error) {
	result, err := c.storageClient().ImagePrune(ctx, client.ImagePruneOptions{
		Filters: make(client.Filters).
			Add("dangling", "false").
			Add("until", unixFilter(unusedBefore)),
	})
	if err != nil {
		return PruneResult{}, fmt.Errorf("prune unused Docker images: %w", err)
	}
	return PruneResult{
		Deleted:        len(result.Report.ImagesDeleted),
		BytesReclaimed: reclaimedBytes(result.Report.SpaceReclaimed),
	}, nil
}

func (c *Client) storageClient() storageAPI {
	if c.storage != nil {
		return c.storage
	}
	return c.cli
}

func unixFilter(value time.Time) string {
	return strconv.FormatInt(value.UTC().Unix(), 10)
}

func reclaimedBytes(value uint64) int64 {
	if value > math.MaxInt64 {
		return math.MaxInt64
	}
	return int64(value)
}