feat: add e2e test for image customization (#355)

* feat: added image customizer scenario test

* Addressed copilot feedback

* Address Reuben's feedback

---------

Co-authored-by: George Mileka <gmileka@outlook.com>

Author: George Mileka

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

@@ -27,15 +27,18 @@ func NewImageCustomizeCmd() *cobra.Command {
 	}
 
 	cmd.Flags().StringVarP(&options.imageFile, "image-file", "", "",
-		"Path of the base Azure Linux image which the customization will be applied to")
+		"Path of the base Azure Linux image to be customized. Cannot be specified with --image-tag")
+	cmd.Flags().StringVarP(&options.imageTag, "image-tag", "", "",
+		"Container tag for the MCR base Azure Linux image to be downloaded and customized."+
+			" Cannot be specified with --image-file")
 	cmd.Flags().StringVarP(&options.configFile, "config-file", "", "",
 		"Path of the image customization config file")
 	cmd.Flags().StringVar(&options.outputImageFormat, "output-image-format", "",
 		"Format of output image ("+getImageCustomizerImageFormatsString()+")")
 	cmd.Flags().StringVar(&options.outputPath, "output-path", "",
-		"Path to write the customized image artifacts to. It can be a path to "+
-			"a file if the output format is a single file format (e.g., vhd, qcow2), "+
-			"or a path to a directory if the output format is a multi-file format (e.g., pxe-dir, pxe-tar)")
+		"Path to write the customized image artifacts to. It can be a path to"+
+			" a file if the output format is a single file format (e.g., vhd, qcow2),"+
+			" or a path to a directory if the output format is a multi-file format (e.g., pxe-dir, pxe-tar)")
 	cmd.Flags().StringSliceVar(&options.rpmSources, "rpm-source", []string{},
 		"Path to a RPM repo config file or a directory containing RPMs")
 	cmd.Flags().BoolVar(&options.disableBaseImageRpmRepos, "disable-base-image-rpm-repos", false,
@@ -53,15 +56,17 @@ func NewImageCustomizeCmd() *cobra.Command {
 	// Customizer, we are requiring them in azldev so that we can deduce which
 	// folders to mount into the container.
 	// See: https://dev.azure.com/mariner-org/polar/_workitems/edit/15282
-	_ = cmd.MarkFlagRequired("image-file")
 	_ = cmd.MarkFlagRequired("config-file")
 	_ = cmd.MarkFlagRequired("output-path")
 
+	cmd.MarkFlagsMutuallyExclusive("image-file", "image-tag")
+	cmd.MarkFlagsOneRequired("image-file", "image-tag")
+
 	return cmd
 }
 
 func customizeImage(
 	env *azldev.Env, options *imageCustomizerOptions,
 ) error {
-	return runImageCustomizerContainer(env, imageCustomizerCustomize, options)
+	return runImageCustomizerContainer(env, imageCustomizerCustomizeCmd, options)
 }

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

@@ -18,17 +18,21 @@ import (
 )
 
 const (
-	logFileTimeFormat        = "20060102-150405"
-	imageCustomizerCustomize = "customize"
-	imageCustomizerInject    = "inject-files"
+	logFileTimeFormat           = "20060102-150405"
+	imageCustomizerCustomizeCmd = "customize"
+	imageCustomizerInjectCmd    = "inject-files"
 	// The Image Customizer log always goes to a debug-level log file - regardless
 	// of the log level set for azldev.
 	// The log level set for azldev controls what is shown on the console.
 	defaultLogLevel = "debug"
+
+	entryPointSwitch               = "--entrypoint"
+	downloadAndCustomizeScriptPath = "/usr/local/bin/run.sh"
 )
 
 type imageCustomizerOptions struct {
 	imageFile                string
+	imageTag                 string
 	configFile               string
 	outputImageFormat        string
 	outputPath               string
@@ -52,15 +56,17 @@ func getImageCustomizerImageFormatsString() string {
 }
 
 func buildDockerArgs(
-	buildDir, configDir, inputImageDir, logsDir, outputPathDir string, rpmSources []rpmSourceInfo,
+	options *imageCustomizerOptions, buildDir string, logsDir string, rpmSources []rpmSourceInfo,
 ) []string {
+	configDir := path.Dir(options.configFile)
+	outputPathDir := path.Dir(options.outputPath)
+
 	args := []string{
 		"run", "--rm",
 		docker.InteractiveFlag, // Ensure we get a TTY (not the default when run with --privileged)
 		docker.PrivilegedFlag,
 		"-v", buildDir + ":" + buildDir + docker.MountRWOption,
 		"-v", configDir + ":" + configDir + docker.MountROOption,
-		"-v", inputImageDir + ":" + inputImageDir + docker.MountROOption,
 		"-v", logsDir + ":" + logsDir + docker.MountRWOption,
 		"-v", outputPathDir + ":" + outputPathDir + docker.MountRWOption,
 		"-v", "/dev:/dev",
@@ -72,6 +78,17 @@ func buildDockerArgs(
 		args = append(args, "-v", rpmSource.dir+":"+rpmSource.dir+docker.MountRWOption)
 	}
 
+	if options.imageFile != "" {
+		inputImageDir := path.Dir(options.imageFile)
+		args = append(args, "-v", inputImageDir+":"+inputImageDir+docker.MountROOption)
+	} else if options.imageTag != "" {
+		// To be able to use the image tag, we need to set the entry point to
+		// the script that will download the image first and then run the
+		// Image Customizer after that. This overrides the default entry point
+		// which calls the Image Customizer directly.
+		args = append(args, entryPointSwitch, downloadAndCustomizeScriptPath)
+	}
+
 	return args
 }
 
@@ -105,18 +122,32 @@ func buildRpmSourcesInfo(rpmSources []string) []rpmSourceInfo {
 }
 
 func buildImageCustomizerArgs(
-	options *imageCustomizerOptions, buildDir, logFile, logLevel, logColor string, rpmSources []rpmSourceInfo,
+	options *imageCustomizerOptions, imageCustomizerCommand, buildDir, logFile, logLevel, logColor string,
+	rpmSources []rpmSourceInfo,
 ) []string {
-	args := []string{
+	args := []string{}
+
+	if options.imageTag != "" {
+		// /usr/local/bin/run.sh expects the first argument to be the image tag.
+		// It then passes the rest to the image customizer binary as before.
+		args = append(args, options.imageTag)
+	}
+
+	args = append(args, imageCustomizerCommand)
+
+	if options.imageFile != "" {
+		args = append(args, "--image-file", options.imageFile)
+	}
+
+	args = append(args, []string{
 		"--build-dir", buildDir,
 		"--config-file", options.configFile,
-		"--image-file", options.imageFile,
 		"--output-image-format", options.outputImageFormat,
 		"--output-path", options.outputPath,
 		"--log-level", logLevel,
 		"--log-color", logColor,
 		"--log-file", logFile,
-	}
+	}...)
 
 	for _, rpmSource := range rpmSources {
 		args = append(args, "--rpm-source", rpmSource.source)
@@ -134,10 +165,10 @@ func buildImageCustomizerArgs(
 }
 
 func runImageCustomizerContainer(
-	env *azldev.Env, command string, options *imageCustomizerOptions,
+	env *azldev.Env, imageCustomizerCommand string, options *imageCustomizerOptions,
 ) error {
 	if env.DryRun() {
-		return fmt.Errorf("dry-run mode is not supported for the 'image %s' command", command)
+		return fmt.Errorf("dry-run mode is not supported for the 'image %s' command", imageCustomizerCommand)
 	}
 
 	containerTag := env.Config().Tools.ImageCustomizer.ContainerTag
@@ -157,10 +188,6 @@ func runImageCustomizerContainer(
 		logsDir = filepath.Join(env.ProjectDir(), projectgen.DefaultLogDir)
 	}
 
-	configDir := path.Dir(options.configFile)
-	inputImageDir := path.Dir(options.imageFile)
-	outputPathDir := path.Dir(options.outputPath)
-
 	timestamp := time.Now().Format(logFileTimeFormat)
 	logFile := path.Join(logsDir, fmt.Sprintf("image-customizer-%s.log", timestamp))
 	logMarkers := getImageCustomizerInfoMarkers()
@@ -169,13 +196,13 @@ func runImageCustomizerContainer(
 
 	rpmSourcesInfo := buildRpmSourcesInfo(options.rpmSources)
 
-	dockerArgs := buildDockerArgs(buildDir, configDir, inputImageDir, logsDir, outputPathDir, rpmSourcesInfo)
+	dockerArgs := buildDockerArgs(options, buildDir, logsDir, rpmSourcesInfo)
 
 	imageCustomizerArgs := buildImageCustomizerArgs(
-		options, buildDir, logFile, defaultLogLevel, string(env.ColorMode()), rpmSourcesInfo,
-	)
+		options, imageCustomizerCommand, buildDir, logFile, defaultLogLevel, string(env.ColorMode()),
+		rpmSourcesInfo)
 
-	_, err := docker.RunDocker(env.Context(), env, dockerArgs, containerTag, command, imageCustomizerArgs, logFile,
+	_, err := docker.RunDocker(env.Context(), env, dockerArgs, containerTag, imageCustomizerArgs, logFile,
 		func(_ context.Context, line string) {
 			filterImageCustomizerOutput(env, line, logMarkers)
 		},

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

@@ -56,5 +56,5 @@ func NewImageInjectFilesCmd() *cobra.Command {
 func injectFileIntoImage(
 	env *azldev.Env, options *imageCustomizerOptions,
 ) error {
-	return runImageCustomizerContainer(env, imageCustomizerInject, options)
+	return runImageCustomizerContainer(env, imageCustomizerInjectCmd, options)
 }

internal/utils/docker/docker.go

@@ -17,7 +17,7 @@ const (
 	MountRWOption   string = ":z"
 	MountROOption   string = ":z,ro"
 	PrivilegedFlag  string = "--privileged"
-	InteractiveFlag string = "-it"
+	InteractiveFlag string = "-i"
 )
 
 func validateDockerArgs(dockerArgs []string) error {
@@ -46,7 +46,7 @@ func validateDockerArgs(dockerArgs []string) error {
 // stdout output as a string. It can also capture output from a log file (logFile)
 // in real-time, filter it (logFilter) and send it to the console.
 func RunDocker(ctx context.Context, cmdFactory opctx.CmdFactory, dockerArgs []string,
-	containerTag string, command string, commandArgs []string, logFile string,
+	containerTag string, entryPointArgs []string, logFile string,
 	logFilter func(context.Context, string),
 ) (string, error) {
 	err := validateDockerArgs(dockerArgs)
@@ -58,8 +58,7 @@ func RunDocker(ctx context.Context, cmdFactory opctx.CmdFactory, dockerArgs []st
 
 	args = append(args, dockerArgs...)
 	args = append(args, containerTag)
-	args = append(args, command)
-	args = append(args, commandArgs...)
+	args = append(args, entryPointArgs...)
 
 	var stderr strings.Builder
 

scenario/docker/Dockerfile

@@ -32,6 +32,9 @@ RUN groupadd -f -g "${GID}" mock && \
 RUN tdnf -y install \
     ca-certificates \
     mock \
+    moby-containerd \
+    moby-engine \
+    docker-cli \
     sudo
 
 COPY entrypoint.sh /usr/local/bin/entrypoint.sh