deb-bootc-image-builder/bib/internal/debos_integration/manifest_generator.go

package debos_integration

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

	"gopkg.in/yaml.v3"
)

// DebosManifest represents a debos YAML manifest
type DebosManifest struct {
	Architecture string                 `yaml:"architecture"`
	Suite        string                 `yaml:"suite"`
	Actions      []DebosAction         `yaml:"actions"`
	Output       DebosOutput           `yaml:"output,omitempty"`
	Variables    map[string]interface{} `yaml:"variables,omitempty"`
}

// DebosAction represents a single debos action
type DebosAction struct {
	Action      string                 `yaml:"action"`
	Description string                 `yaml:"description,omitempty"`
	Script      string                 `yaml:"script,omitempty"`
	Options     map[string]interface{} `yaml:"options,omitempty"`
}

// DebosOutput represents the output configuration
type DebosOutput struct {
	Format      string `yaml:"format,omitempty"`
	Compression bool   `yaml:"compression,omitempty"`
}

// ManifestGenerator creates debos-compatible YAML manifests from container information
type ManifestGenerator struct {
	options *IntegrationOptions
}

// NewManifestGenerator creates a new manifest generator
func NewManifestGenerator(options *IntegrationOptions) *ManifestGenerator {
	return &ManifestGenerator{
		options: options,
	}
}

// GenerateManifest creates a debos manifest from container content
func (mg *ManifestGenerator) GenerateManifest(containerRoot string) (*DebosManifest, error) {
	// Detect Debian suite and architecture from container
	suite := mg.detectSuite(containerRoot)
	architecture := mg.detectArchitecture(containerRoot)
	
	// Create manifest with container-specific actions
	manifest := &DebosManifest{
		Architecture: architecture,
		Suite:        suite,
		Actions:      mg.generateActions(containerRoot),
		Output: DebosOutput{
			Format:      mg.determineOutputFormat(),
			Compression: true,
		},
		Variables: mg.generateVariables(),
	}

	return manifest, nil
}

// detectSuite detects the Debian suite from container content
func (mg *ManifestGenerator) detectSuite(containerRoot string) string {
	// Try to read os-release file
	osReleasePath := filepath.Join(containerRoot, "etc/os-release")
	if data, err := os.ReadFile(osReleasePath); err == nil {
		content := string(data)
		if strings.Contains(content, "VERSION_ID=\"12\"") {
			return "bookworm"
		} else if strings.Contains(content, "VERSION_ID=\"13\"") {
			return "trixie"
		} else if strings.Contains(content, "VERSION_ID=\"11\"") {
			return "bullseye"
		}
	}

	// Fallback to source info if available
	if mg.options.SourceInfo != nil && mg.options.SourceInfo.OSRelease.VersionID != "" {
		switch mg.options.SourceInfo.OSRelease.VersionID {
		case "12":
			return "bookworm"
		case "13":
			return "trixie"
		case "11":
			return "bullseye"
		}
	}

	// Default to trixie (Debian testing)
	return "trixie"
}

// detectArchitecture detects the architecture from container content
func (mg *ManifestGenerator) detectArchitecture(containerRoot string) string {
	// Try to read architecture from multiple sources
	archPaths := []string{
		"usr/lib/x86_64-linux-gnu",
		"usr/lib/aarch64-linux-gnu",
		"usr/lib/arm-linux-gnueabihf",
	}

	for _, path := range archPaths {
		fullPath := filepath.Join(containerRoot, path)
		if _, err := os.Stat(fullPath); err == nil {
			if strings.Contains(path, "x86_64") {
				return "x86_64"
			} else if strings.Contains(path, "aarch64") {
				return "aarch64"
			} else if strings.Contains(path, "arm-linux-gnueabihf") {
				return "armhf"
			}
		}
	}

	// Fallback to options architecture
	return mg.options.Architecture.String()
}

