defined a common interface for nativeimgutil & qemuimgutil

Signed-off-by: Praful Khanduri <[email protected]>

Author: Horiodino

cmd/limactl/disk.go

@@ -18,8 +18,7 @@ import (
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 
-	"github.com/lima-vm/lima/pkg/nativeimgutil"
-	"github.com/lima-vm/lima/pkg/qemu/imgutil"
+	"github.com/lima-vm/lima/pkg/imgutil/proxyimgutil"
 	"github.com/lima-vm/lima/pkg/store"
 	"github.com/lima-vm/lima/pkg/store/filenames"
 )
@@ -113,11 +112,8 @@ func diskCreateAction(cmd *cobra.Command, args []string) error {
 
 	// qemu may not be available, use it only if needed.
 	dataDisk := filepath.Join(diskDir, filenames.DataDisk)
-	if format == "raw" {
-		err = nativeimgutil.CreateRawDisk(dataDisk, int(diskSize))
-	} else {
-		err = imgutil.CreateDisk(dataDisk, format, int(diskSize))
-	}
+	diskUtil := proxyimgutil.NewProxyImageUtil()
+	err = diskUtil.CreateDisk(dataDisk, int(diskSize))
 	if err != nil {
 		rerr := os.RemoveAll(diskDir)
 		if rerr != nil {
@@ -410,11 +406,8 @@ func diskResizeAction(cmd *cobra.Command, args []string) error {
 
 	// qemu may not be available, use it only if needed.
 	dataDisk := filepath.Join(disk.Dir, filenames.DataDisk)
-	if disk.Format == "raw" {
-		err = nativeimgutil.ResizeRawDisk(dataDisk, int(diskSize))
-	} else {
-		err = imgutil.ResizeDisk(dataDisk, disk.Format, int(diskSize))
-	}
+	diskUtil := proxyimgutil.NewProxyImageUtil()
+	err = diskUtil.ResizeDisk(dataDisk, int(diskSize))
 	if err != nil {
 		return fmt.Errorf("failed to resize disk %q: %w", diskName, err)
 	}

pkg/imgutil/interface.go

@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: Copyright The Lima Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package imgutil
+
+import (
+	"encoding/json"
+	"os"
+)
+
+// ImageDiskManager defines the common operations for disk image utilities.
+type ImageDiskManager interface {
+	// CreateDisk creates a new disk image with the specified size.
+	CreateDisk(disk string, size int) error
+
+	// ResizeDisk resizes an existing disk image to the specified size.
+	ResizeDisk(disk string, size int) error
+
+	// ConvertToRaw converts a disk image to raw format.
+	ConvertToRaw(source, dest string, size *int64, allowSourceWithBackingFile bool) error
+
+	// MakeSparse makes a file sparse, starting from the specified offset.
+	MakeSparse(f *os.File, offset int64) error
+}
+
+type InfoFormatSpecific struct {
+	Type string          `json:"type,omitempty"` // since QEMU 1.7
+	Data json.RawMessage `json:"data,omitempty"` // since QEMU 1.7
+}
+
+func (sp *InfoFormatSpecific) Qcow2() *InfoFormatSpecificDataQcow2 {
+	if sp.Type != "qcow2" {
+		return nil
+	}
+	var x InfoFormatSpecificDataQcow2
+	if err := json.Unmarshal(sp.Data, &x); err != nil {
+		panic(err)
+	}
+	return &x
+}
+
+func (sp *InfoFormatSpecific) Vmdk() *InfoFormatSpecificDataVmdk {
+	if sp.Type != "vmdk" {
+		return nil
+	}
+	var x InfoFormatSpecificDataVmdk
+	if err := json.Unmarshal(sp.Data, &x); err != nil {
+		panic(err)
+	}
+	return &x
+}
+
+type InfoFormatSpecificDataQcow2 struct {
+	Compat          string `json:"compat,omitempty"`           // since QEMU 1.7
+	LazyRefcounts   bool   `json:"lazy-refcounts,omitempty"`   // since QEMU 1.7
+	Corrupt         bool   `json:"corrupt,omitempty"`          // since QEMU 2.2
+	RefcountBits    int    `json:"refcount-bits,omitempty"`    // since QEMU 2.3
+	CompressionType string `json:"compression-type,omitempty"` // since QEMU 5.1
+	ExtendedL2      bool   `json:"extended-l2,omitempty"`      // since QEMU 5.2
+}
+
+type InfoFormatSpecificDataVmdk struct {
+	CreateType string                             `json:"create-type,omitempty"` // since QEMU 1.7
+	CID        int                                `json:"cid,omitempty"`         // since QEMU 1.7
+	ParentCID  int                                `json:"parent-cid,omitempty"`  // since QEMU 1.7
+	Extents    []InfoFormatSpecificDataVmdkExtent `json:"extents,omitempty"`     // since QEMU 1.7
+}
+
+type InfoFormatSpecificDataVmdkExtent struct {
+	Filename    string `json:"filename,omitempty"`     // since QEMU 1.7
+	Format      string `json:"format,omitempty"`       // since QEMU 1.7
+	VSize       int64  `json:"virtual-size,omitempty"` // since QEMU 1.7
+	ClusterSize int    `json:"cluster-size,omitempty"` // since QEMU 1.7
+}

pkg/nativeimgutil/fuzz_test.go renamed to pkg/imgutil/nativeimgutil/fuzz_test.go

@@ -17,6 +17,6 @@ func FuzzConvertToRaw(f *testing.F) {
 		destPath := filepath.Join(t.TempDir(), "dest.img")
 		err := os.WriteFile(srcPath, imgData, 0o600)
 		assert.NilError(t, err)
-		_ = ConvertToRaw(srcPath, destPath, &size, withBacking)
+		_ = convertToRaw(srcPath, destPath, &size, withBacking)
 	})
 }

pkg/nativeimgutil/nativeimgutil.go renamed to pkg/imgutil/nativeimgutil/nativeimgutil.go

@@ -28,14 +28,22 @@ import (
 // aligned to 512 bytes.
 const sectorSize = 512
 
-// RoundUp rounds size up to sectorSize.
-func RoundUp(size int) int {
+// NativeImageUtil is the native implementation of the imgutil Interface.
+type NativeImageUtil struct{}
+
+// NewNativeImageUtil returns a new NativeImageUtil instance.
+func NewNativeImageUtil() *NativeImageUtil {
+	return &NativeImageUtil{}
+}
+
+// roundUp rounds size up to sectorSize.
+func roundUp(size int) int {
 	sectors := (size + sectorSize - 1) / sectorSize
 	return sectors * sectorSize
 }
 
-// CreateRawDisk creates an empty raw data disk.
-func CreateRawDisk(disk string, size int) error {
+// createRawDisk creates an empty raw data disk.
+func createRawDisk(disk string, size int) error {
 	if _, err := os.Stat(disk); err == nil || !errors.Is(err, fs.ErrNotExist) {
 		return err
 	}
@@ -44,20 +52,20 @@ func CreateRawDisk(disk string, size int) error {
 		return err
 	}
 	defer f.Close()
-	roundedSize := RoundUp(size)
+	roundedSize := roundUp(size)
 	return f.Truncate(int64(roundedSize))
 }
 
-// ResizeRawDisk resizes a raw data disk.
-func ResizeRawDisk(disk string, size int) error {
-	roundedSize := RoundUp(size)
+// resizeRawDisk resizes a raw data disk.
+func resizeRawDisk(disk string, size int) error {
+	roundedSize := roundUp(size)
 	return os.Truncate(disk, int64(roundedSize))
 }
 
-// ConvertToRaw converts a source disk into a raw disk.
+// convertToRaw converts a source disk into a raw disk.
 // source and dest may be same.
-// ConvertToRaw is a NOP if source == dest, and no resizing is needed.
-func ConvertToRaw(source, dest string, size *int64, allowSourceWithBackingFile bool) error {
+// convertToRaw is a NOP if source == dest, and no resizing is needed.
+func convertToRaw(source, dest string, size *int64, allowSourceWithBackingFile bool) error {
 	srcF, err := os.Open(source)
 	if err != nil {
 		return err
@@ -106,7 +114,7 @@ func ConvertToRaw(source, dest string, size *int64, allowSourceWithBackingFile b
 	// Truncating before copy eliminates the seeks during copy and provide a
 	// hint to the file system that may minimize allocations and fragmentation
 	// of the file.
-	if err := MakeSparse(destTmpF, srcImg.Size()); err != nil {
+	if err := makeSparse(destTmpF, srcImg.Size()); err != nil {
 		return err
 	}
 
@@ -125,7 +133,7 @@ func ConvertToRaw(source, dest string, size *int64, allowSourceWithBackingFile b
 	// Resize
 	if size != nil {
 		logrus.Infof("Expanding to %s", units.BytesSize(float64(*size)))
-		if err = MakeSparse(destTmpF, *size); err != nil {
+		if err = makeSparse(destTmpF, *size); err != nil {
 			return err
 		}
 	}
@@ -153,7 +161,7 @@ func convertRawToRaw(source, dest string, size *int64) error {
 		if err != nil {
 			return err
 		}
-		if err = MakeSparse(destF, *size); err != nil {
+		if err = makeSparse(destF, *size); err != nil {
 			_ = destF.Close()
 			return err
 		}
@@ -162,7 +170,7 @@ func convertRawToRaw(source, dest string, size *int64) error {
 	return nil
 }
 
-func MakeSparse(f *os.File, n int64) error {
+func makeSparse(f *os.File, n int64) error {
 	if _, err := f.Seek(n, io.SeekStart); err != nil {
 		return err
 	}

pkg/nativeimgutil/nativeimgutil_test.go renamed to pkg/imgutil/nativeimgutil/nativeimgutil_test.go

@@ -25,7 +25,7 @@ func TestRoundUp(t *testing.T) {
 		{123456789, 123457024},
 	}
 	for _, tc := range tests {
-		if RoundUp(tc.Size) != tc.Rounded {
+		if roundUp(tc.Size) != tc.Rounded {
 			t.Errorf("expected %d, got %d", tc.Rounded, tc.Size)
 		}
 	}
@@ -63,15 +63,15 @@ func TestConvertToRaw(t *testing.T) {
 	t.Run("qcow without backing file", func(t *testing.T) {
 		resultImage := filepath.Join(tmpDir, strings.ReplaceAll(strings.ReplaceAll(t.Name(), string(os.PathSeparator), "_"), "/", "_"))
 
-		err = ConvertToRaw(qcowImage.Name(), resultImage, nil, false)
+		err = convertToRaw(qcowImage.Name(), resultImage, nil, false)
 		assert.NilError(t, err)
 		assertFileEquals(t, rawImage.Name(), resultImage)
 	})
 
 	t.Run("qcow with backing file", func(t *testing.T) {
 		resultImage := filepath.Join(tmpDir, strings.ReplaceAll(strings.ReplaceAll(t.Name(), string(os.PathSeparator), "_"), "/", "_"))
 
-		err = ConvertToRaw(qcowImage.Name(), resultImage, nil, true)
+		err = convertToRaw(qcowImage.Name(), resultImage, nil, true)
 		assert.NilError(t, err)
 		assertFileEquals(t, rawImage.Name(), resultImage)
 	})
@@ -80,15 +80,15 @@ func TestConvertToRaw(t *testing.T) {
 		resultImage := filepath.Join(tmpDir, strings.ReplaceAll(strings.ReplaceAll(t.Name(), string(os.PathSeparator), "_"), "/", "_"))
 
 		size := int64(2_097_152) // 2mb
-		err = ConvertToRaw(qcowImage.Name(), resultImage, &size, false)
+		err = convertToRaw(qcowImage.Name(), resultImage, &size, false)
 		assert.NilError(t, err)
 		assertFileEquals(t, rawImageExtended.Name(), resultImage)
 	})
 
 	t.Run("raw", func(t *testing.T) {
 		resultImage := filepath.Join(tmpDir, strings.ReplaceAll(strings.ReplaceAll(t.Name(), string(os.PathSeparator), "_"), "/", "_"))
 
-		err = ConvertToRaw(rawImage.Name(), resultImage, nil, false)
+		err = convertToRaw(rawImage.Name(), resultImage, nil, false)
 		assert.NilError(t, err)
 		assertFileEquals(t, rawImage.Name(), resultImage)
 	})

pkg/imgutil/nativeimgutil/util.go

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright The Lima Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package nativeimgutil
+
+import (
+	"os"
+)
+
+// CreateDisk creates a new raw disk image with the specified size.
+func (n *NativeImageUtil) CreateDisk(disk string, size int) error {
+	return createRawDisk(disk, size)
+}
+
+// ResizeDisk resizes an existing raw disk image to the specified size.
+func (n *NativeImageUtil) ResizeDisk(disk string, size int) error {
+	return resizeRawDisk(disk, size)
+}
+
+// ConvertToRaw converts a disk image to raw format.
+func (n *NativeImageUtil) ConvertToRaw(source, dest string, size *int64, allowSourceWithBackingFile bool) error {
+	return convertToRaw(source, dest, size, allowSourceWithBackingFile)
+}
+
+func (n *NativeImageUtil) MakeSparse(f *os.File, offset int64) error {
+	return makeSparse(f, offset)
+}

pkg/imgutil/proxyimgutil/proxyimgutil.go

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: Copyright The Lima Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package proxyimgutil
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+
+	"github.com/lima-vm/lima/pkg/imgutil"
+	"github.com/lima-vm/lima/pkg/imgutil/nativeimgutil"
+	"github.com/lima-vm/lima/pkg/imgutil/qemuimgutil"
+)
+
+type ProxyImageDiskManager struct {
+	qemu   imgutil.ImageDiskManager
+	native imgutil.ImageDiskManager
+}
+
+func NewProxyImageUtil() imgutil.ImageDiskManager {
+	return &ProxyImageDiskManager{
+		qemu:   qemuimgutil.NewQemuImageUtil(),
+		native: nativeimgutil.NewNativeImageUtil(),
+	}
+}
+
+func (p *ProxyImageDiskManager) CreateDisk(disk string, size int) error {
+	if err := p.qemu.CreateDisk(disk, size); err != nil {
+		if errors.Is(err, exec.ErrNotFound) {
+			return p.native.CreateDisk(disk, size)
+		}
+		return err
+	}
+	return nil
+}
+
+func (p *ProxyImageDiskManager) ResizeDisk(disk string, size int) error {
+	if err := p.qemu.ResizeDisk(disk, size); err != nil {
+		if errors.Is(err, exec.ErrNotFound) {
+			return p.native.ResizeDisk(disk, size)
+		}
+		return err
+	}
+	return nil
+}
+
+func (p *ProxyImageDiskManager) ConvertToRaw(source, dest string, size *int64, allowSourceWithBackingFile bool) error {
+	if err := p.qemu.ConvertToRaw(source, dest, size, allowSourceWithBackingFile); err != nil {
+		if errors.Is(err, exec.ErrNotFound) {
+			return p.native.ConvertToRaw(source, dest, size, allowSourceWithBackingFile)
+		}
+		return err
+	}
+	return nil
+}
+
+func (p *ProxyImageDiskManager) MakeSparse(f *os.File, offset int64) error {
+	if err := p.qemu.MakeSparse(f, offset); err != nil {
+		if errors.Is(err, exec.ErrNotFound) {
+			return p.native.MakeSparse(f, offset)
+		}
+		return err
+	}
+	return nil
+}