deb-bootc-image-builder/bib/internal/debos/builder.go

package debos

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/osbuild/images/pkg/arch"
	"github.com/osbuild/images/pkg/bib/osinfo"
)

// DebosBuilder handles building images using debos instead of osbuild
type DebosBuilder struct {
	runner    *DebosRunner
	workDir   string
	outputDir string
}

// BuildOptions contains options for building images
type BuildOptions struct {
	Architecture    arch.Arch
	Suite           string
	ContainerImage  string
	ImageTypes      []string
	OutputDir       string
	WorkDir         string
	CustomPackages  []string
	CustomActions   []DebosAction
}

// BuildResult contains the result of a build operation
type BuildResult struct {
	Success    bool
	OutputPath string
	Error      error
	Logs       string
}

// NewDebosBuilder creates a new debos builder
func NewDebosBuilder(workDir, outputDir string) (*DebosBuilder, error) {
	runner, err := NewDebosRunner(workDir)
	if err != nil {
		return nil, fmt.Errorf("failed to create debos runner: %w", err)
	}

	// Create output directory if it doesn't exist
	if err := os.MkdirAll(outputDir, 0755); err != nil {
		return nil, fmt.Errorf("failed to create output directory: %w", err)
	}

	return &DebosBuilder{
		runner:    runner,
		workDir:   workDir,
		outputDir: outputDir,
	}, nil
}

// Build builds an image using debos
func (b *DebosBuilder) Build(options *BuildOptions) (*BuildResult, error) {
	// Determine suite from container image if not specified
	suite := options.Suite
	if suite == "" {
		suite = b.detectSuiteFromImage(options.ContainerImage)
	}

	// Create template based on image types
	var template *DebosTemplate
	switch {
	case contains(options.ImageTypes, "qcow2"):
		template = b.createQcow2Template(options, suite)
	case contains(options.ImageTypes, "raw"):
		template = b.createRawTemplate(options, suite)
	case contains(options.ImageTypes, "ami"):
		template = b.createAMITemplate(options, suite)
	default:
		// Default to qcow2
		template = b.createQcow2Template(options, suite)
	}

	// Add custom actions if specified
	if len(options.CustomActions) > 0 {
		template.Actions = append(template.Actions, options.CustomActions...)
	}

	// Execute debos
	result, err := b.runner.Execute(template, b.outputDir)
	if err != nil {
		return &BuildResult{
			Success: false,
			Error:   err,
			Logs:    result.ErrorOutput,
		}, err
	}

	// Find the output file
	outputPath := b.findOutputFile(options.ImageTypes)

	return &BuildResult{
		Success:    result.Success,
		OutputPath: outputPath,
		Logs:       result.StdOutput,
	}, nil
}

// createQcow2Template creates a template for qcow2 images
func (b *DebosBuilder) createQcow2Template(options *BuildOptions, suite string) *DebosTemplate {
	// Start with basic bootc template
	template := CreateBootcTemplate(options.Architecture.String(), suite, options.ContainerImage)

	// Add custom packages if specified
	if len(options.CustomPackages) > 0 {
		customAction := DebosAction{
			Action:      "run",
			Description: "Install custom packages",
			Script:      b.generatePackageInstallScript(options.CustomPackages),
		}
		template.Actions = append(template.Actions, customAction)
	}

	// Configure output for qcow2
	template.Output = DebosOutput{
		Format:      "qcow2",
		Compression: true,
	}

	return template
}

// createRawTemplate creates a template for raw images
func (b *DebosBuilder) createRawTemplate(options *BuildOptions, suite string) *DebosTemplate {
	template := b.createQcow2Template(options, suite)
	template.Output.Format = "raw"
	return template
}

// createAMITemplate creates a template for AMI images
func (b *DebosBuilder) createAMITemplate(options *BuildOptions, suite string) *DebosTemplate {
	template := b.createQcow2Template(options, suite)
	template.Output.Format = "raw" // AMI uses raw format
	
	// Add cloud-init configuration
	cloudInitAction := DebosAction{
		Action:      "run",
		Description: "Configure cloud-init",
		Script: `#!/bin/bash
set -e
apt-get install -y cloud-init
mkdir -p /etc/cloud/cloud.cfg.d
cat > /etc/cloud/cloud.cfg.d/99_debian.cfg << 'EOF'
datasource_list: [ NoCloud, ConfigDrive, OpenNebula, Azure, AltCloud, OVF, vApp, MAAS, GCE, OpenStack, CloudStack, HetznerCloud, Oracle, IBMCloud, Exoscale, Scaleway, Vultr, LXD, LXDCluster, CloudSigma, HyperV, VMware, SmartOS, Bigstep, OpenTelekomCloud, UpCloud, PowerVS, Brightbox, OpenGpu, OpenNebula, CloudSigma, HetznerCloud, Oracle, IBMCloud, Exoscale, Scaleway, Vultr, LXD, LXDCluster, CloudSigma, HyperV, VMware, SmartOS, Bigstep, OpenTelekomCloud, UpCloud, PowerVS, Brightbox, OpenGpu ]
EOF`,
	}
	template.Actions = append(template.Actions, cloudInitAction)

	return template
}

// detectSuiteFromImage attempts to detect the Debian suite from the container image
func (b *DebosBuilder) detectSuiteFromImage(imageName string) string {
	// Simple detection based on image name
	if strings.Contains(imageName, "bookworm") {
		return "bookworm"
	}
	if strings.Contains(imageName, "trixie") {
		return "trixie"
	}
	if strings.Contains(imageName, "sid") {
		return "sid"
	}
	
	// Default to trixie (current testing)
	return "trixie"
}

// generatePackageInstallScript generates a script for installing custom packages
func (b *DebosBuilder) generatePackageInstallScript(packages []string) string {
	packageList := strings.Join(packages, " ")
	return fmt.Sprintf(`#!/bin/bash
set -e
apt-get update
apt-get install -y %s`, packageList)
}

// findOutputFile finds the output file based on image types
func (b *DebosBuilder) findOutputFile(imageTypes []string) string {
	for _, imgType := range imageTypes {
		switch imgType {
		case "qcow2":
			if files, err := filepath.Glob(filepath.Join(b.outputDir, "*.qcow2")); err == nil && len(files) > 0 {
				return files[0]
			}
		case "raw":
			if files, err := filepath.Glob(filepath.Join(b.outputDir, "*.raw")); err == nil && len(files) > 0 {
				return files[0]
			}
		case "ami":
			if files, err := filepath.Glob(filepath.Join(b.outputDir, "*.raw")); err == nil && len(files) > 0 {
				return files[0]
			}
		}
	}
	return ""
}

// contains checks if a slice contains a string
func contains(slice []string, item string) bool {
	for _, s := range slice {
		if s == item {
			return true
		}
	}
	return false
}

// BuildFromOSInfo builds an image using OS information from a container
func (b *DebosBuilder) BuildFromOSInfo(options *BuildOptions, osInfo *osinfo.Info) (*BuildResult, error) {
	// Override suite with detected OS info if available
	if osInfo.OSRelease.ID == "debian" && osInfo.OSRelease.VersionID != "" {
		options.Suite = osInfo.OSRelease.VersionID
	}

	return b.Build(options)
}