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

package debos

import (
	"fmt"
	"strings"
)

// OSTreeConfig contains configuration for OSTree integration
type OSTreeConfig struct {
	Repository string
	Branch     string
	Subject    string
	Body       string
	Mode       string // "bare-user", "bare", "archive"
}

// OSTreeTemplate represents a debos template with OSTree integration
type OSTreeTemplate struct {
	*DebosTemplate
	OSTree OSTreeConfig
}

// CreateOSTreeTemplate creates a debos template specifically for OSTree-based bootc images
func CreateOSTreeTemplate(arch, suite string, containerImage string, ostreeConfig OSTreeConfig) *OSTreeTemplate {
	// Start with basic bootc template
	template := CreateBootcTemplate(arch, suite, containerImage)

	// Add OSTree-specific packages
	ostreePackages := []string{
		"ostree",
		"ostree-boot",
		"dracut",
		"grub-efi-" + getArchSuffix(arch),
		"efibootmgr",
		"linux-image-" + getArchSuffix(arch),
		"linux-headers-" + getArchSuffix(arch),
	}

	// Add OSTree packages action
	ostreePackagesAction := DebosAction{
		Action:      "run",
		Description: "Install OSTree packages",
		Script:      generateOSTreePackageInstallScript(ostreePackages),
	}
	template.Actions = append(template.Actions, ostreePackagesAction)

	// Add OSTree configuration action
	ostreeConfigAction := DebosAction{
		Action:      "run",
		Description: "Configure OSTree system",
		Script:      generateOSTreeConfigScript(ostreeConfig),
	}
	template.Actions = append(template.Actions, ostreeConfigAction)

	// Add bootloader configuration action
	bootloaderAction := DebosAction{
		Action:      "run",
		Description: "Configure bootloader for OSTree",
		Script:      generateBootloaderConfigScript(arch, suite),
	}
	template.Actions = append(template.Actions, bootloaderAction)

	// Add OSTree commit action
	ostreeCommitAction := DebosAction{
		Action: "ostree-commit",
		Options: map[string]interface{}{
			"repository": ostreeConfig.Repository,
			"branch":     ostreeConfig.Branch,
			"subject":    ostreeConfig.Subject,
			"body":       ostreeConfig.Body,
		},
	}
	template.Actions = append(template.Actions, ostreeCommitAction)

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

	return &OSTreeTemplate{
		DebosTemplate: template,
		OSTree:        ostreeConfig,
	}
}

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

// generateOSTreeConfigScript generates a script for configuring OSTree
func generateOSTreeConfigScript(config OSTreeConfig) string {
	return fmt.Sprintf(`#!/bin/bash
set -e

# Create basic user
useradd -m -s /bin/bash -G sudo debian
echo 'debian:debian' | chpasswd
echo "debian ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/debian

# Configure locale and timezone
echo "en_US.UTF-8 UTF-8" > /etc/locale.gen
locale-gen
echo "LANG=en_US.UTF-8" > /etc/default/locale
echo "America/Los_Angeles" > /etc/timezone
dpkg-reconfigure -f noninteractive tzdata

# Initialize OSTree repository
mkdir -p %s
ostree init --mode=%s --repo=%s

# Configure dracut for OSTree
echo 'add_drivers+=" overlay "' > /etc/dracut.conf.d/ostree.conf
echo 'add_drivers+=" squashfs "' >> /etc/dracut.conf.d/ostree.conf

# Enable systemd services
systemctl enable systemd-timesyncd
systemctl enable rsyslog`,
		config.Repository, config.Mode, config.Repository)
}

// generateBootloaderConfigScript generates a script for configuring the bootloader
func generateBootloaderConfigScript(arch, suite string) string {
	archSuffix := getArchSuffix(arch)
	return fmt.Sprintf(`#!/bin/bash
set -e

# Configure GRUB for OSTree
echo "GRUB_TIMEOUT=5" >> /etc/default/grub
echo "GRUB_DEFAULT=0" >> /etc/default/grub
echo "GRUB_DISABLE_SUBMENU=true" >> /etc/default/grub
echo "GRUB_TERMINAL_OUTPUT=console" >> /etc/default/grub
echo "GRUB_CMDLINE_LINUX_DEFAULT=\\"quiet ostree=/ostree/boot.1/debian/%s/%s\\"" >> /etc/default/grub
echo "GRUB_CMDLINE_LINUX=\\"\\"" >> /etc/default/grub

# Update GRUB
update-grub`,
		suite, archSuffix)
}

// getArchSuffix converts architecture to package suffix
func getArchSuffix(arch string) string {
	switch arch {
	case "amd64":
		return "amd64"
	case "arm64":
		return "arm64"
	case "armhf":
		return "armhf"
	case "i386":
		return "i386"
	default:
		return "amd64"
	}
}

// CreateBootcOSTreeTemplate creates a template specifically for bootc with OSTree
func CreateBootcOSTreeTemplate(arch, suite string, containerImage string) *OSTreeTemplate {
	// Default OSTree configuration
	ostreeConfig := OSTreeConfig{
		Repository: "/ostree/repo",
		Branch:     fmt.Sprintf("debian/%s/%s", suite, getArchSuffix(arch)),
		Subject:    fmt.Sprintf("Initial Debian %s OSTree commit", suite),
		Body:       fmt.Sprintf("Base system with essential packages and OSTree integration for %s", suite),
		Mode:       "bare-user",
	}

	return CreateOSTreeTemplate(arch, suite, containerImage, ostreeConfig)
}

// OSTreeBuilder extends DebosBuilder with OSTree-specific functionality
type OSTreeBuilder struct {
	*DebosBuilder
}

// NewOSTreeBuilder creates a new OSTree builder
func NewOSTreeBuilder(workDir, outputDir string) (*OSTreeBuilder, error) {
	builder, err := NewDebosBuilder(workDir, outputDir)
	if err != nil {
		return nil, err
	}

	return &OSTreeBuilder{
		DebosBuilder: builder,
	}, nil
}

// BuildOSTree builds an OSTree-based image
func (ob *OSTreeBuilder) BuildOSTree(options *BuildOptions, ostreeConfig OSTreeConfig) (*BuildResult, error) {
	// Create OSTree template
	template := CreateOSTreeTemplate(
		options.Architecture.String(),
		options.Suite,
		options.ContainerImage,
		ostreeConfig,
	)

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

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

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

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

// BuildBootcOSTree builds a bootc-compatible OSTree image
func (ob *OSTreeBuilder) BuildBootcOSTree(options *BuildOptions) (*BuildResult, error) {
	// Use default bootc OSTree configuration
	ostreeConfig := OSTreeConfig{
		Repository: "/ostree/repo",
		Branch:     fmt.Sprintf("debian/%s/%s", options.Suite, getArchSuffix(options.Architecture.String())),
		Subject:    fmt.Sprintf("Initial Debian %s OSTree commit", options.Suite),
		Body:       fmt.Sprintf("Base system with essential packages and OSTree integration for %s", options.Suite),
		Mode:       "bare-user",
	}

	return ob.BuildOSTree(options, ostreeConfig)
}