Add StripVolumeRegex configuration property

infrastructure/devicepathresolver/id_device_path_resolver.go

@@ -3,6 +3,7 @@ package devicepathresolver
 import (
 	"fmt"
 	"path"
+	"regexp"
 	"time"
 
 	boshudev "github.com/cloudfoundry/bosh-agent/platform/udevdevice"
@@ -12,20 +13,25 @@ import (
 )
 
 type idDevicePathResolver struct {
-	diskWaitTimeout time.Duration
-	udev            boshudev.UdevDevice
-	fs              boshsys.FileSystem
+	diskWaitTimeout     time.Duration
+	udev                boshudev.UdevDevice
+	fs                  boshsys.FileSystem
+	stripVolumeRegex    string
+	stripVolumeCompiled *regexp.Regexp
 }
 
 func NewIDDevicePathResolver(
 	diskWaitTimeout time.Duration,
 	udev boshudev.UdevDevice,
 	fs boshsys.FileSystem,
+	stripVolumeRegex string,
 ) DevicePathResolver {
 	return idDevicePathResolver{
-		diskWaitTimeout: diskWaitTimeout,
-		udev:            udev,
-		fs:              fs,
+		diskWaitTimeout:     diskWaitTimeout,
+		udev:                udev,
+		fs:                  fs,
+		stripVolumeRegex:    stripVolumeRegex,
+		stripVolumeCompiled: nil,
 	}
 }
 
@@ -48,13 +54,20 @@ func (idpr idDevicePathResolver) GetRealDevicePath(diskSettings boshsettings.Dis
 		return "", false, bosherr.WrapError(err, "Running udevadm settle")
 	}
 
+	if idpr.stripVolumeRegex != "" && idpr.stripVolumeCompiled == nil {
+		idpr.stripVolumeCompiled, err = regexp.Compile(idpr.stripVolumeRegex)
+		if err != nil {
+			return "", false, bosherr.WrapError(err, "Compiling stripVolumeRegex")
+		}
+	}
+
 	stopAfter := time.Now().Add(idpr.diskWaitTimeout)
 	found := false
 
 	var realPath string
 
 	diskID := diskSettings.ID
-	deviceGlobPattern := fmt.Sprintf("*%s", diskID)
+	deviceGlobPattern := fmt.Sprintf("*%s", idpr.stripDiskID(diskID))
 	deviceIDPathGlobPattern := path.Join("/", "dev", "disk", "by-id", deviceGlobPattern)
 
 	for !found {
@@ -87,3 +100,10 @@ func (idpr idDevicePathResolver) GetRealDevicePath(diskSettings boshsettings.Dis
 
 	return realPath, false, nil
 }
+
+func (idpr idDevicePathResolver) stripDiskID(diskID string) string {
+	if idpr.stripVolumeCompiled != nil {
+		return idpr.stripVolumeCompiled.ReplaceAllLiteralString(diskID, "")
+	}
+	return diskID
+}

infrastructure/devicepathresolver/id_device_path_resolver_test.go

@@ -18,10 +18,11 @@ import (
 
 var _ = Describe("IDDevicePathResolver", func() {
 	var (
-		fs           *fakesys.FakeFileSystem
-		udev         *fakeudev.FakeUdevDevice
-		diskSettings boshsettings.DiskSettings
-		pathResolver DevicePathResolver
+		fs               *fakesys.FakeFileSystem
+		udev             *fakeudev.FakeUdevDevice
+		diskSettings     boshsettings.DiskSettings
+		pathResolver     DevicePathResolver
+		stripVolumeRegex string
 	)
 
 	BeforeEach(func() {
@@ -33,7 +34,7 @@ var _ = Describe("IDDevicePathResolver", func() {
 	})
 
 	JustBeforeEach(func() {
-		pathResolver = NewIDDevicePathResolver(500*time.Millisecond, udev, fs)
+		pathResolver = NewIDDevicePathResolver(500*time.Millisecond, udev, fs, stripVolumeRegex)
 	})
 
 	Describe("GetRealDevicePath", func() {
@@ -204,5 +205,36 @@ var _ = Describe("IDDevicePathResolver", func() {
 				Expect(timeout).To(BeFalse())
 			})
 		})
+
+		Context("when stripVolumeRegex option is used to remove mismatched disk ID prefix", func() {
+			BeforeEach(func() {
+				diskSettings = boshsettings.DiskSettings{
+					ID: "vol-fake-disk-id-include-longname",
+				}
+				stripVolumeRegex = "^vol-"
+				err := fs.MkdirAll("/dev/fake-device-path", os.FileMode(0750))
+				Expect(err).ToNot(HaveOccurred())
+
+				err = fs.Symlink("/dev/fake-device-path", "/dev/intermediate/fake-device-path")
+				Expect(err).ToNot(HaveOccurred())
+
+				err = fs.Symlink("/dev/intermediate/fake-device-path", "/dev/disk/by-id/virtio-fake-disk-id-include-longname")
+				Expect(err).ToNot(HaveOccurred())
+
+				fs.SetGlob("/dev/disk/by-id/*fake-disk-id-include-longname", []string{"/dev/disk/by-id/virtio-fake-disk-id-include-longname"})
+			})
+
+			It("removes prefix and returns fully resolved path", func() {
+				path, timeout, err := pathResolver.GetRealDevicePath(diskSettings)
+				Expect(err).ToNot(HaveOccurred())
+
+				devicePath, err := filepath.Abs("/dev/fake-device-path")
+				Expect(err).ToNot(HaveOccurred())
+
+				Expect(path).To(Equal(devicePath))
+				Expect(timeout).To(BeFalse())
+			})
+		})
+
 	})
 })

platform/linux_platform.go

@@ -78,6 +78,10 @@ type LinuxOptions struct {
 	// Strategy for resolving ephemeral & persistent disk partitioners;
 	// possible values: parted, "" (default is sfdisk if disk < 2TB, parted otherwise)
 	PartitionerType string
+
+	// Regular expression specifying what part of volume ID to strip.
+	// possible values:  valid RE2 regex e.g. "^vol-", "" (default is not to strip)
+	StripVolumeRegex string
 }
 
 type linux struct {

platform/provider.go

@@ -115,7 +115,7 @@ func NewProvider(logger boshlog.Logger, dirProvider boshdirs.Provider, statsColl
 	switch options.Linux.DevicePathResolutionType {
 	case "virtio":
 		udev := boshudev.NewConcreteUdevDevice(runner, logger)
-		idDevicePathResolver := devicepathresolver.NewIDDevicePathResolver(500*time.Millisecond, udev, fs)
+		idDevicePathResolver := devicepathresolver.NewIDDevicePathResolver(500*time.Millisecond, udev, fs, options.Linux.StripVolumeRegex)
 		mappedDevicePathResolver := devicepathresolver.NewMappedDevicePathResolver(30000*time.Millisecond, fs)
 		devicePathResolver = devicepathresolver.NewVirtioDevicePathResolver(idDevicePathResolver, mappedDevicePathResolver, logger)
 	case "scsi":