Thales Maciel
2362d0ae39
Add a localhost-only web console so VM and image management no longer depends on the CLI for every inspection and lifecycle action. Wire bangerd up to a configurable web listener, expose dashboard and async image-build state through the daemon, and serve CSRF-protected HTML pages with host-path picking, VM/image detail views, logs, ports, and progress polling for long-running operations. Keep the browser path aligned with the existing sudo and host-owned artifact model: surface sudo readiness, print the web URL in daemon status, and document the new workflow. Polish the UI with resource usage cards, clearer clickable affordances, cancel paths, confirmation prompts, image-name links, and HTTP port links. Validation: GOCACHE=/tmp/banger-gocache go test ./...
408 lines
13 KiB
Go
408 lines
13 KiB
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
|
|
imageBuildStage(ctx, "resolve_image", "resolving image build inputs")
|
|
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")
|
|
imageBuildSetLogPath(ctx, buildLogPath)
|
|
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)
|
|
imageBuildStage(ctx, "launch_builder", "building rootfs from base image")
|
|
if err := d.runImageBuild(ctx, spec); err != nil {
|
|
_ = logFile.Sync()
|
|
_ = os.RemoveAll(artifactDir)
|
|
return model.Image{}, err
|
|
}
|
|
imageBuildStage(ctx, "prepare_work_seed", "building reusable work seed")
|
|
if err := system.BuildWorkSeedImage(ctx, d.runner, rootfsPath, workSeedPath); err != nil {
|
|
_ = logFile.Sync()
|
|
_ = os.RemoveAll(artifactDir)
|
|
return model.Image{}, err
|
|
}
|
|
imageBuildStage(ctx, "seed_ssh", "seeding runtime SSH access")
|
|
seededSSHPublicKeyFingerprint, err := d.seedAuthorizedKeyOnExt4Image(ctx, workSeedPath)
|
|
if err != nil {
|
|
_ = logFile.Sync()
|
|
_ = os.RemoveAll(artifactDir)
|
|
return model.Image{}, err
|
|
}
|
|
imageBuildStage(ctx, "write_metadata", "writing image metadata")
|
|
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,
|
|
SeededSSHPublicKeyFingerprint: seededSSHPublicKeyFingerprint,
|
|
Docker: params.Docker,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
imageBuildBindImage(ctx, image)
|
|
if err := d.store.UpsertImage(ctx, image); err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
op.stage("persisted", "build_log_path", buildLogPath)
|
|
imageBuildStage(ctx, "persisted", "image metadata saved")
|
|
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 (d *Daemon) PromoteImage(ctx context.Context, idOrName string) (image model.Image, err error) {
|
|
d.mu.Lock()
|
|
defer d.mu.Unlock()
|
|
|
|
op := d.beginOperation("image.promote")
|
|
defer func() {
|
|
if err != nil {
|
|
op.fail(err, imageLogAttrs(image)...)
|
|
return
|
|
}
|
|
op.done(imageLogAttrs(image)...)
|
|
}()
|
|
|
|
image, err = d.FindImage(ctx, idOrName)
|
|
if err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
if image.Managed {
|
|
return model.Image{}, fmt.Errorf("image %s is already managed", image.Name)
|
|
}
|
|
if err := validateImagePromotePaths(image.RootfsPath, image.KernelPath, image.InitrdPath, image.ModulesDir, image.PackagesPath); err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
if strings.TrimSpace(d.layout.ImagesDir) == "" {
|
|
return model.Image{}, errors.New("images dir is not configured")
|
|
}
|
|
if err := os.MkdirAll(d.layout.ImagesDir, 0o755); err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
|
|
artifactDir := filepath.Join(d.layout.ImagesDir, image.ID)
|
|
if _, statErr := os.Stat(artifactDir); statErr == nil {
|
|
return model.Image{}, fmt.Errorf("artifact dir already exists: %s", artifactDir)
|
|
} else if !os.IsNotExist(statErr) {
|
|
return model.Image{}, statErr
|
|
}
|
|
|
|
stageDir, err := os.MkdirTemp(d.layout.ImagesDir, image.ID+".promote-")
|
|
if err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
cleanupStage := true
|
|
defer func() {
|
|
if cleanupStage {
|
|
_ = os.RemoveAll(stageDir)
|
|
}
|
|
}()
|
|
|
|
rootfsPath := filepath.Join(stageDir, "rootfs.ext4")
|
|
op.stage("copy_rootfs", "source_rootfs_path", image.RootfsPath, "target_rootfs_path", rootfsPath)
|
|
if err := system.CopyFilePreferClone(image.RootfsPath, rootfsPath); err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
|
|
workSeedPath := ""
|
|
if image.WorkSeedPath != "" {
|
|
if _, statErr := os.Stat(image.WorkSeedPath); statErr != nil {
|
|
if os.IsNotExist(statErr) {
|
|
op.stage("skip_missing_work_seed", "source_work_seed_path", image.WorkSeedPath)
|
|
image.WorkSeedPath = ""
|
|
} else {
|
|
return model.Image{}, statErr
|
|
}
|
|
}
|
|
}
|
|
if image.WorkSeedPath != "" {
|
|
workSeedPath = filepath.Join(stageDir, "work-seed.ext4")
|
|
op.stage("copy_work_seed", "source_work_seed_path", image.WorkSeedPath, "target_work_seed_path", workSeedPath)
|
|
if err := system.CopyFilePreferClone(image.WorkSeedPath, workSeedPath); err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
image.SeededSSHPublicKeyFingerprint, err = d.seedAuthorizedKeyOnExt4Image(ctx, workSeedPath)
|
|
if err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
} else {
|
|
image.SeededSSHPublicKeyFingerprint = ""
|
|
}
|
|
|
|
op.stage("activate_artifacts", "artifact_dir", artifactDir)
|
|
if err := os.Rename(stageDir, artifactDir); err != nil {
|
|
return model.Image{}, err
|
|
}
|
|
cleanupStage = false
|
|
|
|
image.Managed = true
|
|
image.ArtifactDir = artifactDir
|
|
image.RootfsPath = filepath.Join(artifactDir, "rootfs.ext4")
|
|
if workSeedPath != "" {
|
|
image.WorkSeedPath = filepath.Join(artifactDir, "work-seed.ext4")
|
|
}
|
|
image.UpdatedAt = model.Now()
|
|
if err := d.store.UpsertImage(ctx, image); err != nil {
|
|
_ = os.RemoveAll(artifactDir)
|
|
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 validateImagePromotePaths(rootfsPath, kernelPath, initrdPath, modulesDir, packagesPath string) error {
|
|
checks := system.NewPreflight()
|
|
checks.RequireFile(rootfsPath, "rootfs image", `re-register the image with a valid rootfs`)
|
|
checks.RequireFile(kernelPath, "kernel image", `re-register the image with a valid kernel`)
|
|
if initrdPath != "" {
|
|
checks.RequireFile(initrdPath, "initrd image", `re-register the image with a valid initrd`)
|
|
}
|
|
if modulesDir != "" {
|
|
checks.RequireDir(modulesDir, "kernel modules dir", `re-register the image with a valid modules dir`)
|
|
}
|
|
if packagesPath != "" {
|
|
checks.RequireFile(packagesPath, "packages manifest", `re-register the image with a valid packages manifest`)
|
|
}
|
|
return checks.Err("image promote 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
|
|
}
|