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

package debos_integration

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

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

// ContainerProcessor handles extraction and processing of container images
type ContainerProcessor struct {
	workDir string
}

// ContainerInfo contains extracted information about a container
type ContainerInfo struct {
	ImageRef      string
	Architecture  string
	OSRelease     *osinfo.OSRelease
	PackageList   []string
	Size          int64
	Layers        []string
	WorkingDir    string
}

// NewContainerProcessor creates a new container processor
func NewContainerProcessor(workDir string) *ContainerProcessor {
	return &ContainerProcessor{
		workDir: workDir,
	}
}

// ExtractContainer extracts the filesystem from a container image
func (cp *ContainerProcessor) ExtractContainer(containerImage string) (*ContainerInfo, error) {
	// Create temporary directory for container extraction
	containerRoot, err := os.MkdirTemp(cp.workDir, "container-*")
	if err != nil {
		return nil, fmt.Errorf("failed to create container extraction directory: %w", err)
	}

	// Extract container using podman (preferred) or docker
	if err := cp.extractWithPodman(containerImage, containerRoot); err != nil {
		// Fallback to docker if podman fails
		if err := cp.extractWithDocker(containerImage, containerRoot); err != nil {
			return nil, fmt.Errorf("failed to extract container with both podman and docker: %w", err)
		}
	}

	// Analyze extracted container
	info, err := cp.analyzeContainer(containerImage, containerRoot)
	if err != nil {
		return nil, fmt.Errorf("failed to analyze container: %w", err)
	}

	info.WorkingDir = containerRoot
	return info, nil
}

// extractWithPodman extracts container using podman
func (cp *ContainerProcessor) extractWithPodman(containerImage, containerRoot string) error {
	// Check if podman is available
	if _, err := exec.LookPath("podman"); err != nil {
		return fmt.Errorf("podman not found in PATH")
	}

	// Create a temporary container
	createCmd := exec.Command("podman", "create", "--name", "temp-extract", containerImage)
	if err := createCmd.Run(); err != nil {
		return fmt.Errorf("failed to create temporary container: %w", err)
	}
	defer cp.cleanupPodmanContainer("temp-extract")

	// Export container filesystem
	exportCmd := exec.Command("podman", "export", "temp-extract")
	exportFile := filepath.Join(cp.workDir, "container-export.tar")
	
	exportFileHandle, err := os.Create(exportFile)
	if err != nil {
		return fmt.Errorf("failed to create export file: %w", err)
	}
	defer exportFileHandle.Close()
	defer os.Remove(exportFile)

	exportCmd.Stdout = exportFileHandle
	if err := exportCmd.Run(); err != nil {
		return fmt.Errorf("failed to export container: %w", err)
	}

	// Extract tar archive
	extractCmd := exec.Command("tar", "-xf", exportFile, "-C", containerRoot)
	if err := extractCmd.Run(); err != nil {
		return fmt.Errorf("failed to extract tar archive: %w", err)
	}

	return nil
}

// extractWithDocker extracts container using docker
func (cp *ContainerProcessor) extractWithDocker(containerImage, containerRoot string) error {
	// Check if docker is available
	if _, err := exec.LookPath("docker"); err != nil {
		return fmt.Errorf("docker not found in PATH")
	}

	// Create a temporary container
	createCmd := exec.Command("docker", "create", "--name", "temp-extract", containerImage)
	if err := createCmd.Run(); err != nil {
		return fmt.Errorf("failed to create temporary container: %w", err)
	}
	defer cp.cleanupDockerContainer("temp-extract")

	// Export container filesystem
	exportCmd := exec.Command("docker", "export", "temp-extract")
	exportFile := filepath.Join(cp.workDir, "container-export.tar")
	
	exportFileHandle, err := os.Create(exportFile)
	if err != nil {
		return fmt.Errorf("failed to create export file: %w", err)
	}
	defer exportFileHandle.Close()
	defer os.Remove(exportFile)

	exportCmd.Stdout = exportFileHandle
	if err := exportCmd.Run(); err != nil {
		return fmt.Errorf("failed to export container: %w", err)
	}

	// Extract tar archive
	extractCmd := exec.Command("tar", "-xf", exportFile, "-C", containerRoot)
	if err := extractCmd.Run(); err != nil {
		return fmt.Errorf("failed to extract tar archive: %w", err)
	}

	return nil
}

// cleanupPodmanContainer removes a temporary podman container
func (cp *ContainerProcessor) cleanupPodmanContainer(containerName string) {
	exec.Command("podman", "rm", containerName).Run()
}

// cleanupDockerContainer removes a temporary docker container
func (cp *ContainerProcessor) cleanupDockerContainer(containerName string) {
	exec.Command("docker", "rm", containerName).Run()
}

// analyzeContainer analyzes the extracted container filesystem
func (cp *ContainerProcessor) analyzeContainer(containerImage, containerRoot string) (*ContainerInfo, error) {
	info := &ContainerInfo{
		ImageRef: containerImage,
	}

	// Extract OS release information
	if osRelease, err := cp.extractOSRelease(containerRoot); err == nil {
		info.OSRelease = osRelease
	}

	// Extract package information
	if packages, err := cp.extractPackageList(containerRoot); err == nil {
		info.PackageList = packages
	}

	// Calculate container size
	if size, err := cp.calculateSize(containerRoot); err == nil {
		info.Size = size
	}

	// Extract layer information
	if layers, err := cp.extractLayerInfo(containerImage); err == nil {
		info.Layers = layers
	}

	return info, nil
}