// generateActions creates the list of debos actions for the manifest
func (mg *ManifestGenerator) generateActions(containerRoot string) []DebosAction {
	actions := []DebosAction{}

	// Action 1: Extract container content
	actions = append(actions, DebosAction{
		Action:      "run",
		Description: "Extract and prepare container content",
		Script:      mg.generateContainerExtractionScript(containerRoot),
	})

	// Action 2: Set up basic system structure
	actions = append(actions, DebosAction{
		Action:      "run",
		Description: "Set up basic system structure",
		Script:      mg.generateSystemSetupScript(),
	})

	// Action 3: Install essential packages
	actions = append(actions, DebosAction{
		Action:      "run",
		Description: "Install essential system packages",
		Script:      mg.generatePackageInstallScript(),
	})

	// Action 4: Configure bootloader (GRUB or bootupd)
	bootloaderType := mg.determineBootloaderType()
	actions = append(actions, DebosAction{
		Action:      "run",
		Description: fmt.Sprintf("Configure %s bootloader", bootloaderType),
		Script:      mg.generateBootloaderScript(bootloaderType),
	})

	// Action 5: Set up OSTree structure
	actions = append(actions, DebosAction{
		Action:      "run",
		Description: "Set up OSTree structure",
		Script:      mg.generateOSTreeScript(),
	})

	// Action 6: Create image partitions
	actions = append(actions, DebosAction{
		Action: "image-partition",
		Options: map[string]interface{}{
			"imagename":     "debian-bootc",
			"imagesize":     "4G",
			"partitiontype": "gpt",
			"mountpoints": []map[string]interface{}{
				{
					"mountpoint": "/",
					"size":        "3G",
					"filesystem":  "ext4",
				},
				{
					"mountpoint": "/boot",
					"size":        "512M",
					"filesystem":  "vfat",
				},
				{
					"mountpoint": "/var",
					"size":        "512M",
					"filesystem":  "ext4",
				},
			},
		},
	})

	return actions
}

// generateContainerExtractionScript creates the script for extracting container content
func (mg *ManifestGenerator) generateContainerExtractionScript(containerRoot string) string {
	return `#!/bin/bash
set -e

echo "Setting up container content from extracted filesystem..."

# Container content has already been extracted and analyzed
# The filesystem is ready for bootable image creation

# Verify container content
if [ -f /etc/os-release ]; then
    echo "Container OS detected: $(grep PRETTY_NAME /etc/os-release | cut -d'"' -f2)"
fi

if [ -f /var/lib/dpkg/status ]; then
    echo "Package database found: $(grep -c "^Package:" /var/lib/dpkg/status) packages"
fi

echo "Container content prepared successfully"
`
}

// generateSystemSetupScript creates the script for basic system setup
func (mg *ManifestGenerator) generateSystemSetupScript() string {
	return `#!/bin/bash
set -e

echo "Setting up basic system structure..."

# Configure locale
echo "en_US.UTF-8 UTF-8" > /etc/locale.gen
locale-gen
echo "LANG=en_US.UTF-8" > /etc/default/locale

# Configure timezone
echo "America/Los_Angeles" > /etc/timezone
dpkg-reconfigure -f noninteractive tzdata

# 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

echo "Basic system setup completed"
`
}

// generatePackageInstallScript creates the script for installing essential packages
func (mg *ManifestGenerator) generatePackageInstallScript() string {
	return `#!/bin/bash
set -e

echo "Installing essential system packages..."

# Update package lists
apt-get update

# Install essential packages
apt-get install -y \
  systemd \
  systemd-sysv \
  dbus \
  dbus-user-session \
  bash \
  coreutils \
  util-linux \
  sudo \
  curl \
  wget \
  ca-certificates \
  gnupg \
  locales \
  keyboard-configuration \
  console-setup \
  udev \
  kmod \
  pciutils \
  usbutils \
  rsyslog \
  logrotate \
  systemd-timesyncd \
  tzdata

# Install bootc and OSTree packages
apt-get install -y \
  ostree \
  ostree-boot \
  dracut \
  grub-efi-amd64 \
  efibootmgr \
  linux-image-amd64 \
  linux-headers-amd64 \
  parted \
  e2fsprogs \
  dosfstools \
  fdisk \
  gdisk \
  bootupd

echo "Essential packages installed successfully"
`
}

