From 8147b51b5d15ed970e97058d833612cc8e32b1ab Mon Sep 17 00:00:00 2001 From: lukasmetzner Date: Thu, 17 Oct 2024 14:41:24 +0200 Subject: [PATCH 1/3] refactor: Switched to k8s.io/mount-utils Replaced our code for formatting and other disk related functions to k8s.io/mount-utils. This leaves only code that is related to LUKS. --- internal/driver/sanity_test.go | 8 -- internal/mock/volume.go | 28 +---- internal/volumes/mount.go | 99 ++------------- test/integration/volumes_test.go | 202 ++++++++++++++++++++----------- 4 files changed, 144 insertions(+), 193 deletions(-) diff --git a/internal/driver/sanity_test.go b/internal/driver/sanity_test.go index bec0c08d..fb626331 100644 --- a/internal/driver/sanity_test.go +++ b/internal/driver/sanity_test.go @@ -206,14 +206,6 @@ func (s *sanityMountService) PathExists(path string) (bool, error) { return true, nil } -func (s *sanityMountService) FormatDisk(_ string, _ string) error { - return nil -} - -func (s *sanityMountService) DetectDiskFormat(_ string) (string, error) { - return "ext4", nil -} - type sanityResizeService struct{} func (s *sanityResizeService) Resize(volumePath string) error { diff --git a/internal/mock/volume.go b/internal/mock/volume.go index cc44f4ee..5a3f9a40 100644 --- a/internal/mock/volume.go +++ b/internal/mock/volume.go @@ -77,11 +77,9 @@ func (s *VolumeService) Resize(ctx context.Context, volume *csi.Volume, size int } type VolumeMountService struct { - PublishFunc func(targetPath string, devicePath string, opts volumes.MountOpts) error - UnpublishFunc func(targetPath string) error - PathExistsFunc func(path string) (bool, error) - FormatDiskFunc func(disk string, fstype string) error - DetectDiskFormatFunc func(disk string) (string, error) + PublishFunc func(targetPath string, devicePath string, opts volumes.MountOpts) error + UnpublishFunc func(targetPath string) error + PathExistsFunc func(path string) (bool, error) } func (s *VolumeMountService) Publish(targetPath string, devicePath string, opts volumes.MountOpts) error { @@ -91,13 +89,6 @@ func (s *VolumeMountService) Publish(targetPath string, devicePath string, opts return s.PublishFunc(targetPath, devicePath, opts) } -func (s *VolumeMountService) PathExists(path string) (bool, error) { - if s.PathExistsFunc == nil { - panic("not implemented") - } - return s.PathExistsFunc(path) -} - func (s *VolumeMountService) Unpublish(targetPath string) error { if s.UnpublishFunc == nil { panic("not implemented") @@ -105,18 +96,11 @@ func (s *VolumeMountService) Unpublish(targetPath string) error { return s.UnpublishFunc(targetPath) } -func (s *VolumeMountService) FormatDisk(disk string, fstype string) error { - if s.FormatDiskFunc == nil { - panic("not implemented") - } - return s.FormatDiskFunc(disk, fstype) -} - -func (s *VolumeMountService) DetectDiskFormat(disk string) (string, error) { - if s.DetectDiskFormatFunc == nil { +func (s *VolumeMountService) PathExists(path string) (bool, error) { + if s.PathExistsFunc == nil { panic("not implemented") } - return s.DetectDiskFormatFunc(disk) + return s.PathExistsFunc(path) } type VolumeResizeService struct { diff --git a/internal/volumes/mount.go b/internal/volumes/mount.go index e8ea8b7e..8d4dce5e 100644 --- a/internal/volumes/mount.go +++ b/internal/volumes/mount.go @@ -4,7 +4,6 @@ import ( "fmt" "os" "path/filepath" - "regexp" "strings" "github.com/go-kit/log" @@ -29,8 +28,6 @@ type MountService interface { Publish(targetPath string, devicePath string, opts MountOpts) error Unpublish(targetPath string) error PathExists(path string) (bool, error) - FormatDisk(disk string, fstype string) error - DetectDiskFormat(disk string) (string, error) } // LinuxMountService mounts volumes on a Linux system. @@ -100,7 +97,7 @@ func (s *LinuxMountService) Publish(targetPath string, devicePath string, opts M mountOptions = append(mountOptions, opts.Additional...) if opts.EncryptionPassphrase != "" { - existingFSType, err := s.DetectDiskFormat(devicePath) + existingFSType, err := s.mounter.GetDiskFormat(devicePath) if err != nil { return fmt.Errorf("unable to detect existing disk format of %s: %w", devicePath, err) } @@ -122,26 +119,6 @@ func (s *LinuxMountService) Publish(targetPath string, devicePath string, opts M devicePath = luksDevicePath } - // Format disk if requested (/skip formatting for block devices) - if opts.FSType != "" { - existingFSType, err := s.DetectDiskFormat(devicePath) - if err != nil { - return fmt.Errorf("unable to detect existing disk format of %s: %w", devicePath, err) - } - - if existingFSType == "" { - if opts.Readonly { - return fmt.Errorf("cannot publish unformatted disk %s in read-only mode", devicePath) - } - - if err = s.FormatDisk(devicePath, opts.FSType); err != nil { - return err - } - } else if existingFSType != opts.FSType { - return fmt.Errorf("requested %s volume, but disk %s already is formatted with %s", opts.FSType, devicePath, existingFSType) - } - } - level.Info(s.logger).Log( "msg", "publishing volume", "target-path", targetPath, @@ -153,7 +130,11 @@ func (s *LinuxMountService) Publish(targetPath string, devicePath string, opts M "encrypted", opts.EncryptionPassphrase != "", ) - return s.mounter.Mount(devicePath, targetPath, opts.FSType, mountOptions) + if opts.BlockVolume { + return s.mounter.Mount(devicePath, targetPath, opts.FSType, mountOptions) + } + + return s.mounter.FormatAndMount(devicePath, targetPath, opts.FSType, mountOptions) } func (s *LinuxMountService) Unpublish(targetPath string) error { @@ -178,71 +159,5 @@ func (s *LinuxMountService) Unpublish(targetPath string) error { } func (s *LinuxMountService) PathExists(path string) (bool, error) { - level.Debug(s.logger).Log( - "msg", "checking path existence", - "path", path, - ) - _, err := os.Stat(path) - if err == nil { - return true, nil - } - if os.IsNotExist(err) { - return false, nil - } - return false, err -} - -func (s *LinuxMountService) FormatDisk(disk string, fstype string) error { - level.Info(s.logger).Log( - "msg", "formatting disk", - "disk", disk, - "fstype", fstype, - ) - switch fstype { - case "ext4": - _, _, err := command("mkfs.ext4", "-F", "-m0", disk) - return err - case "xfs": - _, _, err := command( - "mkfs.xfs", - "-i", "nrext64=0", // Compatibility with kernel that do not support nrext64 - disk) - return err - case "btrfs": - _, _, err := command("mkfs.btrfs", disk) - return err - default: - return fmt.Errorf("unsupported disk format %s", fstype) - } -} - -// see https://github.com/kubernetes/mount-utils/blob/master/mount_linux.go -func (s *LinuxMountService) DetectDiskFormat(disk string) (string, error) { - args := []string{"-p", "-s", "TYPE", "-s", "PTTYPE", "-o", "export", disk} - output, exitCode, err := command("blkid", args...) - if exitCode == 2 { - return "", nil - } - if err != nil { - return "", err - } - - fstypeRegex := regexp.MustCompile(`TYPE=(.*)`) - pttypeRegex := regexp.MustCompile(`PTTYPE=(.*)`) - fstype := "" - pttype := "" - fstypeMatch := fstypeRegex.FindStringSubmatch(output) - if fstypeMatch != nil { - fstype = fstypeMatch[1] - } - pttypeMatch := pttypeRegex.FindStringSubmatch(output) - if pttypeMatch != nil { - pttype = pttypeMatch[1] - } - - if pttype != "" { - return "", fmt.Errorf("disk %s propably contains partitions", disk) - } - - return fstype, nil + return mount.PathExists(path) } diff --git a/test/integration/volumes_test.go b/test/integration/volumes_test.go index 3288877c..c51dddc4 100644 --- a/test/integration/volumes_test.go +++ b/test/integration/volumes_test.go @@ -11,6 +11,8 @@ import ( "testing" "github.com/go-kit/log" + "k8s.io/mount-utils" + "k8s.io/utils/exec" "github.com/hetznercloud/csi-driver/internal/volumes" ) @@ -23,56 +25,70 @@ func TestVolumePublishUnpublish(t *testing.T) { tests := []struct { name string mountOpts volumes.MountOpts - prepare func(svc volumes.MountService, cs *volumes.CryptSetup, device string) error + prepare func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error expectedError error }{ // Block volume not formatted { - "plain", - volumes.MountOpts{}, - nil, - nil, + name: "plain", + mountOpts: volumes.MountOpts{}, + prepare: nil, + expectedError: nil, }, { - "plain-correct-formatted", - volumes.MountOpts{}, - func(svc volumes.MountService, cs *volumes.CryptSetup, device string) error { - return svc.FormatDisk(device, "ext4") + name: "plain-correct-formatted", + mountOpts: volumes.MountOpts{}, + prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { + tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") + if err != nil { + return err + } + + defer os.RemoveAll(tmppath) + defer mounter.Unmount(tmppath) + return mounter.FormatAndMount(device, tmppath, "ext4", nil) }, - nil, + expectedError: nil, }, { - "plain-wrong-formatted", - volumes.MountOpts{}, - func(svc volumes.MountService, cs *volumes.CryptSetup, device string) error { - return svc.FormatDisk(device, "xfs") + name: "plain-wrong-formatted", + mountOpts: volumes.MountOpts{}, + prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { + tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") + if err != nil { + return err + } + + defer os.RemoveAll(tmppath) + defer mounter.Unmount(tmppath) + return mounter.FormatAndMount(device, tmppath, "xfs", nil) }, - fmt.Errorf("requested ext4 volume, but disk /dev-fake-plain-wrong-formatted already is formatted with xfs"), + expectedError: mount.NewMountError(mount.FilesystemMismatch, ""), }, { - "block-volume", - volumes.MountOpts{BlockVolume: true}, - nil, - nil, + name: "block-volume", + mountOpts: volumes.MountOpts{BlockVolume: true}, + prepare: nil, + expectedError: nil, }, { - "encrypted", - volumes.MountOpts{EncryptionPassphrase: "passphrase"}, - nil, - nil, + name: "encrypted", + mountOpts: volumes.MountOpts{EncryptionPassphrase: "passphrase"}, + prepare: nil, + expectedError: nil, }, { - "encrypted-correct-formatted-1", - volumes.MountOpts{EncryptionPassphrase: "passphrase"}, - func(svc volumes.MountService, cs *volumes.CryptSetup, device string) error { + name: "encrypted-correct-formatted-1", + mountOpts: volumes.MountOpts{EncryptionPassphrase: "passphrase"}, + prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { return cs.Format(device, "passphrase") }, - nil, + expectedError: nil, }, { - "encrypted-correct-formatted-2", - volumes.MountOpts{EncryptionPassphrase: "passphrase"}, - func(svc volumes.MountService, cs *volumes.CryptSetup, device string) error { + name: "encrypted-correct-formatted-2", + mountOpts: volumes.MountOpts{EncryptionPassphrase: "passphrase"}, + prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { if err := cs.Format(device, "passphrase"); err != nil { return err } @@ -85,17 +101,31 @@ func TestVolumePublishUnpublish(t *testing.T) { luksDevicePath := volumes.GenerateLUKSDevicePath(luksDeviceName) - return svc.FormatDisk(luksDevicePath, "ext4") + tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") + if err != nil { + return err + } + + defer os.RemoveAll(tmppath) + defer mounter.Unmount(tmppath) + return mounter.FormatAndMount(luksDevicePath, tmppath, "ext4", nil) }, - nil, + expectedError: nil, }, { - "encrypted-wrong-formatted-1", - volumes.MountOpts{EncryptionPassphrase: "passphrase"}, - func(svc volumes.MountService, cs *volumes.CryptSetup, device string) error { - return svc.FormatDisk(device, "ext4") + name: "encrypted-wrong-formatted-1", + mountOpts: volumes.MountOpts{EncryptionPassphrase: "passphrase"}, + prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { + tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") + if err != nil { + return err + } + + defer os.RemoveAll(tmppath) + defer mounter.Unmount(tmppath) + return mounter.FormatAndMount(device, tmppath, "ext4", nil) }, - fmt.Errorf("requested encrypted volume, but disk /dev-fake-encrypted-wrong-formatted-1 already is formatted with ext4"), + expectedError: fmt.Errorf("requested encrypted volume, but disk /dev-fake-encrypted-wrong-formatted-1 already is formatted with ext4"), }, } @@ -103,6 +133,10 @@ func TestVolumePublishUnpublish(t *testing.T) { t.Run(test.name, func(t *testing.T) { logger := log.NewLogfmtLogger(NewTestingWriter(t)) mountService := volumes.NewLinuxMountService(logger) + mounter := &mount.SafeFormatAndMount{ + Interface: mount.New(""), + Exec: exec.New(), + } cryptSetup := volumes.NewCryptSetup(logger) device, err := createFakeDevice("fake-"+test.name, 512) if err != nil { @@ -110,7 +144,7 @@ func TestVolumePublishUnpublish(t *testing.T) { } if test.prepare != nil { - if err := test.prepare(mountService, cryptSetup, device); err != nil { + if err := test.prepare(mounter, cryptSetup, device); err != nil { t.Fatal(err) } } @@ -123,29 +157,39 @@ func TestVolumePublishUnpublish(t *testing.T) { // Required as FS volumes require target dir, but block volumes require // target file targetPath = path.Join(targetPath, "target-path") - + defer func() { + err := mountService.Unpublish(targetPath) + if err != nil { + t.Fatal(err) + } else { + t.Logf("Unpublished targetPath %s", targetPath) + } + }() publishErr := mountService.Publish(targetPath, device, test.mountOpts) + if test.expectedError != nil { - // We expected an error if publishErr == nil { t.Fatalf("expected error %q but got no error", test.expectedError.Error()) + } + + if got, ok := publishErr.(mount.MountError); ok { + if expected, ok := test.expectedError.(mount.MountError); ok { + if got.Type != expected.Type { + t.Fatalf("Expected Mount Error %s, but got %s", expected.Type, got.Type) + } + return + } else { + t.Fatalf("Test returned MountError %s, but expected error is not of MountError", got.Type) + } } else if test.expectedError.Error() != publishErr.Error() { t.Fatal(fmt.Errorf("expected error %q but got %q", test.expectedError.Error(), publishErr.Error())) + return } - - // Makes no sense to continue verification if we got the error that we expected - _ = mountService.Unpublish(targetPath) - return } + if err != nil { t.Fatal(publishErr) } - defer func() { - err := mountService.Unpublish(targetPath) - if err != nil { - t.Fatal(err) - } - }() // Verify target exists and is of expected type fileInfo, err := os.Stat(targetPath) @@ -165,7 +209,7 @@ func TestVolumePublishUnpublish(t *testing.T) { if test.mountOpts.EncryptionPassphrase == "" { // Verify device has expected fs type // Encrypted volumes always have "crypto_LUKS" - fsType, err := mountService.DetectDiskFormat(device) + fsType, err := mounter.GetDiskFormat(device) if err != nil { t.Fatal(err) } @@ -284,54 +328,70 @@ func TestDetectDiskFormat(t *testing.T) { tests := []*struct { name string - prepare func(*volumes.LinuxMountService, string) error + prepare func(*mount.SafeFormatAndMount, string) error expectedFormat string }{ { - "empty", - nil, - "", + name: "empty", + prepare: nil, + expectedFormat: "", }, { - "ext4", - func(svc *volumes.LinuxMountService, disk string) error { - return svc.FormatDisk(disk, "ext4") + name: "ext4", + prepare: func(mounter *mount.SafeFormatAndMount, device string) error { + tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") + if err != nil { + return err + } + + defer os.RemoveAll(tmppath) + defer mounter.Unmount(tmppath) + return mounter.FormatAndMount(device, tmppath, "ext4", nil) }, - "ext4", + expectedFormat: "ext4", }, { - "xfs", - func(svc *volumes.LinuxMountService, disk string) error { - return svc.FormatDisk(disk, "xfs") + name: "xfs", + prepare: func(mounter *mount.SafeFormatAndMount, device string) error { + tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") + if err != nil { + return err + } + + defer os.RemoveAll(tmppath) + defer mounter.Unmount(tmppath) + return mounter.FormatAndMount(device, tmppath, "xfs", nil) }, - "xfs", + expectedFormat: "xfs", }, { - "crypto_LUKS", - func(svc *volumes.LinuxMountService, disk string) error { + name: "crypto_LUKS", + prepare: func(mounter *mount.SafeFormatAndMount, device string) error { logger := log.NewLogfmtLogger(NewTestingWriter(t)) cryptSetup := volumes.NewCryptSetup(logger) - err := cryptSetup.Format(disk, "passphrase") + err := cryptSetup.Format(device, "passphrase") return err }, - "crypto_LUKS", + expectedFormat: "crypto_LUKS", }, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { - logger := log.NewLogfmtLogger(NewTestingWriter(t)) - mountService := volumes.NewLinuxMountService(logger) + mounter := &mount.SafeFormatAndMount{ + Interface: mount.New(""), + Exec: exec.New(), + } disk, err := createFakeDevice(test.name, 512) if err != nil { t.Fatal(err) } if test.prepare != nil { - if err := test.prepare(mountService, disk); err != nil { + if err := test.prepare(mounter, disk); err != nil { t.Fatal(err) } } - format, err := mountService.DetectDiskFormat(disk) + format, err := mounter.GetDiskFormat(disk) if err != nil { t.Fatal(err) } From aff32c5594159ff88508e2d82caf7558cbd4eeee Mon Sep 17 00:00:00 2001 From: lukasmetzner Date: Fri, 18 Oct 2024 09:16:52 +0200 Subject: [PATCH 2/3] refactor: Helper function for disk formatting --- test/integration/integration_test.go | 13 +++++++ test/integration/volumes_test.go | 57 ++++------------------------ 2 files changed, 20 insertions(+), 50 deletions(-) diff --git a/test/integration/integration_test.go b/test/integration/integration_test.go index 67775cc3..90407907 100644 --- a/test/integration/integration_test.go +++ b/test/integration/integration_test.go @@ -9,6 +9,8 @@ import ( "regexp" "strconv" "testing" + + "k8s.io/mount-utils" ) const testImageName = "hcloud-csi-driver-integrationtests" @@ -105,3 +107,14 @@ func (w TestingWriter) Write(p []byte) (n int, err error) { } return len(p), nil } + +func formatDisk(mounter *mount.SafeFormatAndMount, device string, fstype string) error { + tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") + if err != nil { + return err + } + + defer os.RemoveAll(tmppath) + defer mounter.Unmount(tmppath) + return mounter.FormatAndMount(device, tmppath, fstype, nil) +} diff --git a/test/integration/volumes_test.go b/test/integration/volumes_test.go index c51dddc4..23cf24ab 100644 --- a/test/integration/volumes_test.go +++ b/test/integration/volumes_test.go @@ -39,14 +39,7 @@ func TestVolumePublishUnpublish(t *testing.T) { name: "plain-correct-formatted", mountOpts: volumes.MountOpts{}, prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { - tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") - if err != nil { - return err - } - - defer os.RemoveAll(tmppath) - defer mounter.Unmount(tmppath) - return mounter.FormatAndMount(device, tmppath, "ext4", nil) + return formatDisk(mounter, device, "ext4") }, expectedError: nil, }, @@ -54,14 +47,7 @@ func TestVolumePublishUnpublish(t *testing.T) { name: "plain-wrong-formatted", mountOpts: volumes.MountOpts{}, prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { - tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") - if err != nil { - return err - } - - defer os.RemoveAll(tmppath) - defer mounter.Unmount(tmppath) - return mounter.FormatAndMount(device, tmppath, "xfs", nil) + return formatDisk(mounter, device, "xfs") }, expectedError: mount.NewMountError(mount.FilesystemMismatch, ""), }, @@ -101,14 +87,7 @@ func TestVolumePublishUnpublish(t *testing.T) { luksDevicePath := volumes.GenerateLUKSDevicePath(luksDeviceName) - tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") - if err != nil { - return err - } - - defer os.RemoveAll(tmppath) - defer mounter.Unmount(tmppath) - return mounter.FormatAndMount(luksDevicePath, tmppath, "ext4", nil) + return formatDisk(mounter, luksDevicePath, "ext4") }, expectedError: nil, }, @@ -116,14 +95,7 @@ func TestVolumePublishUnpublish(t *testing.T) { name: "encrypted-wrong-formatted-1", mountOpts: volumes.MountOpts{EncryptionPassphrase: "passphrase"}, prepare: func(mounter *mount.SafeFormatAndMount, cs *volumes.CryptSetup, device string) error { - tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") - if err != nil { - return err - } - - defer os.RemoveAll(tmppath) - defer mounter.Unmount(tmppath) - return mounter.FormatAndMount(device, tmppath, "ext4", nil) + return formatDisk(mounter, device, "ext4") }, expectedError: fmt.Errorf("requested encrypted volume, but disk /dev-fake-encrypted-wrong-formatted-1 already is formatted with ext4"), }, @@ -157,6 +129,7 @@ func TestVolumePublishUnpublish(t *testing.T) { // Required as FS volumes require target dir, but block volumes require // target file targetPath = path.Join(targetPath, "target-path") + publishErr := mountService.Publish(targetPath, device, test.mountOpts) defer func() { err := mountService.Unpublish(targetPath) if err != nil { @@ -165,7 +138,6 @@ func TestVolumePublishUnpublish(t *testing.T) { t.Logf("Unpublished targetPath %s", targetPath) } }() - publishErr := mountService.Publish(targetPath, device, test.mountOpts) if test.expectedError != nil { if publishErr == nil { @@ -183,7 +155,6 @@ func TestVolumePublishUnpublish(t *testing.T) { } } else if test.expectedError.Error() != publishErr.Error() { t.Fatal(fmt.Errorf("expected error %q but got %q", test.expectedError.Error(), publishErr.Error())) - return } } @@ -339,28 +310,14 @@ func TestDetectDiskFormat(t *testing.T) { { name: "ext4", prepare: func(mounter *mount.SafeFormatAndMount, device string) error { - tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") - if err != nil { - return err - } - - defer os.RemoveAll(tmppath) - defer mounter.Unmount(tmppath) - return mounter.FormatAndMount(device, tmppath, "ext4", nil) + return formatDisk(mounter, device, "ext4") }, expectedFormat: "ext4", }, { name: "xfs", prepare: func(mounter *mount.SafeFormatAndMount, device string) error { - tmppath, err := os.MkdirTemp(os.TempDir(), "csi-driver-prepare") - if err != nil { - return err - } - - defer os.RemoveAll(tmppath) - defer mounter.Unmount(tmppath) - return mounter.FormatAndMount(device, tmppath, "xfs", nil) + return formatDisk(mounter, device, "xfs") }, expectedFormat: "xfs", }, From 7f98ceac16849a541303631279ad2e4056b2ad6a Mon Sep 17 00:00:00 2001 From: Lukas Metzner Date: Fri, 18 Oct 2024 11:21:24 +0200 Subject: [PATCH 3/3] Update test/integration/integration_test.go MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Julian Tölle --- test/integration/integration_test.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/integration/integration_test.go b/test/integration/integration_test.go index 90407907..c47a4922 100644 --- a/test/integration/integration_test.go +++ b/test/integration/integration_test.go @@ -114,6 +114,8 @@ func formatDisk(mounter *mount.SafeFormatAndMount, device string, fstype string) return err } + // The library we use to format volumes only supports a combined "FormatAndMount" + // so we call that and immediately unmount and cleanup the temp path afterwards. defer os.RemoveAll(tmppath) defer mounter.Unmount(tmppath) return mounter.FormatAndMount(device, tmppath, fstype, nil)