banger/internal/daemon/images.go

package daemon

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"

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

func (d *Daemon) BuildImage(ctx context.Context, params api.ImageBuildParams) (model.Image, error) {
	d.mu.Lock()
	defer d.mu.Unlock()

	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
	}
	rootfsPath := filepath.Join(artifactDir, "rootfs.ext4")
	script := d.config.CustomizeScript
	if script == "" {
		return model.Image{}, fmt.Errorf("customize script not configured; %s", paths.RuntimeBundleHint())
	}
	if _, err := os.Stat(script); err != nil {
		return model.Image{}, fmt.Errorf("customize.sh not found at %s; %s", script, paths.RuntimeBundleHint())
	}
	args := []string{script, baseRootfs, "--out", rootfsPath}
	if params.Size != "" {
		args = append(args, "--size", params.Size)
	}
	kernelPath := params.KernelPath
	if kernelPath == "" {
		kernelPath = d.config.DefaultKernel
	}
	if kernelPath != "" {
		args = append(args, "--kernel", kernelPath)
	}
	initrdPath := params.InitrdPath
	if initrdPath == "" {
		initrdPath = d.config.DefaultInitrd
	}
	if initrdPath != "" {
		args = append(args, "--initrd", initrdPath)
	}
	modulesDir := params.ModulesDir
	if modulesDir == "" {
		modulesDir = d.config.DefaultModulesDir
	}
	if modulesDir != "" {
		args = append(args, "--modules", modulesDir)
	}
	if params.Docker {
		args = append(args, "--docker")
	}
	if err := d.validateImageBuildPrereqs(ctx, baseRootfs, kernelPath, initrdPath, modulesDir); err != nil {
		return model.Image{}, err
	}
	cmd := exec.CommandContext(ctx, "bash", args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.Stdin = os.Stdin
	cmd.Dir = d.layout.StateDir
	cmd.Env = append(
		os.Environ(),
		"BANGER_RUNTIME_DIR="+d.config.RuntimeDir,
		"BANGER_STATE_DIR="+filepath.Join(d.layout.StateDir, "image-build"),
	)
	if d.config.MapDNSBin != "" {
		cmd.Env = append(cmd.Env, "BANGER_MAPDNS_BIN="+d.config.MapDNSBin)
	}
	if d.config.MapDNSDataFile != "" {
		cmd.Env = append(cmd.Env, "BANGER_MAPDNS_DATA_FILE="+d.config.MapDNSDataFile)
	}
	if err := cmd.Run(); err != nil {
		_ = os.RemoveAll(artifactDir)
		return model.Image{}, err
	}
	image := model.Image{
		ID:           id,
		Name:         name,
		Managed:      true,
		ArtifactDir:  artifactDir,
		RootfsPath:   rootfsPath,
		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
	}
	return image, nil
}

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
}