// extractOSRelease extracts OS release information from container
func (cp *ContainerProcessor) extractOSRelease(containerRoot string) (*osinfo.OSRelease, error) {
	// Try multiple possible locations for os-release
	osReleasePaths := []string{
		"etc/os-release",
		"usr/lib/os-release",
		"lib/os-release",
	}

	for _, path := range osReleasePaths {
		fullPath := filepath.Join(containerRoot, path)
		if data, err := os.ReadFile(fullPath); err == nil {
			return cp.parseOSRelease(string(data)), nil
		}
	}

	return nil, fmt.Errorf("no os-release file found")
}

// parseOSRelease parses os-release file content
func (cp *ContainerProcessor) parseOSRelease(content string) *osinfo.OSRelease {
	release := &osinfo.OSRelease{}
	lines := strings.Split(content, "\n")

	for _, line := range lines {
		if strings.Contains(line, "=") {
			parts := strings.SplitN(line, "=", 2)
			if len(parts) == 2 {
				key := strings.TrimSpace(parts[0])
				value := strings.Trim(strings.TrimSpace(parts[1]), "\"")
				
				switch key {
				case "ID":
					release.ID = value
				case "VERSION_ID":
					release.VersionID = value
				case "NAME":
					release.Name = value
				case "VARIANT_ID":
					release.VariantID = value
				case "PLATFORM_ID":
					release.PlatformID = value
				}
			}
		}
	}

	return release
}

// extractPackageList extracts list of installed packages
func (cp *ContainerProcessor) extractPackageList(containerRoot string) ([]string, error) {
	var packages []string

	// Try to extract package list from dpkg status
	dpkgStatusPath := filepath.Join(containerRoot, "var/lib/dpkg/status")
	if data, err := os.ReadFile(dpkgStatusPath); err == nil {
		packages = cp.parseDpkgStatus(string(data))
	}

	// Try to extract from apt list
	aptListPath := filepath.Join(containerRoot, "var/lib/apt/lists")
	if entries, err := os.ReadDir(aptListPath); err == nil {
		for _, entry := range entries {
			if !entry.IsDir() && strings.HasSuffix(entry.Name(), "_Packages") {
				if data, err := os.ReadFile(filepath.Join(aptListPath, entry.Name())); err == nil {
					packages = append(packages, cp.parseAptPackages(string(data))...)
				}
			}
		}
	}

	return packages, nil
}

// parseDpkgStatus parses dpkg status file for package names
func (cp *ContainerProcessor) parseDpkgStatus(content string) []string {
	var packages []string
	lines := strings.Split(content, "\n")
	
	for _, line := range lines {
		if strings.HasPrefix(line, "Package: ") {
			pkgName := strings.TrimPrefix(line, "Package: ")
			packages = append(packages, strings.TrimSpace(pkgName))
		}
	}
	
	return packages
}

// parseAptPackages parses apt packages file for package names
func (cp *ContainerProcessor) parseAptPackages(content string) []string {
	var packages []string
	lines := strings.Split(content, "\n")
	
	for _, line := range lines {
		if strings.HasPrefix(line, "Package: ") {
			pkgName := strings.TrimPrefix(line, "Package: ")
			packages = append(packages, strings.TrimSpace(pkgName))
		}
	}
	
	return packages
}

// calculateSize calculates the size of the container filesystem
func (cp *ContainerProcessor) calculateSize(containerRoot string) (int64, error) {
	var totalSize int64
	
	err := filepath.Walk(containerRoot, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			totalSize += info.Size()
		}
		return nil
	})
	
	return totalSize, err
}

// extractLayerInfo extracts information about container layers
func (cp *ContainerProcessor) extractLayerInfo(containerImage string) ([]string, error) {
	var layers []string

	// Try podman first
	if _, err := exec.LookPath("podman"); err == nil {
		if output, err := exec.Command("podman", "inspect", containerImage).Output(); err == nil {
			// Simple parsing - in production, use proper JSON parsing
			content := string(output)
			if strings.Contains(content, "sha256:") {
				// Extract layer IDs
				lines := strings.Split(content, "\n")
				for _, line := range lines {
					if strings.Contains(line, "sha256:") {
						parts := strings.Split(line, "sha256:")
						if len(parts) > 1 {
							layerID := strings.Split(parts[1], "\"")[0]
							if len(layerID) >= 12 {
								layers = append(layers, "sha256:"+layerID[:12])
							}
						}
					}
				}
			}
		}
	}

	// Fallback to docker
	if len(layers) == 0 {
		if _, err := exec.LookPath("docker"); err == nil {
			if output, err := exec.Command("docker", "inspect", containerImage).Output(); err == nil {
				content := string(output)
				if strings.Contains(content, "sha256:") {
					lines := strings.Split(content, "\n")
					for _, line := range lines {
						if strings.Contains(line, "sha256:") {
							parts := strings.Split(line, "sha256:")
							if len(parts) > 1 {
								layerID := strings.Split(parts[1], "\"")[0]
								if len(layerID) >= 12 {
									layers = append(layers, "sha256:"+layerID[:12])
								}
							}
						}
					}
				}
			}
		}
	}

	return layers, nil
}

// Cleanup removes temporary container extraction files
func (cp *ContainerProcessor) Cleanup(containerInfo *ContainerInfo) error {
	if containerInfo != nil && containerInfo.WorkingDir != "" {
		return os.RemoveAll(containerInfo.WorkingDir)
	}
	return nil
}