Files
kandev/apps/backend/internal/system/storage/dockerstore/provider.go
T

219 lines
6.8 KiB
Go

package dockerstore
import (
"context"
"errors"
"fmt"
"time"
agentdocker "github.com/kandev/kandev/internal/agent/docker"
"github.com/kandev/kandev/internal/system/storage"
)
var (
ErrDockerUnavailable = errors.New("docker client is unavailable")
ErrGlobalCleanupDisabled = errors.New("global Docker cleanup is disabled")
)
type DockerClient interface {
Ping(context.Context) error
ListContainers(context.Context, map[string]string) ([]agentdocker.ContainerInfo, error)
RemoveContainer(context.Context, string, bool) error
DiskUsage(context.Context) (agentdocker.DiskUsage, error)
PruneBuildCache(context.Context, agentdocker.BuildCachePruneOptions) (agentdocker.PruneResult, error)
PruneUnusedImages(context.Context, time.Time) (agentdocker.PruneResult, error)
}
type TaskInventory interface {
ContainerTaskRemovable(context.Context, string) (bool, error)
}
type SettingsReader interface {
GetSettings(context.Context) (storage.StorageMaintenanceSettings, error)
}
type Result struct {
Available bool `json:"available"`
Removed int `json:"removed"`
Kept int `json:"kept"`
Warnings []string `json:"warnings"`
}
type Analysis struct {
Available bool `json:"available"`
ManagedContainerCount int `json:"managed_container_count"`
ManagedContainerBytes int64 `json:"managed_container_bytes"`
ImageLayerBytes int64 `json:"image_layer_bytes"`
BuildCacheBytes int64 `json:"build_cache_bytes"`
UnusedImageBytes int64 `json:"unused_image_bytes"`
Warnings []string `json:"warnings"`
}
type Provider struct {
docker DockerClient
inventory TaskInventory
settings SettingsReader
now func() time.Time
}
func NewProvider(docker DockerClient, inventory TaskInventory, settings SettingsReader) *Provider {
return &Provider{docker: docker, inventory: inventory, settings: settings, now: time.Now}
}
func (p *Provider) CleanupContainers(ctx context.Context) Result {
if warning := p.availabilityWarning(ctx); warning != "" {
return Result{Warnings: []string{warning}}
}
containers, err := p.docker.ListContainers(ctx, map[string]string{"kandev.managed": "true"})
if err != nil {
return Result{Warnings: []string{fmt.Sprintf("list Docker containers: %v", err)}}
}
result := Result{Available: true}
for _, candidate := range containers {
p.cleanupContainer(ctx, candidate, &result)
}
return result
}
func (p *Provider) Analyze(ctx context.Context) Analysis {
if warning := p.availabilityWarning(ctx); warning != "" {
return Analysis{Warnings: []string{warning}}
}
usage, err := p.docker.DiskUsage(ctx)
if err != nil {
return Analysis{Warnings: []string{fmt.Sprintf("read Docker disk usage: %v", err)}}
}
settings, err := p.settings.GetSettings(ctx)
if err != nil {
return Analysis{Warnings: []string{fmt.Sprintf("read storage settings: %v", err)}}
}
settings, err = storage.NormalizeSettings(settings)
if err != nil {
return Analysis{Warnings: []string{fmt.Sprintf("validate storage settings: %v", err)}}
}
cutoff := p.now().Add(-time.Duration(settings.Docker.UnusedImagesHours) * time.Hour)
managedCount, managedBytes := managedContainerUsage(usage.Containers)
return Analysis{
Available: true,
ManagedContainerCount: managedCount,
ManagedContainerBytes: managedBytes,
ImageLayerBytes: usage.ImageLayerBytes,
BuildCacheBytes: usage.BuildCacheBytes,
UnusedImageBytes: unusedImageBytes(usage.Images, cutoff),
}
}
func (p *Provider) PruneBuildCache(ctx context.Context) (agentdocker.PruneResult, error) {
if p.docker == nil {
return agentdocker.PruneResult{}, ErrDockerUnavailable
}
settings, err := p.settings.GetSettings(ctx)
if err != nil {
return agentdocker.PruneResult{}, fmt.Errorf("read storage settings: %w", err)
}
settings, err = storage.NormalizeSettings(settings)
if err != nil {
return agentdocker.PruneResult{}, fmt.Errorf("validate storage settings: %w", err)
}
if !settings.Docker.DedicatedDaemonAcknowledged || !settings.Docker.BuildCacheEnabled {
return agentdocker.PruneResult{}, ErrGlobalCleanupDisabled
}
return p.docker.PruneBuildCache(ctx, agentdocker.BuildCachePruneOptions{
KeepBytes: settings.Docker.BuildCacheKeepBytes,
UnusedBefore: p.now().Add(
-time.Duration(settings.Docker.BuildCacheUnusedHours) * time.Hour,
),
})
}
func (p *Provider) PruneUnusedImages(ctx context.Context) (agentdocker.PruneResult, error) {
if p.docker == nil {
return agentdocker.PruneResult{}, ErrDockerUnavailable
}
settings, err := p.settings.GetSettings(ctx)
if err != nil {
return agentdocker.PruneResult{}, fmt.Errorf("read storage settings: %w", err)
}
settings, err = storage.NormalizeSettings(settings)
if err != nil {
return agentdocker.PruneResult{}, fmt.Errorf("validate storage settings: %w", err)
}
if !settings.Docker.DedicatedDaemonAcknowledged || !settings.Docker.UnusedImagesEnabled {
return agentdocker.PruneResult{}, ErrGlobalCleanupDisabled
}
cutoff := p.now().Add(-time.Duration(settings.Docker.UnusedImagesHours) * time.Hour)
return p.docker.PruneUnusedImages(ctx, cutoff)
}
func (p *Provider) availabilityWarning(ctx context.Context) string {
if p.docker == nil {
return "Docker unavailable: client not configured"
}
if err := p.docker.Ping(ctx); err != nil {
return fmt.Sprintf("Docker unavailable: %v", err)
}
return ""
}
func (p *Provider) cleanupContainer(ctx context.Context, candidate agentdocker.ContainerInfo, result *Result) {
if candidate.Labels["kandev.managed"] != "true" || !stoppedContainer(candidate.State) {
result.Kept++
return
}
taskID := candidate.Labels["kandev.task_id"]
if taskID == "" {
result.Kept++
return
}
removable, err := p.inventory.ContainerTaskRemovable(ctx, taskID)
if err != nil {
result.Kept++
result.Warnings = append(result.Warnings, fmt.Sprintf("classify container %s: %v", candidate.ID, err))
return
}
if !removable {
result.Kept++
return
}
if err := p.docker.RemoveContainer(ctx, candidate.ID, false); err != nil {
result.Kept++
result.Warnings = append(result.Warnings, fmt.Sprintf("remove container %s: %v", candidate.ID, err))
return
}
result.Removed++
}
func stoppedContainer(state string) bool {
switch state {
case "created", "exited", "dead":
return true
default:
return false
}
}
func unusedImageBytes(images []agentdocker.ImageUsage, cutoff time.Time) int64 {
var total int64
for _, image := range images {
if image.Containers == 0 && image.CreatedAt.Before(cutoff) && image.SizeBytes > 0 {
total += image.SizeBytes
}
}
return total
}
func managedContainerUsage(containers []agentdocker.ContainerUsage) (int, int64) {
var count int
var bytes int64
for _, item := range containers {
if item.Labels["kandev.managed"] != "true" {
continue
}
count++
if item.WritableBytes > 0 {
bytes += item.WritableBytes
}
}
return count, bytes
}