feat(image boot): Add vhdfixed format support (#497)

Extend azldev image boot to accept VHD format images,

Author: liunan-ms

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

@@ -42,14 +42,16 @@ const (
 	ImageFormatRaw ImageFormat = "raw"
 	// ImageFormatQcow2 is the QEMU copy-on-write v2 format.
 	ImageFormatQcow2 ImageFormat = "qcow2"
+	// ImageFormatVhd is the Hyper-V VHD format (QEMU driver: vpc).
+	ImageFormatVhd ImageFormat = "vhd"
 	// ImageFormatVhdx is the Hyper-V virtual hard disk format.
 	ImageFormatVhdx ImageFormat = "vhdx"
 )
 
 // SupportedImageFormats returns the list of supported bootable image formats in priority order.
 // When multiple formats exist, the first match in this order is selected.
 func SupportedImageFormats() []string {
-	return []string{string(ImageFormatRaw), string(ImageFormatQcow2), string(ImageFormatVhdx)}
+	return []string{string(ImageFormatRaw), string(ImageFormatQcow2), string(ImageFormatVhdx), string(ImageFormatVhd)}
 }
 
 // Assert that [ImageFormat] implements the [pflag.Value] interface.
@@ -66,6 +68,8 @@ func (f *ImageFormat) Set(value string) error {
 		*f = ImageFormatRaw
 	case string(ImageFormatQcow2):
 		*f = ImageFormatQcow2
+	case string(ImageFormatVhd):
+		*f = ImageFormatVhd
 	case string(ImageFormatVhdx):
 		*f = ImageFormatVhdx
 	default:
@@ -80,6 +84,18 @@ func (f *ImageFormat) Type() string {
 	return "format"
 }
 
+// QEMUDriver returns the QEMU block driver name for the image format.
+// Most formats use their string value directly, but some (e.g., vhd → vpc)
+// require translation.
+func QEMUDriver(format string) string {
+	switch format {
+	case string(ImageFormatVhd):
+		return "vpc"
+	default:
+		return format
+	}
+}
+
 // ImageBootOptions contains options for the boot command.
 type ImageBootOptions struct {
 	Arch                    qemu.Arch
@@ -155,7 +171,7 @@ Requirements:
 
 func addBootFlags(cmd *cobra.Command, options *ImageBootOptions) {
 	cmd.Flags().VarP(&options.Format, "format", "f",
-		"Image format to boot (raw, qcow2, vhdx). Auto-detected if not specified.")
+		"Image format to boot (raw, qcow2, vhdx, vhd). Auto-detected if not specified.")
 
 	cmd.Flags().StringVar(&options.TestUserName, "test-user", "test", "Name for the test account")
 	cmd.Flags().StringVar(&options.TestUserPassword, "test-password", "",
@@ -239,6 +255,19 @@ func bootImage(env *azldev.Env, options *ImageBootOptions) error {
 			slog.String("path", imagePath),
 			slog.String("format", imageFormat),
 		)
+	} else {
+		// Infer format from the file extension when --image-path is used.
+		var err error
+
+		imageFormat, err = InferImageFormat(imagePath)
+		if err != nil {
+			return err
+		}
+
+		slog.Info("Inferred image format from file extension",
+			slog.String("path", imagePath),
+			slog.String("format", imageFormat),
+		)
 	}
 
 	// Dry-run mode: log what would be executed and return early.
@@ -255,9 +284,20 @@ func bootImage(env *azldev.Env, options *ImageBootOptions) error {
 	return bootImageUsingDiskFile(env, options, arch, imagePath, imageFormat)
 }
 
+// fileExtensionsForFormat returns the file extensions to search for the given format.
+// Most formats have a single extension matching the format name, but vhd accepts
+// both .vhd and .vhdfixed since QEMU treats them identically.
+func fileExtensionsForFormat(format string) []string {
+	if format == string(ImageFormatVhd) {
+		return []string{"vhd", "vhdfixed"}
+	}
+
+	return []string{format}
+}
+
 // findBootableImageArtifact locates a bootable image artifact in the output directory for the
 // given image name. If format is specified, only that format is searched. Otherwise, formats
-// are searched in priority order (raw, qcow2, vhdx) and the first match is returned.
+// are searched in priority order (raw, qcow2, vhdx, vhd) and the first match is returned.
 func findBootableImageArtifact(
 	env *azldev.Env, imageName, format string,
 ) (imagePath, imageFormat string, err error) {
@@ -290,16 +330,18 @@ func findBootableImageArtifact(
 
 	// Search for bootable artifacts in priority order.
 	for _, currentFormat := range formatsToSearch {
-		pattern := filepath.Join(imageOutputDir, "*."+currentFormat)
+		for _, ext := range fileExtensionsForFormat(currentFormat) {
+			pattern := filepath.Join(imageOutputDir, "*."+ext)
 
-		matches, globErr := fileutils.Glob(env.FS(), pattern)
-		if globErr != nil {
-			continue
-		}
+			matches, globErr := fileutils.Glob(env.FS(), pattern)
+			if globErr != nil {
+				continue
+			}
 
-		if len(matches) > 0 {
-			// Return the first match for the highest-priority format.
-			return matches[0], currentFormat, nil
+			if len(matches) > 0 {
+				// Return the first match for the highest-priority format.
+				return matches[0], currentFormat, nil
+			}
 		}
 	}
 
@@ -326,6 +368,35 @@ func findBootableImageArtifact(
 	)
 }
 
+// InferImageFormat determines the image format from the file extension.
+// Returns an error if the extension does not match a supported format.
+func InferImageFormat(imagePath string) (string, error) {
+	ext := strings.ToLower(filepath.Ext(imagePath))
+	if ext == "" {
+		return "", fmt.Errorf(
+			"cannot infer image format from %#q: no file extension",
+			imagePath,
+		)
+	}
+
+	// Strip the leading dot (e.g., ".vhdfixed" → "vhdfixed").
+	format := ext[1:]
+	if format == "vhdfixed" {
+		format = string(ImageFormatVhd)
+	}
+
+	// Validate the inferred format is supported.
+	supported := SupportedImageFormats()
+	if !lo.Contains(supported, format) {
+		return "", fmt.Errorf(
+			"unsupported image format %#q inferred from %#q; supported formats: %v",
+			format, imagePath, supported,
+		)
+	}
+
+	return format, nil
+}
+
 // listImageArtifacts returns a list of image artifact filenames in the given directory.
 func listImageArtifacts(env *azldev.Env, dir string) ([]string, error) {
 	entries, err := fileutils.ReadDir(env.FS(), dir)
@@ -428,7 +499,7 @@ func bootImageUsingDiskFile(
 		FirmwarePath:     fwPath,
 		NVRAMPath:        nvramPath,
 		DiskPath:         selectedDiskPath,
-		DiskType:         imageFormat,
+		DiskType:         QEMUDriver(imageFormat),
 		CloudInitISOPath: cloudInitMetadataIsoPath,
 		SecureBoot:       options.SecureBoot,
 		SSHPort:          int(options.SSHPort),

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

@@ -49,14 +49,23 @@ func TestImageFormat_Set_InvalidFormat(t *testing.T) {
 }
 
 func TestImageFormat_Set_ValidFormats(t *testing.T) {
-	validFormats := []string{"raw", "qcow2", "vhdx"}
-	for _, formatStr := range validFormats {
-		t.Run(formatStr, func(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{input: "raw", expected: "raw"},
+		{input: "qcow2", expected: "qcow2"},
+		{input: "vhdx", expected: "vhdx"},
+		{input: "vhd", expected: "vhd"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.input, func(t *testing.T) {
 			var format image.ImageFormat
 
-			err := format.Set(formatStr)
+			err := format.Set(test.input)
 			require.NoError(t, err)
-			assert.Equal(t, formatStr, format.String())
+			assert.Equal(t, test.expected, format.String())
 		})
 	}
 }
@@ -145,6 +154,42 @@ func TestSupportedImageFormats(t *testing.T) {
 	assert.Contains(t, formats, "raw")
 	assert.Contains(t, formats, "qcow2")
 	assert.Contains(t, formats, "vhdx")
+	assert.Contains(t, formats, "vhd")
+}
+
+func TestInferImageFormat(t *testing.T) {
+	tests := []struct {
+		name     string
+		path     string
+		expected string
+	}{
+		{name: "raw", path: "/path/to/image.raw", expected: "raw"},
+		{name: "qcow2", path: "/path/to/image.qcow2", expected: "qcow2"},
+		{name: "vhd", path: "/path/to/image.vhd", expected: "vhd"},
+		{name: "vhdfixed", path: "/path/to/image.vhdfixed", expected: "vhd"},
+		{name: "vhdx", path: "/path/to/image.vhdx", expected: "vhdx"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			format, err := image.InferImageFormat(test.path)
+			require.NoError(t, err)
+			assert.Equal(t, test.expected, format)
+		})
+	}
+}
+
+func TestInferImageFormat_NoExtension(t *testing.T) {
+	_, err := image.InferImageFormat("/path/to/imagefile")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "no file extension")
+}
+
+func TestInferImageFormat_UnsupportedExtension(t *testing.T) {
+	_, err := image.InferImageFormat("/path/to/image.iso")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "unsupported image format")
+	assert.Contains(t, err.Error(), "iso")
 }
 
 func TestSupportedArchitectures(t *testing.T) {