banger/internal/daemon/images.go

package daemon

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"banger/internal/api"
	"banger/internal/model"
	"banger/internal/paths"
	"banger/internal/system"
)

func (d *Daemon) BuildImage(ctx context.Context, params api.ImageBuildParams) (image model.Image, err error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	op := d.beginOperation("image.build")
	buildLogPath := ""
	defer func() {
		if err != nil {
			err = annotateLogPath(err, buildLogPath)
			op.fail(err, imageLogAttrs(image)...)
			return
		}
		op.done(imageLogAttrs(image)...)
	}()

	name := params.Name
	if name == "" {
		name = fmt.Sprintf("image-%d", model.Now().Unix())
	}
	if _, err := d.FindImage(ctx, name); err == nil {
		return model.Image{}, fmt.Errorf("image name already exists: %s", name)
	}
	baseRootfs := params.BaseRootfs
	if baseRootfs == "" {
		baseRootfs = d.config.DefaultBaseRootfs
	}
	if baseRootfs == "" {
		return model.Image{}, fmt.Errorf("base rootfs is required; %s", paths.RuntimeBundleHint())
	}
	id, err := model.NewID()
	if err != nil {
		return model.Image{}, err
	}
	now := model.Now()
	artifactDir := filepath.Join(d.layout.ImagesDir, id)
	if err := os.MkdirAll(artifactDir, 0o755); err != nil {
		return model.Image{}, err
	}
	buildLogDir := filepath.Join(d.layout.StateDir, "image-build")
	if err := os.MkdirAll(buildLogDir, 0o755); err != nil {
		return model.Image{}, err
	}
	buildLogPath = filepath.Join(buildLogDir, id+".log")
	logFile, err := os.OpenFile(buildLogPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
	if err != nil {
		return model.Image{}, err
	}
	defer logFile.Close()
	rootfsPath := filepath.Join(artifactDir, "rootfs.ext4")
	workSeedPath := filepath.Join(artifactDir, "work-seed.ext4")
	kernelPath := params.KernelPath
	if kernelPath == "" {
		kernelPath = d.config.DefaultKernel
	}
	initrdPath := params.InitrdPath
	if initrdPath == "" {
		initrdPath = d.config.DefaultInitrd
	}
	modulesDir := params.ModulesDir
	if modulesDir == "" {
		modulesDir = d.config.DefaultModulesDir
	}
	if err := d.validateImageBuildPrereqs(ctx, baseRootfs, kernelPath, initrdPath, modulesDir, params.Size); err != nil {
		return model.Image{}, err
	}
	spec := imageBuildSpec{
		ID:            id,
		Name:          name,
		BaseRootfs:    baseRootfs,
		RootfsPath:    rootfsPath,
		BuildLog:      logFile,
		KernelPath:    kernelPath,
		InitrdPath:    initrdPath,
		ModulesDir:    modulesDir,
		PackagesPath:  d.config.DefaultPackagesFile,
		InstallDocker: params.Docker,
		Size:          params.Size,
	}
	op.stage("launch_builder", "build_log_path", buildLogPath, "artifact_dir", artifactDir)
	if err := d.runImageBuild(ctx, spec); err != nil {
		_ = logFile.Sync()
		_ = os.RemoveAll(artifactDir)
		return model.Image{}, err
	}
	if err := system.BuildWorkSeedImage(ctx, d.runner, rootfsPath, workSeedPath); err != nil {
		_ = logFile.Sync()
		_ = os.RemoveAll(artifactDir)
		return model.Image{}, err
	}
	if err := writePackagesMetadata(rootfsPath, d.config.DefaultPackagesFile); err != nil {
		_ = logFile.Sync()
		_ = os.RemoveAll(artifactDir)
		return model.Image{}, err
	}
	image = model.Image{
		ID:           id,
		Name:         name,
		Managed:      true,
		ArtifactDir:  artifactDir,
		RootfsPath:   rootfsPath,
		WorkSeedPath: workSeedPath,
		KernelPath:   kernelPath,
		InitrdPath:   initrdPath,
		ModulesDir:   modulesDir,
		PackagesPath: d.config.DefaultPackagesFile,
		BuildSize:    params.Size,
		Docker:       params.Docker,
		CreatedAt:    now,
		UpdatedAt:    now,
	}
	if err := d.store.UpsertImage(ctx, image); err != nil {
		return model.Image{}, err
	}
	op.stage("persisted", "build_log_path", buildLogPath)
	if d.logger != nil {
		d.logger.Info("image build log preserved", append(imageLogAttrs(image), "build_log_path", buildLogPath)...)
	}
	_ = logFile.Sync()
	return image, nil
}

func (d *Daemon) RegisterImage(ctx context.Context, params api.ImageRegisterParams) (image model.Image, err error) {
	d.mu.Lock()
	defer d.mu.Unlock()

	name := strings.TrimSpace(params.Name)
	if name == "" {
		return model.Image{}, fmt.Errorf("image name is required")
	}

	rootfsPath := strings.TrimSpace(params.RootfsPath)
	if rootfsPath == "" {
		return model.Image{}, fmt.Errorf("rootfs path is required")
	}
	workSeedPath := strings.TrimSpace(params.WorkSeedPath)
	if workSeedPath == "" {
		candidate := system.WorkSeedPath(rootfsPath)
		if candidate != "" {
			if _, statErr := os.Stat(candidate); statErr == nil {
				workSeedPath = candidate
			}
		}
	}
	kernelPath := strings.TrimSpace(params.KernelPath)
	if kernelPath == "" {
		kernelPath = d.config.DefaultKernel
	}
	initrdPath := strings.TrimSpace(params.InitrdPath)
	if initrdPath == "" {
		initrdPath = d.config.DefaultInitrd
	}
	modulesDir := strings.TrimSpace(params.ModulesDir)
	if modulesDir == "" {
		modulesDir = d.config.DefaultModulesDir
	}
	packagesPath := strings.TrimSpace(params.PackagesPath)

	if err := validateImageRegisterPaths(rootfsPath, workSeedPath, kernelPath, initrdPath, modulesDir, packagesPath); err != nil {
		return model.Image{}, err
	}

	now := model.Now()
	existing, lookupErr := d.store.GetImageByName(ctx, name)
	switch {
	case lookupErr == nil:
		if existing.Managed {
			return model.Image{}, fmt.Errorf("managed image %s cannot be updated via register", name)
		}
		image = existing
		image.RootfsPath = rootfsPath
		image.WorkSeedPath = workSeedPath
		image.KernelPath = kernelPath
		image.InitrdPath = initrdPath
		image.ModulesDir = modulesDir
		image.PackagesPath = packagesPath
		image.Docker = params.Docker
		image.UpdatedAt = now
	case errors.Is(lookupErr, sql.ErrNoRows):
		id, idErr := model.NewID()
		if idErr != nil {
			return model.Image{}, idErr
		}
		image = model.Image{
			ID:           id,
			Name:         name,
			Managed:      false,
			RootfsPath:   rootfsPath,
			WorkSeedPath: workSeedPath,
			KernelPath:   kernelPath,
			InitrdPath:   initrdPath,
			ModulesDir:   modulesDir,
			PackagesPath: packagesPath,
			Docker:       params.Docker,
			CreatedAt:    now,
			UpdatedAt:    now,
		}
	default:
		return model.Image{}, lookupErr
	}

	if err := d.store.UpsertImage(ctx, image); err != nil {
		return model.Image{}, err
	}
	return image, nil
}

func validateImageRegisterPaths(rootfsPath, workSeedPath, kernelPath, initrdPath, modulesDir, packagesPath string) error {
	checks := system.NewPreflight()
	checks.RequireFile(rootfsPath, "rootfs image", `pass --rootfs <path>`)
	checks.RequireFile(kernelPath, "kernel image", `pass --kernel <path> or set "default_kernel"`)
	if workSeedPath != "" {
		checks.RequireFile(workSeedPath, "work-seed image", `pass --work-seed <path> or rebuild the image with a work seed`)
	}
	if initrdPath != "" {
		checks.RequireFile(initrdPath, "initrd image", `pass --initrd <path> or set "default_initrd"`)
	}
	if modulesDir != "" {
		checks.RequireDir(modulesDir, "kernel modules dir", `pass --modules <dir> or set "default_modules_dir"`)
	}
	if packagesPath != "" {
		checks.RequireFile(packagesPath, "packages manifest", `pass --packages <path>`)
	}
	return checks.Err("image register failed")
}

func writePackagesMetadata(rootfsPath, packagesPath string) error {
	if rootfsPath == "" || packagesPath == "" {
		return nil
	}
	lines, err := system.ReadNormalizedLines(packagesPath)
	if err != nil {
		return err
	}
	metadataPath := rootfsPath + ".packages.sha256"
	return os.WriteFile(metadataPath, []byte(packagesHash(lines)+"\n"), 0o644)
}

func (d *Daemon) DeleteImage(ctx context.Context, idOrName string) (model.Image, error) {
	d.mu.Lock()
	defer d.mu.Unlock()

	image, err := d.FindImage(ctx, idOrName)
	if err != nil {
		return model.Image{}, err
	}
	vms, err := d.store.FindVMsUsingImage(ctx, image.ID)
	if err != nil {
		return model.Image{}, err
	}
	if len(vms) > 0 {
		return model.Image{}, fmt.Errorf("image %s is still referenced by %d VM(s)", image.Name, len(vms))
	}
	if err := d.store.DeleteImage(ctx, image.ID); err != nil {
		return model.Image{}, err
	}
	if image.Managed && image.ArtifactDir != "" {
		if err := os.RemoveAll(image.ArtifactDir); err != nil {
			return model.Image{}, err
		}
	}
	return image, nil
}