// determineBootloaderType determines which bootloader to use
func (mg *ManifestGenerator) determineBootloaderType() BootloaderType {
	// If explicitly specified, use that
	if mg.options.Bootloader != BootloaderAuto {
		return mg.options.Bootloader
	}

	// Auto-detect based on container content
	// For now, default to bootupd for OSTree systems, GRUB for traditional
	// This can be enhanced with container analysis later
	return BootloaderBootupd
}

// generateBootloaderScript creates the script for configuring the bootloader
func (mg *ManifestGenerator) generateBootloaderScript(bootloaderType BootloaderType) string {
	switch bootloaderType {
	case BootloaderBootupd:
		return mg.generateBootupdScript()
	case BootloaderGRUB:
		return mg.generateGRUBScript()
	default:
		// Default to bootupd for OSTree systems
		return mg.generateBootupdScript()
	}
}

// generateBootupdScript creates the script for configuring bootupd
func (mg *ManifestGenerator) generateBootupdScript() string {
	return `#!/bin/bash
set -e

echo "Configuring bootupd bootloader..."

# Install bootupd if not already present
if ! command -v bootupctl &> /dev/null; then
    echo "Installing bootupd..."
    apt-get update
    apt-get install -y bootupd
fi

# Create boot directories
mkdir -p /boot/efi
mkdir -p /boot/grub

# Initialize bootupd
bootupctl install || echo "bootupd install failed (expected in container)"

# Enable bootupd service
systemctl enable bootupd

echo "bootupd configuration completed"
`
}

// generateGRUBScript creates the script for configuring GRUB
func (mg *ManifestGenerator) generateGRUBScript() string {
	return `#!/bin/bash
set -e

echo "Configuring GRUB bootloader..."

# Configure GRUB
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\"" >> /etc/default/grub

# Create boot directories
mkdir -p /boot/efi
mkdir -p /boot/grub

# Update GRUB (may fail in container, that's OK)
update-grub || echo "GRUB update failed (expected in container)"

echo "GRUB configuration completed"
`
}

// generateOSTreeScript creates the script for setting up OSTree
func (mg *ManifestGenerator) generateOSTreeScript() string {
	return `#!/bin/bash
set -e

echo "Setting up OSTree structure..."

# Create OSTree directories
mkdir -p /ostree/repo
mkdir -p /sysroot/ostree
mkdir -p /usr/lib/ostree-boot
mkdir -p /usr/lib/kernel
mkdir -p /usr/lib/modules
mkdir -p /usr/lib/firmware

# Enable systemd services
systemctl enable systemd-timesyncd
systemctl enable systemd-networkd

echo "OSTree structure setup completed"
`
}

// determineOutputFormat determines the output format based on image types
func (mg *ManifestGenerator) determineOutputFormat() string {
	if len(mg.options.ImageTypes) == 0 {
		return "qcow2"
	}

	// Prefer qcow2, then raw, then others
	for _, imgType := range mg.options.ImageTypes {
		if imgType == "qcow2" {
			return "qcow2"
		}
	}
	
	for _, imgType := range mg.options.ImageTypes {
		if imgType == "raw" {
			return "raw"
		}
	}

	return mg.options.ImageTypes[0]
}

// generateVariables creates variables for the manifest
func (mg *ManifestGenerator) generateVariables() map[string]interface{} {
	return map[string]interface{}{
		"container_image": mg.options.ContainerImage,
		"architecture":    mg.options.Architecture.String(),
		"suite":          mg.detectSuite(""),
		"extraction_time": "real-time",
		"container_analysis": "enabled",
	}
}

// SaveToFile saves the manifest to a YAML file
func (mg *DebosManifest) SaveToFile(filepath string) error {
	data, err := yaml.Marshal(mg)
	if err != nil {
		return fmt.Errorf("failed to marshal manifest: %w", err)
	}

	if err := os.WriteFile(filepath, data, 0644); err != nil {
		return fmt.Errorf("failed to write manifest file: %w", err)
	}

	return nil
}