WIP: add regex transformation paterns for disk resolver

cloudfoundry · Dec 16, 2024 · f24b03f · f24b03f
1 parent a60ec2b
commit f24b03f
Show file tree

Hide file tree

Showing 4 changed files with 51 additions and 40 deletions.
diff --git a/TEST.Md b/TEST.Md
@@ -5,6 +5,29 @@ ideas so far
 
 IDS are coming from `/var/vcap/bosh/persistent_disk_hints.json`
 
+# agent.json
+the agent json regex
+#### GCP
+```
+"DiskIDTransformPatern" "^(disk-.+)$",
+"DiskIDTransformReplacement": "google-${1}"
+```
+#### AWS:
+```
+"DiskIDTransformPatern": "^(vol-(.+))$",
+"DiskIDTransformReplacement": "nvme-Amazon_Elastic_Block_Store_vol${2}"
+```
+#### OpenStack:
+```
+"DiskIDTransformPatern": "^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$",
+"DiskIDTransformReplacement": "scsi-${1}${2}${3}${4}${5}"
+```
+#### AliCloud:
+```
+"DiskIDTransformPatern": "^d-(.+)$",
+"DiskIDTransformReplacement": "virtio-${1}"
+```
+
 # IAAS
 
 ## GCP:

diff --git a/infrastructure/devicepathresolver/id_device_path_resolver.go b/infrastructure/devicepathresolver/id_device_path_resolver.go
@@ -13,25 +13,26 @@ import (
 )
 
 type idDevicePathResolver struct {
-	diskWaitTimeout     time.Duration
-	udev                boshudev.UdevDevice
-	fs                  boshsys.FileSystem
-	stripVolumeRegex    string
-	stripVolumeCompiled *regexp.Regexp
+	diskWaitTimeout            time.Duration
+	udev                       boshudev.UdevDevice
+	fs                         boshsys.FileSystem
+	DiskIDTransformPatern      string
+	DiskIDTransformReplacement string
 }
 
 func NewIDDevicePathResolver(
 	diskWaitTimeout time.Duration,
 	udev boshudev.UdevDevice,
 	fs boshsys.FileSystem,
-	stripVolumeRegex string,
+	DiskIDTransformPatern string,
+	DiskIDTransformReplacement string,
 ) DevicePathResolver {
 	return &idDevicePathResolver{
-		diskWaitTimeout:     diskWaitTimeout,
-		udev:                udev,
-		fs:                  fs,
-		stripVolumeRegex:    stripVolumeRegex,
-		stripVolumeCompiled: nil,
+		diskWaitTimeout:            diskWaitTimeout,
+		udev:                       udev,
+		fs:                         fs,
+		DiskIDTransformPatern:      DiskIDTransformPatern,
+		DiskIDTransformReplacement: DiskIDTransformReplacement,
 	}
 }
 
@@ -60,13 +61,12 @@ func (idpr *idDevicePathResolver) GetRealDevicePath(diskSettings boshsettings.Di
 	var realPath string
 
 	diskID := diskSettings.ID
-	strippedDiskID, err := idpr.stripVolumeIfRequired(diskID)
+	TransformedDiskID, err := idpr.TransformDiskID(diskID)
 	if err != nil {
 		return "", false, err
 	}
 
-	deviceGlobPattern := fmt.Sprintf("*%s", strippedDiskID)
-	deviceIDPathGlobPattern := path.Join("/", "dev", "disk", "by-id", deviceGlobPattern)
+	deviceIDPathGlobPattern := path.Join("/", "dev", "disk", "by-id", TransformedDiskID)
 
 	for !found {
 		if time.Now().After(stopAfter) {
@@ -99,30 +99,17 @@ func (idpr *idDevicePathResolver) GetRealDevicePath(diskSettings boshsettings.Di
 	return realPath, false, nil
 }
 
-func (idpr *idDevicePathResolver) stripVolumeIfRequired(diskID string) (string, error) {
-	fmt.Println("DEBUG: stripVolumeRegex called with diskID:", diskID)
-	if idpr.stripVolumeRegex == "" {
-		fmt.Println("DEBUG: stripVolumeRegex is empty, returning diskID as is")
+func (idpr *idDevicePathResolver) TransformDiskID(diskID string) (string, error) {
+	if idpr.DiskIDTransformPatern == "" {
+		fmt.Println("DEBUG: DiskIDTransformRules is empty, returning diskID as is")
 		return diskID, nil
 	}
 
-	if idpr.stripVolumeCompiled == nil {
-		var err error
-		idpr.stripVolumeCompiled, err = regexp.Compile(idpr.stripVolumeRegex)
-		if err != nil {
-			return "", bosherr.WrapError(err, "Compiling stripVolumeRegex")
-		}
-	}
-
-	// Ugly ducktape code to strip diskID from all the prefixes so we can later re-add them from agent.json
-	re := regexp.MustCompile(`^[^-]+-([0-9a-fA-F-]+)$`)
-	matches := re.FindStringSubmatch(diskID)
-	fmt.Println("DEBUG: all matches found:", matches)
-	if len(matches) > 1 {
-		fmt.Println("DEBUG: matches found:", idpr.stripVolumeRegex+matches[1])
-		strippedDiskID := matches[1]
-		return idpr.stripVolumeRegex + strippedDiskID, nil
+	transformed := diskID
+	re := regexp.MustCompile(idpr.DiskIDTransformPatern)
+	if re.MatchString(transformed) {
+		transformed = re.ReplaceAllString(transformed, idpr.DiskIDTransformReplacement)
 	}
-	fmt.Println("DEBUG: no matches found, returning diskID as is")
-	return idpr.stripVolumeCompiled.ReplaceAllLiteralString(diskID, ""), nil
+	fmt.Printf("DEBUG: DiskIDTransformRules: Original: %s -> Transformed: %s\n", diskID, transformed)
+	return transformed, nil
 }
diff --git a/platform/linux_platform.go b/platform/linux_platform.go
@@ -84,9 +84,10 @@ type LinuxOptions struct {
 	// possible values: systemd, ""
 	ServiceManager 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
+	// Regular expression specifying what part of disk ID to strip and transform
+	// example: "pattern": "^(disk-.+)$", "replacement": "google-${1}",
+	DiskIDTransformPatern string
+	DiskIDTransformReplacement string
 }
 
 type linux struct {

diff --git a/platform/provider.go b/platform/provider.go
@@ -132,7 +132,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, options.Linux.StripVolumeRegex)
+		idDevicePathResolver := devicepathresolver.NewIDDevicePathResolver(500*time.Millisecond, udev, fs, options.Linux.DiskIDTransformPatern, options.Linux.DiskIDTransformReplacement)
 		mappedDevicePathResolver := devicepathresolver.NewMappedDevicePathResolver(30000*time.Millisecond, fs)
 		devicePathResolver = devicepathresolver.NewVirtioDevicePathResolver(idDevicePathResolver, mappedDevicePathResolver, logger)
 	case "scsi":