feat: add image build using kiwi (#420)

Author: reubeno

internal/app/azldev/cmds/image/build.go

@@ -0,0 +1,245 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+package image
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+	"path/filepath"
+
+	"github.com/gim-home/azldev-preview/internal/app/azldev"
+	"github.com/gim-home/azldev-preview/internal/app/azldev/core/workdir"
+	"github.com/gim-home/azldev-preview/internal/projectconfig"
+	"github.com/gim-home/azldev-preview/internal/utils/fileutils"
+	"github.com/gim-home/azldev-preview/internal/utils/kiwi"
+	"github.com/spf13/cobra"
+)
+
+// Options for building images.
+type ImageBuildOptions struct {
+	// Name of the image to build.
+	ImageName string
+
+	// Paths to local repositories to include during build.
+	LocalRepoPaths []string
+}
+
+// ImageBuildResult summarizes the results of building an image.
+type ImageBuildResult struct {
+	// Name of the image that was built.
+	ImageName string `json:"imageName" table:",sortkey"`
+
+	// Path to the output directory containing the built image.
+	OutputDir string `json:"outputDir" table:"Output Dir"`
+
+	// Paths to the artifact files that were linked into the output directory.
+	ArtifactPaths []string `json:"artifactPaths" table:"Artifact Paths"`
+}
+
+func buildOnAppInit(_ *azldev.App, parentCmd *cobra.Command) {
+	parentCmd.AddCommand(NewImageBuildCmd())
+}
+
+// Constructs a [cobra.Command] for the 'image build' command.
+func NewImageBuildCmd() *cobra.Command {
+	options := &ImageBuildOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "build [image-name]",
+		Short: "Build an image using kiwi-ng",
+		Long: `Build an image using kiwi-ng.
+
+The image must be defined in the project configuration with a kiwi definition type.
+This command invokes kiwi-ng via sudo to build the image.`,
+		Args: cobra.MaximumNArgs(1),
+		RunE: azldev.RunFuncWithExtraArgs(func(env *azldev.Env, args []string) (interface{}, error) {
+			if len(args) > 0 {
+				options.ImageName = args[0]
+			}
+
+			return BuildImage(env, options)
+		}),
+		ValidArgsFunction: generateImageNameCompletions,
+	}
+
+	cmd.Flags().StringArrayVar(&options.LocalRepoPaths, "local-repo", []string{},
+		"Paths to local repositories to include during build (can be specified multiple times)")
+
+	return cmd
+}
+
+// BuildImage builds the specified image using kiwi-ng.
+func BuildImage(env *azldev.Env, options *ImageBuildOptions) (*ImageBuildResult, error) {
+	if err := checkBuildPrerequisites(env); err != nil {
+		return nil, err
+	}
+
+	// Resolve the image from config.
+	imageConfig, err := resolveImage(env, options.ImageName)
+	if err != nil {
+		return nil, err
+	}
+
+	// Validate the image definition type.
+	if imageConfig.Definition.DefinitionType != projectconfig.ImageDefinitionTypeKiwi {
+		return nil, fmt.Errorf(
+			"image %#q has definition type %#q, but only %#q is currently supported for building",
+			options.ImageName,
+			imageConfig.Definition.DefinitionType,
+			projectconfig.ImageDefinitionTypeKiwi,
+		)
+	}
+
+	// Check required directories.
+	if env.WorkDir() == "" {
+		return nil, errors.New("can't build images without a valid work directory configured")
+	}
+
+	if env.OutputDir() == "" {
+		return nil, errors.New("can't build images without a valid output directory configured")
+	}
+
+	// Validate that the kiwi definition file exists.
+	kiwiDefPath := imageConfig.Definition.Path
+	if exists, _ := fileutils.Exists(env.FS(), kiwiDefPath); !exists {
+		return nil, fmt.Errorf("kiwi definition file not found at %#q", kiwiDefPath)
+	}
+
+	// Handle dry-run mode.
+	if env.DryRun() {
+		slog.Info("Dry run: would build image with kiwi-ng",
+			"image", options.ImageName,
+			"definition", kiwiDefPath,
+		)
+
+		return &ImageBuildResult{
+			ImageName: options.ImageName,
+		}, nil
+	}
+
+	// Create workdir factory for intermediate outputs.
+	workDirFactory, err := workdir.NewFactory(env.FS(), env.WorkDir(), env.ConstructionTime())
+	if err != nil {
+		return nil, fmt.Errorf("failed to create work dir factory:\n%w", err)
+	}
+
+	// Create a work directory for kiwi's output. Kiwi requires a fresh directory.
+	kiwiWorkDir, err := workDirFactory.Create(options.ImageName, "kiwi")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create work directory for image build:\n%w", err)
+	}
+
+	// Run kiwi to build the image into the work directory.
+	kiwiRunner := kiwi.NewRunner(env, filepath.Dir(kiwiDefPath)).WithTargetDir(kiwiWorkDir)
+	for _, repoPath := range options.LocalRepoPaths {
+		kiwiRunner.AddLocalRepo(repoPath)
+	}
+
+	err = kiwiRunner.Build(env)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build image %#q:\n%w", options.ImageName, err)
+	}
+
+	// Final output directory for linked artifacts.
+	imageOutputDir := filepath.Join(env.OutputDir(), "images", options.ImageName)
+
+	// Link the final artifacts to the output directory.
+	artifactPaths, err := linkImageArtifacts(env, kiwiWorkDir, imageOutputDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to link image artifacts to output directory:\n%w", err)
+	}
+
+	return &ImageBuildResult{
+		ImageName:     options.ImageName,
+		OutputDir:     imageOutputDir,
+		ArtifactPaths: artifactPaths,
+	}, nil
+}
+
+// checkBuildPrerequisites verifies that required tools are available for building images.
+func checkBuildPrerequisites(env *azldev.Env) error {
+	if err := kiwi.CheckPrerequisites(env); err != nil {
+		return fmt.Errorf("kiwi prerequisite check failed:\n%w", err)
+	}
+
+	return nil
+}
+
+// resolveImage looks up an image by name from the project configuration.
+func resolveImage(env *azldev.Env, imageName string) (*projectconfig.ImageConfig, error) {
+	cfg := env.Config()
+	if cfg == nil {
+		return nil, errors.New("no project configuration loaded")
+	}
+
+	if imageName == "" {
+		return nil, errors.New("image name is required")
+	}
+
+	imageConfig, ok := cfg.Images[imageName]
+	if !ok {
+		return nil, fmt.Errorf("image %#q not found in project configuration", imageName)
+	}
+
+	return &imageConfig, nil
+}
+
+// linkImageArtifacts hard-links the final image artifacts from the work directory to the
+// output directory. Uses symlinks to avoid duplicating large image files.
+// It parses kiwi's result JSON to determine which files are artifacts.
+func linkImageArtifacts(env *azldev.Env, workDir, outputDir string) ([]string, error) {
+	// Parse kiwi's result file to get artifact paths.
+	artifactSourcePaths, err := kiwi.ParseResult(env.FS(), workDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse kiwi result:\n%w", err)
+	}
+
+	if len(artifactSourcePaths) == 0 {
+		slog.Warn("No artifacts found in kiwi result", "workDir", workDir)
+
+		return []string{}, nil
+	}
+
+	linkedPaths := make([]string, 0, len(artifactSourcePaths))
+
+	// Ensure output directory exists.
+	err = fileutils.MkdirAll(env.FS(), outputDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create output directory %#q:\n%w", outputDir, err)
+	}
+
+	// First remove any existing files from previous builds.
+	for _, sourcePath := range artifactSourcePaths {
+		filename := filepath.Base(sourcePath)
+		destPath := filepath.Join(outputDir, filename)
+
+		if exists, _ := fileutils.Exists(env.FS(), destPath); exists {
+			err = env.FS().Remove(destPath)
+			if err != nil {
+				return linkedPaths, fmt.Errorf("failed to remove existing file %#q:\n%w", destPath, err)
+			}
+		}
+	}
+
+	// Now try to link each artifact to the output directory.
+	for _, sourcePath := range artifactSourcePaths {
+		filename := filepath.Base(sourcePath)
+		destPath := filepath.Join(outputDir, filename)
+
+		// Try symlink first (most efficient, no extra space), fall back to copy.
+		err = fileutils.SymLinkOrCopy(env, env.FS(), sourcePath, destPath, fileutils.CopyFileOptions{
+			PreserveFileMode: true,
+		})
+		if err != nil {
+			return linkedPaths, fmt.Errorf("failed to link or copy artifact %#q to output:\n%w", filename, err)
+		}
+
+		linkedPaths = append(linkedPaths, destPath)
+
+		slog.Info("Linked image artifact to output", "path", destPath)
+	}
+
+	return linkedPaths, nil
+}

