return nil, errNotAbsolute
	}

	// If path has a Windows volume name, convert the volume to a host and prefix
	// per https://blogs.msdn.microsoft.com/ie/2006/12/06/file-uris-in-windows/.
	if vol := filepath.VolumeName(path); vol != "" {
		if strings.HasPrefix(vol, `\\`) {
			path = filepath.ToSlash(path[2:])
			i := strings.IndexByte(path, '/')

			if i < 0 {
				// A degenerate case.

							System:           "",
							SecretRef:        nil,
							SSLEnabled:       false,
							ProtectionDomain: "",
							StoragePool:      "",
							StorageMode:      "",
							VolumeName:       "",
							FSType:           "",
							ReadOnly:         false,
						},
					},
				},
			},
			expected: []string{
				`spec.scaleIO: deprecated in v1.16, non-functional in v1.22+`,
			},

	expectedDesiredSizeMap map[string]*resource.Quantity,
	dsw DesiredStateOfWorld) {
	volumesToMount := dsw.GetVolumesToMount()
	for volumeName, expectedDesiredSize := range expectedDesiredSizeMap {
		if podExistsInVolume := dsw.VolumeExistsWithSpecName(
			expectedPodName, volumeName); !podExistsInVolume {
			t.Fatalf(
				"DSW VolumeExistsWithSpecName returned incorrect value. Expected: <true> Actual: <%v>",

func New(mounter mount.Interface) Interface {
	return &subpath{
		mounter: mounter,
	}
}

func (sp *subpath) CleanSubPaths(podDir string, volumeName string) error {
	return doCleanSubPaths(sp.mounter, podDir, volumeName)
}

func (sp *subpath) SafeMakeDir(subdir string, base string, perm os.FileMode) error {
	realBase, err := filepath.EvalSymlinks(base)
	if err != nil {

              storageClassName: storageClassNameValue
              volumeAttributesClassName: volumeAttributesClassNameValue
              volumeMode: volumeModeValue
              volumeName: volumeNameValue
        fc:
          fsType: fsTypeValue
          lun: 2
          readOnly: true
          targetWWNs:
          - targetWWNsValue
          wwids:
          - wwidsValue

              "storagePool": "storagePoolValue",
              "storageMode": "storageModeValue",
              "volumeName": "volumeNameValue",
              "fsType": "fsTypeValue",
              "readOnly": true
            },
            "storageos": {
              "volumeName": "volumeNameValue",
              "volumeNamespace": "volumeNamespaceValue",
              "fsType": "fsTypeValue",

}

type ConfigSpec struct {
	Disks        []DiskSpec
	StorageClass string
}

type DiskSpec struct {
	Name         string
	Size         string
	StorageClass string
	Annotations  map[string]string
	VolumeName   string
}

// Config is the Schema for the configs API.
type Config struct {
	TypeMeta
	ObjectMeta

	Spec ConfigSpec
}

func findDiskSize(diskSpec *DiskSpec, configSpec *ConfigSpec) string {

	// Path to the device attached. This field is valid only for attach calls.
	// ie: /dev/sdx
	DevicePath string `json:"device,omitempty"`
	// Cluster wide unique name of the volume.
	VolumeName string `json:"volumeName,omitempty"`
	// Represents volume is attached on the node
	Attached bool `json:"attached,omitempty"`
	// Returns capabilities of the driver.
	// By default we assume all the capabilities are supported.

}

// Detacher can detach a volume from a node.
type Detacher interface {
	DeviceUnmounter
	// Detach the given volume from the node with the given Name.
	// volumeName is name of the volume as returned from plugin's
	// GetVolumeName().
	Detach(volumeName string, nodeName types.NodeName) error
}

// DeviceUnmounter can unmount a block volume from the global path.
type DeviceUnmounter interface {

	return newSize, nil
}

func (plugin *portworxVolumePlugin) ConstructVolumeSpec(volumeName, mountPath string) (volume.ReconstructedVolume, error) {
	portworxVolume := &v1.Volume{
		Name: volumeName,
		VolumeSource: v1.VolumeSource{
			PortworxVolume: &v1.PortworxVolumeSource{
				VolumeID: volumeName,
			},
		},
	}
	return volume.ReconstructedVolume{
		Spec: volume.NewSpecFromVolume(portworxVolume),