internal/app/azldev/cmds/image/image.go

@@ -16,6 +16,7 @@ func OnAppInit(app *azldev.App) {
 	}
 
 	app.AddTopLevelCommand(cmd)
+	buildOnAppInit(app, cmd)
 	customizeOnAppInit(app, cmd)
 	injectFilesOnAppInit(app, cmd)
 	listOnAppInit(app, cmd)

internal/app/azldev/core/componentbuilder/componentbuilder.go

@@ -118,7 +118,7 @@ func (b *Builder) prepSourcesForSRPM(
 	defer prepEvent.End()
 
 	// Create a temp dir for the sources.
-	preparedSourcesDir, err = b.workDirFactory.Create(component.GetConfig(), "sources")
+	preparedSourcesDir, err = b.workDirFactory.Create(component.GetName(), "sources")
 	if err != nil {
 		return "", fmt.Errorf("failed to create work dir for source preparation:\n%w", err)
 	}
@@ -139,7 +139,7 @@ func (b *Builder) buildSRPMFromPreparedSources(
 	preparedSpecPath := path.Join(preparedSourcesDir, component.GetName()+".spec")
 
 	// Create a work dir for the SRPM itself.
-	srpmOutputDir, err = b.workDirFactory.Create(component.GetConfig(), "srpm-build")
+	srpmOutputDir, err = b.workDirFactory.Create(component.GetName(), "srpm-build")
 	if err != nil {
 		return "", fmt.Errorf("failed to create work dir:\n%w", err)
 	}
@@ -206,7 +206,7 @@ func (b *Builder) buildRPM(
 	var tempRPMDir string
 
 	// Create a temp dir for the RPM itself.
-	tempRPMDir, err = b.workDirFactory.Create(component.GetConfig(), "rpm-build")
+	tempRPMDir, err = b.workDirFactory.Create(component.GetName(), "rpm-build")
 	if err != nil {
 		return outputRPMPaths, fmt.Errorf("failed to create temp dir:\n%w", err)
 	}

internal/app/azldev/core/workdir/workdir.go

@@ -46,13 +46,13 @@ func NewFactory(fs opctx.FS, baseDir string, timestampTime time.Time) (*Factory,
 // If a work directory with that label has already been used, then a unique one will be
 // generated with a random suffix.
 func (f *Factory) Create(
-	component *projectconfig.ComponentConfig, label string,
+	componentName string, label string,
 ) (dirPath string, err error) {
 	dateBasedDirName := f.timestampTime.Format("2006-01-02.150405")
 
 	componentNameToUse := defaultNameForGlobalWorkDir
-	if component != nil {
-		componentNameToUse = component.Name
+	if componentName != "" {
+		componentNameToUse = componentName
 	}
 
 	parentDirPath := filepath.Join(f.baseDir, componentNameToUse, dateBasedDirName)
@@ -83,7 +83,7 @@ func MkComponentBuildEnvironment(
 	label string,
 ) (buildEnv buildenv.RPMAwareBuildEnv, err error) {
 	// Create a work directory for us to place the environment under.
-	workDir, err := factory.Create(component, label)
+	workDir, err := factory.Create(component.Name, label)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create work dir for component %q:\n%w", component.Name, err)
 	}

internal/app/azldev/core/workdir/workdir_test.go

@@ -45,7 +45,7 @@ func Test_Create(t *testing.T) {
 	factory, err := workdir.NewFactory(env.FS(), env.Env.WorkDir(), env.Env.ConstructionTime())
 	require.NoError(t, err)
 
-	dirPath, err := factory.Create(&component, testLabelName)
+	dirPath, err := factory.Create(component.Name, testLabelName)
 	require.NoError(t, err)
 	require.NotEmpty(t, dirPath)
 

internal/utils/fileutils/copy.go

@@ -11,6 +11,7 @@ import (
 	"path/filepath"
 
 	"github.com/gim-home/azldev-preview/internal/global/opctx"
+	"github.com/spf13/afero"
 )
 
 // Options regarding file copying.
@@ -182,3 +183,44 @@ func CopyDirRecursiveCrossFS(
 
 	return nil
 }
+
+// SymLinkOrCopy attempts to symlink a file, falling back to copy if symlinking
+// is not supported or fails. Symlinks are only attempted on real OS filesystems
+// (afero.OsFs). For other filesystem types (e.g., in-memory filesystems used in tests),
+// this function logs a warning and falls back directly to copying.
+func SymLinkOrCopy(
+	dryRunnable opctx.DryRunnable,
+	fs opctx.FS,
+	sourcePath, destPath string,
+	options CopyFileOptions,
+) error {
+	if dryRunnable.DryRun() {
+		slog.Info("Dry run; would symlink or copy file", "source", sourcePath, "dest", destPath)
+
+		return nil
+	}
+
+	// See if the filesystem supports symlinks.
+	if linker, ok := fs.(afero.Linker); ok {
+		err := linker.SymlinkIfPossible(sourcePath, destPath)
+		if err == nil {
+			return nil
+		}
+
+		// Symlink failed. Warn and fall back to copy.
+		slog.Warn("Symlink failed, falling back to copy",
+			"source", sourcePath,
+			"dest", destPath,
+			"error", err,
+		)
+	} else {
+		// Not supported, skip symlink attempt.
+		slog.Warn("Symlinking not supported on this filesystem, falling back to copy",
+			"source", sourcePath,
+			"dest", destPath,
+			"fsType", fmt.Sprintf("%T", fs),
+		)
+	}
+
+	return CopyFile(dryRunnable, fs, sourcePath, destPath, options)
+}