Update to kube v1.17

Signed-off-by: Humble Chirammal <hchiramm@redhat.com>

vendor/k8s.io/csi-translation-lib/plugins/aws_ebs.go

@@ -0,0 +1,255 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package plugins
+
+import (
+	"fmt"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	v1 "k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	// AWSEBSDriverName is the name of the CSI driver for EBS
+	AWSEBSDriverName = "ebs.csi.aws.com"
+	// AWSEBSInTreePluginName is the name of the intree plugin for EBS
+	AWSEBSInTreePluginName = "kubernetes.io/aws-ebs"
+	// AWSEBSTopologyKey is the zonal topology key for AWS EBS CSI driver
+	AWSEBSTopologyKey = "topology." + AWSEBSDriverName + "/zone"
+)
+
+var _ InTreePlugin = &awsElasticBlockStoreCSITranslator{}
+
+// awsElasticBlockStoreTranslator handles translation of PV spec from In-tree EBS to CSI EBS and vice versa
+type awsElasticBlockStoreCSITranslator struct{}
+
+// NewAWSElasticBlockStoreCSITranslator returns a new instance of awsElasticBlockStoreTranslator
+func NewAWSElasticBlockStoreCSITranslator() InTreePlugin {
+	return &awsElasticBlockStoreCSITranslator{}
+}
+
+// TranslateInTreeStorageClassToCSI translates InTree EBS storage class parameters to CSI storage class
+func (t *awsElasticBlockStoreCSITranslator) TranslateInTreeStorageClassToCSI(sc *storage.StorageClass) (*storage.StorageClass, error) {
+	var (
+		generatedTopologies []v1.TopologySelectorTerm
+		params              = map[string]string{}
+	)
+	for k, v := range sc.Parameters {
+		switch strings.ToLower(k) {
+		case fsTypeKey:
+			params[csiFsTypeKey] = v
+		case zoneKey:
+			generatedTopologies = generateToplogySelectors(AWSEBSTopologyKey, []string{v})
+		case zonesKey:
+			generatedTopologies = generateToplogySelectors(AWSEBSTopologyKey, strings.Split(v, ","))
+		default:
+			params[k] = v
+		}
+	}
+
+	if len(generatedTopologies) > 0 && len(sc.AllowedTopologies) > 0 {
+		return nil, fmt.Errorf("cannot simultaneously set allowed topologies and zone/zones parameters")
+	} else if len(generatedTopologies) > 0 {
+		sc.AllowedTopologies = generatedTopologies
+	} else if len(sc.AllowedTopologies) > 0 {
+		newTopologies, err := translateAllowedTopologies(sc.AllowedTopologies, AWSEBSTopologyKey)
+		if err != nil {
+			return nil, fmt.Errorf("failed translating allowed topologies: %v", err)
+		}
+		sc.AllowedTopologies = newTopologies
+	}
+
+	sc.Parameters = params
+
+	return sc, nil
+}
+
+// TranslateInTreeInlineVolumeToCSI takes a Volume with AWSElasticBlockStore set from in-tree
+// and converts the AWSElasticBlockStore source to a CSIPersistentVolumeSource
+func (t *awsElasticBlockStoreCSITranslator) TranslateInTreeInlineVolumeToCSI(volume *v1.Volume) (*v1.PersistentVolume, error) {
+	if volume == nil || volume.AWSElasticBlockStore == nil {
+		return nil, fmt.Errorf("volume is nil or AWS EBS not defined on volume")
+	}
+	ebsSource := volume.AWSElasticBlockStore
+	volumeHandle, err := KubernetesVolumeIDToEBSVolumeID(ebsSource.VolumeID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to translate Kubernetes ID to EBS Volume ID %v", err)
+	}
+	pv := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			// Must be unique per disk as it is used as the unique part of the
+			// staging path
+			Name: fmt.Sprintf("%s-%s", AWSEBSDriverName, ebsSource.VolumeID),
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				CSI: &v1.CSIPersistentVolumeSource{
+					Driver:       AWSEBSDriverName,
+					VolumeHandle: volumeHandle,
+					ReadOnly:     ebsSource.ReadOnly,
+					FSType:       ebsSource.FSType,
+					VolumeAttributes: map[string]string{
+						"partition": strconv.FormatInt(int64(ebsSource.Partition), 10),
+					},
+				},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+		},
+	}
+	return pv, nil
+}
+
+// TranslateInTreePVToCSI takes a PV with AWSElasticBlockStore set from in-tree
+// and converts the AWSElasticBlockStore source to a CSIPersistentVolumeSource
+func (t *awsElasticBlockStoreCSITranslator) TranslateInTreePVToCSI(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.AWSElasticBlockStore == nil {
+		return nil, fmt.Errorf("pv is nil or AWS EBS not defined on pv")
+	}
+
+	ebsSource := pv.Spec.AWSElasticBlockStore
+
+	volumeHandle, err := KubernetesVolumeIDToEBSVolumeID(ebsSource.VolumeID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to translate Kubernetes ID to EBS Volume ID %v", err)
+	}
+
+	csiSource := &v1.CSIPersistentVolumeSource{
+		Driver:       AWSEBSDriverName,
+		VolumeHandle: volumeHandle,
+		ReadOnly:     ebsSource.ReadOnly,
+		FSType:       ebsSource.FSType,
+		VolumeAttributes: map[string]string{
+			"partition": strconv.FormatInt(int64(ebsSource.Partition), 10),
+		},
+	}
+
+	if err := translateTopology(pv, AWSEBSTopologyKey); err != nil {
+		return nil, fmt.Errorf("failed to translate topology: %v", err)
+	}
+
+	pv.Spec.AWSElasticBlockStore = nil
+	pv.Spec.CSI = csiSource
+	return pv, nil
+}
+
+// TranslateCSIPVToInTree takes a PV with CSIPersistentVolumeSource set and
+// translates the EBS CSI source to a AWSElasticBlockStore source.
+func (t *awsElasticBlockStoreCSITranslator) TranslateCSIPVToInTree(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.CSI == nil {
+		return nil, fmt.Errorf("pv is nil or CSI source not defined on pv")
+	}
+
+	csiSource := pv.Spec.CSI
+
+	ebsSource := &v1.AWSElasticBlockStoreVolumeSource{
+		VolumeID: csiSource.VolumeHandle,
+		FSType:   csiSource.FSType,
+		ReadOnly: csiSource.ReadOnly,
+	}
+
+	if partition, ok := csiSource.VolumeAttributes["partition"]; ok {
+		partValue, err := strconv.Atoi(partition)
+		if err != nil {
+			return nil, fmt.Errorf("failed to convert partition %v to integer: %v", partition, err)
+		}
+		ebsSource.Partition = int32(partValue)
+	}
+
+	pv.Spec.CSI = nil
+	pv.Spec.AWSElasticBlockStore = ebsSource
+	return pv, nil
+}
+
+// CanSupport tests whether the plugin supports a given persistent volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *awsElasticBlockStoreCSITranslator) CanSupport(pv *v1.PersistentVolume) bool {
+	return pv != nil && pv.Spec.AWSElasticBlockStore != nil
+}
+
+// CanSupportInline tests whether the plugin supports a given inline volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *awsElasticBlockStoreCSITranslator) CanSupportInline(volume *v1.Volume) bool {
+	return volume != nil && volume.AWSElasticBlockStore != nil
+}
+
+// GetInTreePluginName returns the name of the intree plugin driver
+func (t *awsElasticBlockStoreCSITranslator) GetInTreePluginName() string {
+	return AWSEBSInTreePluginName
+}
+
+// GetCSIPluginName returns the name of the CSI plugin
+func (t *awsElasticBlockStoreCSITranslator) GetCSIPluginName() string {
+	return AWSEBSDriverName
+}
+
+func (t *awsElasticBlockStoreCSITranslator) RepairVolumeHandle(volumeHandle, nodeID string) (string, error) {
+	return volumeHandle, nil
+}
+
+// awsVolumeRegMatch represents Regex Match for AWS volume.
+var awsVolumeRegMatch = regexp.MustCompile("^vol-[^/]*$")
+
+// KubernetesVolumeIDToEBSVolumeID translates Kubernetes volume ID to EBS volume ID
+// KubernetsVolumeID forms:
+//  * aws://<zone>/<awsVolumeId>
+//  * aws:///<awsVolumeId>
+//  * <awsVolumeId>
+// EBS Volume ID form:
+//  * vol-<alphanumberic>
+// This translation shouldn't be needed and should be fixed in long run
+// See https://github.com/kubernetes/kubernetes/issues/73730
+func KubernetesVolumeIDToEBSVolumeID(kubernetesID string) (string, error) {
+	// name looks like aws://availability-zone/awsVolumeId
+
+	// The original idea of the URL-style name was to put the AZ into the
+	// host, so we could find the AZ immediately from the name without
+	// querying the API.  But it turns out we don't actually need it for
+	// multi-AZ clusters, as we put the AZ into the labels on the PV instead.
+	// However, if in future we want to support multi-AZ cluster
+	// volume-awareness without using PersistentVolumes, we likely will
+	// want the AZ in the host.
+	if !strings.HasPrefix(kubernetesID, "aws://") {
+		// Assume a bare aws volume id (vol-1234...)
+		return kubernetesID, nil
+	}
+	url, err := url.Parse(kubernetesID)
+	if err != nil {
+		// TODO: Maybe we should pass a URL into the Volume functions
+		return "", fmt.Errorf("Invalid disk name (%s): %v", kubernetesID, err)
+	}
+	if url.Scheme != "aws" {
+		return "", fmt.Errorf("Invalid scheme for AWS volume (%s)", kubernetesID)
+	}
+
+	awsID := url.Path
+	awsID = strings.Trim(awsID, "/")
+
+	// We sanity check the resulting volume; the two known formats are
+	// vol-12345678 and vol-12345678abcdef01
+	if !awsVolumeRegMatch.MatchString(awsID) {
+		return "", fmt.Errorf("Invalid format for AWS volume (%s)", kubernetesID)
+	}
+
+	return awsID, nil
+}

vendor/k8s.io/csi-translation-lib/plugins/azure_disk.go

@@ -0,0 +1,235 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package plugins
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	v1 "k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	// AzureDiskDriverName is the name of the CSI driver for Azure Disk
+	AzureDiskDriverName = "disk.csi.azure.com"
+	// AzureDiskInTreePluginName is the name of the intree plugin for Azure Disk
+	AzureDiskInTreePluginName = "kubernetes.io/azure-disk"
+
+	// Parameter names defined in azure disk CSI driver, refer to
+	// https://github.com/kubernetes-sigs/azuredisk-csi-driver/blob/master/docs/driver-parameters.md
+	azureDiskKind        = "kind"
+	azureDiskCachingMode = "cachingMode"
+	azureDiskFSType      = "fsType"
+)
+
+var (
+	managedDiskPathRE   = regexp.MustCompile(`.*/subscriptions/(?:.*)/resourceGroups/(?:.*)/providers/Microsoft.Compute/disks/(.+)`)
+	unmanagedDiskPathRE = regexp.MustCompile(`http(?:.*)://(?:.*)/vhds/(.+)`)
+)
+
+var _ InTreePlugin = &azureDiskCSITranslator{}
+
+// azureDiskCSITranslator handles translation of PV spec from In-tree
+// Azure Disk to CSI Azure Disk and vice versa
+type azureDiskCSITranslator struct{}
+
+// NewAzureDiskCSITranslator returns a new instance of azureDiskTranslator
+func NewAzureDiskCSITranslator() InTreePlugin {
+	return &azureDiskCSITranslator{}
+}
+
+// TranslateInTreeStorageClassParametersToCSI translates InTree Azure Disk storage class parameters to CSI storage class
+func (t *azureDiskCSITranslator) TranslateInTreeStorageClassToCSI(sc *storage.StorageClass) (*storage.StorageClass, error) {
+	return sc, nil
+}
+
+// TranslateInTreeInlineVolumeToCSI takes a Volume with AzureDisk set from in-tree
+// and converts the AzureDisk source to a CSIPersistentVolumeSource
+func (t *azureDiskCSITranslator) TranslateInTreeInlineVolumeToCSI(volume *v1.Volume) (*v1.PersistentVolume, error) {
+	if volume == nil || volume.AzureDisk == nil {
+		return nil, fmt.Errorf("volume is nil or Azure Disk not defined on volume")
+	}
+
+	azureSource := volume.AzureDisk
+	pv := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			// Must be unique per disk as it is used as the unique part of the
+			// staging path
+			Name: fmt.Sprintf("%s-%s", AzureDiskDriverName, azureSource.DiskName),
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				CSI: &v1.CSIPersistentVolumeSource{
+					Driver:           AzureDiskDriverName,
+					VolumeHandle:     azureSource.DataDiskURI,
+					VolumeAttributes: map[string]string{azureDiskKind: "Managed"},
+				},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+		},
+	}
+	if azureSource.ReadOnly != nil {
+		pv.Spec.PersistentVolumeSource.CSI.ReadOnly = *azureSource.ReadOnly
+	}
+
+	if azureSource.CachingMode != nil && *azureSource.CachingMode != "" {
+		pv.Spec.PersistentVolumeSource.CSI.VolumeAttributes[azureDiskCachingMode] = string(*azureSource.CachingMode)
+	}
+	if azureSource.FSType != nil {
+		pv.Spec.PersistentVolumeSource.CSI.FSType = *azureSource.FSType
+		pv.Spec.PersistentVolumeSource.CSI.VolumeAttributes[azureDiskFSType] = *azureSource.FSType
+	}
+	if azureSource.Kind != nil {
+		pv.Spec.PersistentVolumeSource.CSI.VolumeAttributes[azureDiskKind] = string(*azureSource.Kind)
+	}
+
+	return pv, nil
+}
+
+// TranslateInTreePVToCSI takes a PV with AzureDisk set from in-tree
+// and converts the AzureDisk source to a CSIPersistentVolumeSource
+func (t *azureDiskCSITranslator) TranslateInTreePVToCSI(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.AzureDisk == nil {
+		return nil, fmt.Errorf("pv is nil or Azure Disk source not defined on pv")
+	}
+
+	azureSource := pv.Spec.PersistentVolumeSource.AzureDisk
+
+	// refer to https://github.com/kubernetes-sigs/azuredisk-csi-driver/blob/master/docs/driver-parameters.md
+	csiSource := &v1.CSIPersistentVolumeSource{
+		Driver:           AzureDiskDriverName,
+		VolumeHandle:     azureSource.DataDiskURI,
+		ReadOnly:         *azureSource.ReadOnly,
+		FSType:           *azureSource.FSType,
+		VolumeAttributes: map[string]string{azureDiskKind: "Managed"},
+	}
+
+	if azureSource.CachingMode != nil {
+		csiSource.VolumeAttributes[azureDiskCachingMode] = string(*azureSource.CachingMode)
+	}
+
+	if azureSource.FSType != nil {
+		csiSource.VolumeAttributes[azureDiskFSType] = *azureSource.FSType
+	}
+
+	if azureSource.Kind != nil {
+		csiSource.VolumeAttributes[azureDiskKind] = string(*azureSource.Kind)
+	}
+
+	pv.Spec.PersistentVolumeSource.AzureDisk = nil
+	pv.Spec.PersistentVolumeSource.CSI = csiSource
+	pv.Spec.AccessModes = backwardCompatibleAccessModes(pv.Spec.AccessModes)
+
+	return pv, nil
+}
+
+// TranslateCSIPVToInTree takes a PV with CSIPersistentVolumeSource set and
+// translates the Azure Disk CSI source to a AzureDisk source.
+func (t *azureDiskCSITranslator) TranslateCSIPVToInTree(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.CSI == nil {
+		return nil, fmt.Errorf("pv is nil or CSI source not defined on pv")
+	}
+	csiSource := pv.Spec.CSI
+
+	diskURI := csiSource.VolumeHandle
+	diskName, err := getDiskName(diskURI)
+	if err != nil {
+		return nil, err
+	}
+
+	// refer to https://github.com/kubernetes-sigs/azuredisk-csi-driver/blob/master/docs/driver-parameters.md
+	managed := v1.AzureManagedDisk
+	azureSource := &v1.AzureDiskVolumeSource{
+		DiskName:    diskName,
+		DataDiskURI: diskURI,
+		FSType:      &csiSource.FSType,
+		ReadOnly:    &csiSource.ReadOnly,
+		Kind:        &managed,
+	}
+
+	if csiSource.VolumeAttributes != nil {
+		if cachingMode, ok := csiSource.VolumeAttributes[azureDiskCachingMode]; ok {
+			mode := v1.AzureDataDiskCachingMode(cachingMode)
+			azureSource.CachingMode = &mode
+		}
+
+		if fsType, ok := csiSource.VolumeAttributes[azureDiskFSType]; ok && fsType != "" {
+			azureSource.FSType = &fsType
+		}
+
+		if kind, ok := csiSource.VolumeAttributes[azureDiskKind]; ok && kind != "" {
+			diskKind := v1.AzureDataDiskKind(kind)
+			azureSource.Kind = &diskKind
+		}
+	}
+
+	pv.Spec.CSI = nil
+	pv.Spec.AzureDisk = azureSource
+
+	return pv, nil
+}
+
+// CanSupport tests whether the plugin supports a given volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *azureDiskCSITranslator) CanSupport(pv *v1.PersistentVolume) bool {
+	return pv != nil && pv.Spec.AzureDisk != nil
+}
+
+// CanSupportInline tests whether the plugin supports a given inline volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *azureDiskCSITranslator) CanSupportInline(volume *v1.Volume) bool {
+	return volume != nil && volume.AzureDisk != nil
+}
+
+// GetInTreePluginName returns the name of the intree plugin driver
+func (t *azureDiskCSITranslator) GetInTreePluginName() string {
+	return AzureDiskInTreePluginName
+}
+
+// GetCSIPluginName returns the name of the CSI plugin
+func (t *azureDiskCSITranslator) GetCSIPluginName() string {
+	return AzureDiskDriverName
+}
+
+func (t *azureDiskCSITranslator) RepairVolumeHandle(volumeHandle, nodeID string) (string, error) {
+	return volumeHandle, nil
+}
+
+func isManagedDisk(diskURI string) bool {
+	if len(diskURI) > 4 && strings.ToLower(diskURI[:4]) == "http" {
+		return false
+	}
+	return true
+}
+
+func getDiskName(diskURI string) (string, error) {
+	diskPathRE := managedDiskPathRE
+	if !isManagedDisk(diskURI) {
+		diskPathRE = unmanagedDiskPathRE
+	}
+
+	matches := diskPathRE.FindStringSubmatch(diskURI)
+	if len(matches) != 2 {
+		return "", fmt.Errorf("could not get disk name from %s, correct format: %s", diskURI, diskPathRE)
+	}
+	return matches[1], nil
+}

vendor/k8s.io/csi-translation-lib/plugins/azure_file.go

@@ -0,0 +1,193 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package plugins
+
+import (
+	"fmt"
+	"strings"
+
+	v1 "k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	// AzureFileDriverName is the name of the CSI driver for Azure File
+	AzureFileDriverName = "file.csi.azure.com"
+	// AzureFileInTreePluginName is the name of the intree plugin for Azure file
+	AzureFileInTreePluginName = "kubernetes.io/azure-file"
+
+	separator        = "#"
+	volumeIDTemplate = "%s#%s#%s"
+	// Parameter names defined in azure file CSI driver, refer to
+	// https://github.com/kubernetes-sigs/azurefile-csi-driver/blob/master/docs/driver-parameters.md
+	azureFileShareName = "shareName"
+)
+
+var _ InTreePlugin = &azureFileCSITranslator{}
+
+// azureFileCSITranslator handles translation of PV spec from In-tree
+// Azure File to CSI Azure File and vice versa
+type azureFileCSITranslator struct{}
+
+// NewAzureFileCSITranslator returns a new instance of azureFileTranslator
+func NewAzureFileCSITranslator() InTreePlugin {
+	return &azureFileCSITranslator{}
+}
+
+// TranslateInTreeStorageClassParametersToCSI translates InTree Azure File storage class parameters to CSI storage class
+func (t *azureFileCSITranslator) TranslateInTreeStorageClassToCSI(sc *storage.StorageClass) (*storage.StorageClass, error) {
+	return sc, nil
+}
+
+// TranslateInTreeInlineVolumeToCSI takes a Volume with AzureFile set from in-tree
+// and converts the AzureFile source to a CSIPersistentVolumeSource
+func (t *azureFileCSITranslator) TranslateInTreeInlineVolumeToCSI(volume *v1.Volume) (*v1.PersistentVolume, error) {
+	if volume == nil || volume.AzureFile == nil {
+		return nil, fmt.Errorf("volume is nil or AWS EBS not defined on volume")
+	}
+
+	azureSource := volume.AzureFile
+
+	pv := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			// Must be unique per disk as it is used as the unique part of the
+			// staging path
+			Name: fmt.Sprintf("%s-%s", AzureFileDriverName, azureSource.ShareName),
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				CSI: &v1.CSIPersistentVolumeSource{
+					VolumeHandle:     fmt.Sprintf(volumeIDTemplate, "", azureSource.SecretName, azureSource.ShareName),
+					ReadOnly:         azureSource.ReadOnly,
+					VolumeAttributes: map[string]string{azureFileShareName: azureSource.ShareName},
+					NodePublishSecretRef: &v1.SecretReference{
+						Name:      azureSource.ShareName,
+						Namespace: "default",
+					},
+				},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteMany},
+		},
+	}
+	return pv, nil
+}
+
+// TranslateInTreePVToCSI takes a PV with AzureFile set from in-tree
+// and converts the AzureFile source to a CSIPersistentVolumeSource
+func (t *azureFileCSITranslator) TranslateInTreePVToCSI(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.AzureFile == nil {
+		return nil, fmt.Errorf("pv is nil or Azure File source not defined on pv")
+	}
+
+	azureSource := pv.Spec.PersistentVolumeSource.AzureFile
+
+	volumeID := fmt.Sprintf(volumeIDTemplate, "", azureSource.SecretName, azureSource.ShareName)
+	// refer to https://github.com/kubernetes-sigs/azurefile-csi-driver/blob/master/docs/driver-parameters.md
+	csiSource := &v1.CSIPersistentVolumeSource{
+		VolumeHandle:     volumeID,
+		ReadOnly:         azureSource.ReadOnly,
+		VolumeAttributes: map[string]string{azureFileShareName: azureSource.ShareName},
+	}
+
+	csiSource.NodePublishSecretRef = &v1.SecretReference{
+		Name:      azureSource.ShareName,
+		Namespace: *azureSource.SecretNamespace,
+	}
+
+	pv.Spec.PersistentVolumeSource.AzureFile = nil
+	pv.Spec.PersistentVolumeSource.CSI = csiSource
+	pv.Spec.AccessModes = backwardCompatibleAccessModes(pv.Spec.AccessModes)
+
+	return pv, nil
+}
+
+// TranslateCSIPVToInTree takes a PV with CSIPersistentVolumeSource set and
+// translates the Azure File CSI source to a AzureFile source.
+func (t *azureFileCSITranslator) TranslateCSIPVToInTree(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.CSI == nil {
+		return nil, fmt.Errorf("pv is nil or CSI source not defined on pv")
+	}
+	csiSource := pv.Spec.CSI
+
+	// refer to https://github.com/kubernetes-sigs/azurefile-csi-driver/blob/master/docs/driver-parameters.md
+	azureSource := &v1.AzureFilePersistentVolumeSource{
+		ReadOnly: csiSource.ReadOnly,
+	}
+
+	if csiSource.NodePublishSecretRef != nil && csiSource.NodePublishSecretRef.Name != "" {
+		azureSource.SecretName = csiSource.NodePublishSecretRef.Name
+		azureSource.SecretNamespace = &csiSource.NodePublishSecretRef.Namespace
+		if csiSource.VolumeAttributes != nil {
+			if shareName, ok := csiSource.VolumeAttributes[azureFileShareName]; ok {
+				azureSource.ShareName = shareName
+			}
+		}
+	} else {
+		_, _, fileShareName, err := getFileShareInfo(csiSource.VolumeHandle)
+		if err != nil {
+			return nil, err
+		}
+		azureSource.ShareName = fileShareName
+		// to-do: for dynamic provision scenario in CSI, it uses cluster's identity to get storage account key
+		// secret for the file share is not created, we may create a serect here
+	}
+
+	pv.Spec.CSI = nil
+	pv.Spec.AzureFile = azureSource
+
+	return pv, nil
+}
+
+// CanSupport tests whether the plugin supports a given volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *azureFileCSITranslator) CanSupport(pv *v1.PersistentVolume) bool {
+	return pv != nil && pv.Spec.AzureFile != nil
+}
+
+// CanSupportInline tests whether the plugin supports a given inline volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *azureFileCSITranslator) CanSupportInline(volume *v1.Volume) bool {
+	return volume != nil && volume.AzureFile != nil
+}
+
+// GetInTreePluginName returns the name of the intree plugin driver
+func (t *azureFileCSITranslator) GetInTreePluginName() string {
+	return AzureFileInTreePluginName
+}
+
+// GetCSIPluginName returns the name of the CSI plugin
+func (t *azureFileCSITranslator) GetCSIPluginName() string {
+	return AzureFileDriverName
+}
+
+func (t *azureFileCSITranslator) RepairVolumeHandle(volumeHandle, nodeID string) (string, error) {
+	return volumeHandle, nil
+}
+
+// get file share info according to volume id, e.g.
+// input: "rg#f5713de20cde511e8ba4900#pvc-file-dynamic-17e43f84-f474-11e8-acd0-000d3a00df41"
+// output: rg, f5713de20cde511e8ba4900, pvc-file-dynamic-17e43f84-f474-11e8-acd0-000d3a00df41
+func getFileShareInfo(id string) (string, string, string, error) {
+	segments := strings.Split(id, separator)
+	if len(segments) < 3 {
+		return "", "", "", fmt.Errorf("error parsing volume id: %q, should at least contain two #", id)
+	}
+	return segments[0], segments[1], segments[2], nil
+}

vendor/k8s.io/csi-translation-lib/plugins/gce_pd.go

@@ -0,0 +1,392 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package plugins
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	v1 "k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	cloudvolume "k8s.io/cloud-provider/volume"
+)
+
+const (
+	// GCEPDDriverName is the name of the CSI driver for GCE PD
+	GCEPDDriverName = "pd.csi.storage.gke.io"
+	// GCEPDInTreePluginName is the name of the intree plugin for GCE PD
+	GCEPDInTreePluginName = "kubernetes.io/gce-pd"
+
+	// GCEPDTopologyKey is the zonal topology key for GCE PD CSI Driver
+	GCEPDTopologyKey = "topology.gke.io/zone"
+
+	// Volume ID Expected Format
+	// "projects/{projectName}/zones/{zoneName}/disks/{diskName}"
+	volIDZonalFmt = "projects/%s/zones/%s/disks/%s"
+	// "projects/{projectName}/regions/{regionName}/disks/{diskName}"
+	volIDRegionalFmt      = "projects/%s/regions/%s/disks/%s"
+	volIDProjectValue     = 1
+	volIDRegionalityValue = 2
+	volIDZoneValue        = 3
+	volIDDiskNameValue    = 5
+	volIDTotalElements    = 6
+
+	nodeIDFmt = "projects/%s/zones/%s/instances/%s"
+
+	// UnspecifiedValue is used for an unknown zone string
+	UnspecifiedValue = "UNSPECIFIED"
+)
+
+var _ InTreePlugin = &gcePersistentDiskCSITranslator{}
+
+// gcePersistentDiskCSITranslator handles translation of PV spec from In-tree
+// GCE PD to CSI GCE PD and vice versa
+type gcePersistentDiskCSITranslator struct{}
+
+// NewGCEPersistentDiskCSITranslator returns a new instance of gcePersistentDiskTranslator
+func NewGCEPersistentDiskCSITranslator() InTreePlugin {
+	return &gcePersistentDiskCSITranslator{}
+}
+
+func generateToplogySelectors(key string, values []string) []v1.TopologySelectorTerm {
+	return []v1.TopologySelectorTerm{
+		{
+			MatchLabelExpressions: []v1.TopologySelectorLabelRequirement{
+				{
+					Key:    key,
+					Values: values,
+				},
+			},
+		},
+	}
+}
+
+// TranslateInTreeStorageClassParametersToCSI translates InTree GCE storage class parameters to CSI storage class
+func (g *gcePersistentDiskCSITranslator) TranslateInTreeStorageClassToCSI(sc *storage.StorageClass) (*storage.StorageClass, error) {
+	var generatedTopologies []v1.TopologySelectorTerm
+
+	np := map[string]string{}
+	for k, v := range sc.Parameters {
+		switch strings.ToLower(k) {
+		case fsTypeKey:
+			// prefixed fstype parameter is stripped out by external provisioner
+			np[csiFsTypeKey] = v
+		// Strip out zone and zones parameters and translate them into topologies instead
+		case zoneKey:
+			generatedTopologies = generateToplogySelectors(GCEPDTopologyKey, []string{v})
+		case zonesKey:
+			generatedTopologies = generateToplogySelectors(GCEPDTopologyKey, strings.Split(v, ","))
+		default:
+			np[k] = v
+		}
+	}
+
+	if len(generatedTopologies) > 0 && len(sc.AllowedTopologies) > 0 {
+		return nil, fmt.Errorf("cannot simultaneously set allowed topologies and zone/zones parameters")
+	} else if len(generatedTopologies) > 0 {
+		sc.AllowedTopologies = generatedTopologies
+	} else if len(sc.AllowedTopologies) > 0 {
+		newTopologies, err := translateAllowedTopologies(sc.AllowedTopologies, GCEPDTopologyKey)
+		if err != nil {
+			return nil, fmt.Errorf("failed translating allowed topologies: %v", err)
+		}
+		sc.AllowedTopologies = newTopologies
+	}
+
+	sc.Parameters = np
+
+	return sc, nil
+}
+
+// backwardCompatibleAccessModes translates all instances of ReadWriteMany
+// access mode from the in-tree plugin to ReadWriteOnce. This is because in-tree
+// plugin never supported ReadWriteMany but also did not validate or enforce
+// this access mode for pre-provisioned volumes. The GCE PD CSI Driver validates
+// and enforces (fails) ReadWriteMany. Therefore we treat all in-tree
+// ReadWriteMany as ReadWriteOnce volumes to not break legacy volumes. It also
+// takes [ReadWriteOnce, ReadOnlyMany] and makes it ReadWriteOnce. This is
+// because the in-tree plugin does not enforce access modes and just attaches
+// the disk in ReadWriteOnce mode; however, the CSI external-attacher will fail
+// this combination because technically [ReadWriteOnce, ReadOnlyMany] is not
+// supportable on an attached volume
+// See: https://github.com/kubernetes-csi/external-attacher/issues/153
+func backwardCompatibleAccessModes(ams []v1.PersistentVolumeAccessMode) []v1.PersistentVolumeAccessMode {
+	if ams == nil {
+		return nil
+	}
+
+	s := map[v1.PersistentVolumeAccessMode]bool{}
+	var newAM []v1.PersistentVolumeAccessMode
+
+	for _, am := range ams {
+		if am == v1.ReadWriteMany {
+			// ReadWriteMany is unsupported in CSI, but in-tree did no
+			// validation and treated it as ReadWriteOnce
+			s[v1.ReadWriteOnce] = true
+		} else {
+			s[am] = true
+		}
+	}
+
+	switch {
+	case s[v1.ReadOnlyMany] && s[v1.ReadWriteOnce]:
+		// ROX,RWO is unsupported in CSI, but in-tree did not validation and
+		// treated it as ReadWriteOnce
+		newAM = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+	case s[v1.ReadWriteOnce]:
+		newAM = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+	case s[v1.ReadOnlyMany]:
+		newAM = []v1.PersistentVolumeAccessMode{v1.ReadOnlyMany}
+	default:
+		newAM = []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}
+	}
+
+	return newAM
+}
+
+// TranslateInTreeInlineVolumeToCSI takes a Volume with GCEPersistentDisk set from in-tree
+// and converts the GCEPersistentDisk source to a CSIPersistentVolumeSource
+func (g *gcePersistentDiskCSITranslator) TranslateInTreeInlineVolumeToCSI(volume *v1.Volume) (*v1.PersistentVolume, error) {
+	if volume == nil || volume.GCEPersistentDisk == nil {
+		return nil, fmt.Errorf("volume is nil or GCE PD not defined on volume")
+	}
+
+	pdSource := volume.GCEPersistentDisk
+
+	partition := ""
+	if pdSource.Partition != 0 {
+		partition = strconv.Itoa(int(pdSource.Partition))
+	}
+
+	var am v1.PersistentVolumeAccessMode
+	if pdSource.ReadOnly {
+		am = v1.ReadOnlyMany
+	} else {
+		am = v1.ReadWriteOnce
+	}
+
+	fsMode := v1.PersistentVolumeFilesystem
+	return &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			// Must be unique per disk as it is used as the unique part of the
+			// staging path
+			Name: fmt.Sprintf("%s-%s", GCEPDDriverName, pdSource.PDName),
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				CSI: &v1.CSIPersistentVolumeSource{
+					Driver:       GCEPDDriverName,
+					VolumeHandle: fmt.Sprintf(volIDZonalFmt, UnspecifiedValue, UnspecifiedValue, pdSource.PDName),
+					ReadOnly:     pdSource.ReadOnly,
+					FSType:       pdSource.FSType,
+					VolumeAttributes: map[string]string{
+						"partition": partition,
+					},
+				},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{am},
+			VolumeMode:  &fsMode,
+		},
+	}, nil
+}
+
+// TranslateInTreePVToCSI takes a PV with GCEPersistentDisk set from in-tree
+// and converts the GCEPersistentDisk source to a CSIPersistentVolumeSource
+func (g *gcePersistentDiskCSITranslator) TranslateInTreePVToCSI(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	var volID string
+
+	if pv == nil || pv.Spec.GCEPersistentDisk == nil {
+		return nil, fmt.Errorf("pv is nil or GCE Persistent Disk source not defined on pv")
+	}
+
+	zonesLabel := pv.Labels[v1.LabelZoneFailureDomain]
+	zones := strings.Split(zonesLabel, cloudvolume.LabelMultiZoneDelimiter)
+	if len(zones) == 1 && len(zones[0]) != 0 {
+		// Zonal
+		volID = fmt.Sprintf(volIDZonalFmt, UnspecifiedValue, zones[0], pv.Spec.GCEPersistentDisk.PDName)
+	} else if len(zones) > 1 {
+		// Regional
+		region, err := getRegionFromZones(zones)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get region from zones: %v", err)
+		}
+		volID = fmt.Sprintf(volIDZonalFmt, UnspecifiedValue, region, pv.Spec.GCEPersistentDisk.PDName)
+	} else {
+		// Unspecified
+		volID = fmt.Sprintf(volIDZonalFmt, UnspecifiedValue, UnspecifiedValue, pv.Spec.GCEPersistentDisk.PDName)
+	}
+
+	gceSource := pv.Spec.PersistentVolumeSource.GCEPersistentDisk
+
+	partition := ""
+	if gceSource.Partition != 0 {
+		partition = strconv.Itoa(int(gceSource.Partition))
+	}
+
+	csiSource := &v1.CSIPersistentVolumeSource{
+		Driver:       GCEPDDriverName,
+		VolumeHandle: volID,
+		ReadOnly:     gceSource.ReadOnly,
+		FSType:       gceSource.FSType,
+		VolumeAttributes: map[string]string{
+			"partition": partition,
+		},
+	}
+
+	if err := translateTopology(pv, GCEPDTopologyKey); err != nil {
+		return nil, fmt.Errorf("failed to translate topology: %v", err)
+	}
+
+	pv.Spec.PersistentVolumeSource.GCEPersistentDisk = nil
+	pv.Spec.PersistentVolumeSource.CSI = csiSource
+	pv.Spec.AccessModes = backwardCompatibleAccessModes(pv.Spec.AccessModes)
+
+	return pv, nil
+}
+
+// TranslateCSIPVToInTree takes a PV with CSIPersistentVolumeSource set and
+// translates the GCE PD CSI source to a GCEPersistentDisk source.
+func (g *gcePersistentDiskCSITranslator) TranslateCSIPVToInTree(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.CSI == nil {
+		return nil, fmt.Errorf("pv is nil or CSI source not defined on pv")
+	}
+	csiSource := pv.Spec.CSI
+
+	pdName, err := pdNameFromVolumeID(csiSource.VolumeHandle)
+	if err != nil {
+		return nil, err
+	}
+
+	gceSource := &v1.GCEPersistentDiskVolumeSource{
+		PDName:   pdName,
+		FSType:   csiSource.FSType,
+		ReadOnly: csiSource.ReadOnly,
+	}
+	if partition, ok := csiSource.VolumeAttributes["partition"]; ok && partition != "" {
+		partInt, err := strconv.Atoi(partition)
+		if err != nil {
+			return nil, fmt.Errorf("Failed to convert partition %v to integer: %v", partition, err)
+		}
+		gceSource.Partition = int32(partInt)
+	}
+
+	// TODO: Take the zone/regional information and stick it into the label.
+
+	pv.Spec.CSI = nil
+	pv.Spec.GCEPersistentDisk = gceSource
+
+	return pv, nil
+}
+
+// CanSupport tests whether the plugin supports a given persistent volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (g *gcePersistentDiskCSITranslator) CanSupport(pv *v1.PersistentVolume) bool {
+	return pv != nil && pv.Spec.GCEPersistentDisk != nil
+}
+
+// CanSupportInline tests whether the plugin supports a given inline volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (g *gcePersistentDiskCSITranslator) CanSupportInline(volume *v1.Volume) bool {
+	return volume != nil && volume.GCEPersistentDisk != nil
+}
+
+// GetInTreePluginName returns the name of the intree plugin driver
+func (g *gcePersistentDiskCSITranslator) GetInTreePluginName() string {
+	return GCEPDInTreePluginName
+}
+
+// GetCSIPluginName returns the name of the CSI plugin
+func (g *gcePersistentDiskCSITranslator) GetCSIPluginName() string {
+	return GCEPDDriverName
+}
+
+// RepairVolumeHandle returns a fully specified volume handle by inferring
+// project, zone/region from the node ID if the volume handle has UNSPECIFIED
+// sections
+func (g *gcePersistentDiskCSITranslator) RepairVolumeHandle(volumeHandle, nodeID string) (string, error) {
+	var err error
+	tok := strings.Split(volumeHandle, "/")
+	if len(tok) < volIDTotalElements {
+		return "", fmt.Errorf("volume handle has wrong number of elements; got %v, wanted %v or more", len(tok), volIDTotalElements)
+	}
+	if tok[volIDProjectValue] != UnspecifiedValue {
+		return volumeHandle, nil
+	}
+
+	nodeTok := strings.Split(nodeID, "/")
+	if len(nodeTok) < volIDTotalElements {
+		return "", fmt.Errorf("node handle has wrong number of elements; got %v, wanted %v or more", len(nodeTok), volIDTotalElements)
+	}
+
+	switch tok[volIDRegionalityValue] {
+	case "zones":
+		zone := ""
+		if tok[volIDZoneValue] == UnspecifiedValue {
+			zone = nodeTok[volIDZoneValue]
+		} else {
+			zone = tok[volIDZoneValue]
+		}
+		return fmt.Sprintf(volIDZonalFmt, nodeTok[volIDProjectValue], zone, tok[volIDDiskNameValue]), nil
+	case "regions":
+		region := ""
+		if tok[volIDZoneValue] == UnspecifiedValue {
+			region, err = getRegionFromZones([]string{nodeTok[volIDZoneValue]})
+			if err != nil {
+				return "", fmt.Errorf("failed to get region from zone %s: %v", nodeTok[volIDZoneValue], err)
+			}
+		} else {
+			region = tok[volIDZoneValue]
+		}
+		return fmt.Sprintf(volIDRegionalFmt, nodeTok[volIDProjectValue], region, tok[volIDDiskNameValue]), nil
+	default:
+		return "", fmt.Errorf("expected volume handle to have zones or regions regionality value, got: %s", tok[volIDRegionalityValue])
+	}
+}
+
+func pdNameFromVolumeID(id string) (string, error) {
+	splitID := strings.Split(id, "/")
+	if len(splitID) < volIDTotalElements {
+		return "", fmt.Errorf("failed to get id components.Got: %v, wanted %v components or more. ", len(splitID), volIDTotalElements)
+	}
+	return splitID[volIDDiskNameValue], nil
+}
+
+// TODO: Replace this with the imported one from GCE PD CSI Driver when
+// the driver removes all k8s/k8s dependencies
+func getRegionFromZones(zones []string) (string, error) {
+	regions := sets.String{}
+	if len(zones) < 1 {
+		return "", fmt.Errorf("no zones specified")
+	}
+	for _, zone := range zones {
+		// Zone expected format {locale}-{region}-{zone}
+		splitZone := strings.Split(zone, "-")
+		if len(splitZone) != 3 {
+			return "", fmt.Errorf("zone in unexpected format, expected: {locale}-{region}-{zone}, got: %v", zone)
+		}
+		regions.Insert(strings.Join(splitZone[0:2], "-"))
+	}
+	if regions.Len() != 1 {
+		return "", fmt.Errorf("multiple or no regions gotten from zones, got: %v", regions)
+	}
+	return regions.UnsortedList()[0], nil
+}

vendor/k8s.io/csi-translation-lib/plugins/in_tree_volume.go

@@ -0,0 +1,196 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package plugins
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	v1 "k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
+	cloudvolume "k8s.io/cloud-provider/volume"
+)
+
+// InTreePlugin handles translations between CSI and in-tree sources in a PV
+type InTreePlugin interface {
+
+	// TranslateInTreeStorageClassToCSI takes in-tree volume options
+	// and translates them to a volume options consumable by CSI plugin
+	TranslateInTreeStorageClassToCSI(sc *storage.StorageClass) (*storage.StorageClass, error)
+
+	// TranslateInTreeInlineVolumeToCSI takes a inline volume and will translate
+	// the in-tree inline volume source to a CSIPersistentVolumeSource
+	// A PV object containing the CSIPersistentVolumeSource in it's spec is returned
+	TranslateInTreeInlineVolumeToCSI(volume *v1.Volume) (*v1.PersistentVolume, error)
+
+	// TranslateInTreePVToCSI takes a persistent volume and will translate
+	// the in-tree pv source to a CSI Source. The input persistent volume can be modified
+	TranslateInTreePVToCSI(pv *v1.PersistentVolume) (*v1.PersistentVolume, error)
+
+	// TranslateCSIPVToInTree takes a PV with a CSI PersistentVolume Source and will translate
+	// it to a in-tree Persistent Volume Source for the in-tree volume
+	// by the `Driver` field in the CSI Source. The input PV object can be modified
+	TranslateCSIPVToInTree(pv *v1.PersistentVolume) (*v1.PersistentVolume, error)
+
+	// CanSupport tests whether the plugin supports a given persistent volume
+	// specification from the API.
+	CanSupport(pv *v1.PersistentVolume) bool
+
+	// CanSupportInline tests whether the plugin supports a given inline volume
+	// specification from the API.
+	CanSupportInline(vol *v1.Volume) bool
+
+	// GetInTreePluginName returns the in-tree plugin name this migrates
+	GetInTreePluginName() string
+
+	// GetCSIPluginName returns the name of the CSI plugin that supersedes the in-tree plugin
+	GetCSIPluginName() string
+
+	// RepairVolumeHandle generates a correct volume handle based on node ID information.
+	RepairVolumeHandle(volumeHandle, nodeID string) (string, error)
+}
+
+const (
+	// fsTypeKey is the deprecated storage class parameter key for fstype
+	fsTypeKey = "fstype"
+	// csiFsTypeKey is the storage class parameter key for CSI fstype
+	csiFsTypeKey = "csi.storage.k8s.io/fstype"
+	// zoneKey is the deprecated storage class parameter key for zone
+	zoneKey = "zone"
+	// zonesKey is the deprecated storage class parameter key for zones
+	zonesKey = "zones"
+)
+
+// replaceTopology overwrites an existing topology key by a new one.
+func replaceTopology(pv *v1.PersistentVolume, oldKey, newKey string) error {
+	for i := range pv.Spec.NodeAffinity.Required.NodeSelectorTerms {
+		for j, r := range pv.Spec.NodeAffinity.Required.NodeSelectorTerms[i].MatchExpressions {
+			if r.Key == oldKey {
+				pv.Spec.NodeAffinity.Required.NodeSelectorTerms[i].MatchExpressions[j].Key = newKey
+			}
+		}
+	}
+	return nil
+}
+
+// getTopologyZones returns all topology zones with the given key found in the PV.
+func getTopologyZones(pv *v1.PersistentVolume, key string) []string {
+	if pv.Spec.NodeAffinity == nil ||
+		pv.Spec.NodeAffinity.Required == nil ||
+		len(pv.Spec.NodeAffinity.Required.NodeSelectorTerms) < 1 {
+		return nil
+	}
+
+	var values []string
+	for i := range pv.Spec.NodeAffinity.Required.NodeSelectorTerms {
+		for _, r := range pv.Spec.NodeAffinity.Required.NodeSelectorTerms[i].MatchExpressions {
+			if r.Key == key {
+				values = append(values, r.Values...)
+			}
+		}
+	}
+	return values
+}
+
+// addTopology appends the topology to the given PV.
+func addTopology(pv *v1.PersistentVolume, topologyKey string, zones []string) error {
+	// Make sure there are no duplicate or empty strings
+	filteredZones := sets.String{}
+	for i := range zones {
+		zone := strings.TrimSpace(zones[i])
+		if len(zone) > 0 {
+			filteredZones.Insert(zone)
+		}
+	}
+
+	zones = filteredZones.UnsortedList()
+	if len(zones) < 1 {
+		return errors.New("there are no valid zones to add to pv")
+	}
+
+	// Make sure the necessary fields exist
+	pv.Spec.NodeAffinity = new(v1.VolumeNodeAffinity)
+	pv.Spec.NodeAffinity.Required = new(v1.NodeSelector)
+	pv.Spec.NodeAffinity.Required.NodeSelectorTerms = make([]v1.NodeSelectorTerm, 1)
+
+	topology := v1.NodeSelectorRequirement{
+		Key:      topologyKey,
+		Operator: v1.NodeSelectorOpIn,
+		Values:   zones,
+	}
+
+	pv.Spec.NodeAffinity.Required.NodeSelectorTerms[0].MatchExpressions = append(
+		pv.Spec.NodeAffinity.Required.NodeSelectorTerms[0].MatchExpressions,
+		topology,
+	)
+
+	return nil
+}
+
+// translateTopology converts existing zone labels or in-tree topology to CSI topology.
+// In-tree topology has precedence over zone labels.
+func translateTopology(pv *v1.PersistentVolume, topologyKey string) error {
+	// If topology is already set, assume the content is accurate
+	if len(getTopologyZones(pv, topologyKey)) > 0 {
+		return nil
+	}
+
+	zones := getTopologyZones(pv, v1.LabelZoneFailureDomain)
+	if len(zones) > 0 {
+		return replaceTopology(pv, v1.LabelZoneFailureDomain, topologyKey)
+	}
+
+	if label, ok := pv.Labels[v1.LabelZoneFailureDomain]; ok {
+		zones = strings.Split(label, cloudvolume.LabelMultiZoneDelimiter)
+		if len(zones) > 0 {
+			return addTopology(pv, topologyKey, zones)
+		}
+	}
+
+	return nil
+}
+
+// translateAllowedTopologies translates allowed topologies within storage class
+// from legacy failure domain to given CSI topology key
+func translateAllowedTopologies(terms []v1.TopologySelectorTerm, key string) ([]v1.TopologySelectorTerm, error) {
+	if terms == nil {
+		return nil, nil
+	}
+
+	newTopologies := []v1.TopologySelectorTerm{}
+	for _, term := range terms {
+		newTerm := v1.TopologySelectorTerm{}
+		for _, exp := range term.MatchLabelExpressions {
+			var newExp v1.TopologySelectorLabelRequirement
+			if exp.Key == v1.LabelZoneFailureDomain {
+				newExp = v1.TopologySelectorLabelRequirement{
+					Key:    key,
+					Values: exp.Values,
+				}
+			} else if exp.Key == key {
+				newExp = exp
+			} else {
+				return nil, fmt.Errorf("unknown topology key: %v", exp.Key)
+			}
+			newTerm.MatchLabelExpressions = append(newTerm.MatchLabelExpressions, newExp)
+		}
+		newTopologies = append(newTopologies, newTerm)
+	}
+	return newTopologies, nil
+}

vendor/k8s.io/csi-translation-lib/plugins/openstack_cinder.go

@@ -0,0 +1,153 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package plugins
+
+import (
+	"fmt"
+
+	v1 "k8s.io/api/core/v1"
+	storage "k8s.io/api/storage/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	// CinderDriverName is the name of the CSI driver for Cinder
+	CinderDriverName = "cinder.csi.openstack.org"
+	// CinderTopologyKey is the zonal topology key for Cinder CSI Driver
+	CinderTopologyKey = "topology.cinder.csi.openstack.org/zone"
+	// CinderInTreePluginName is the name of the intree plugin for Cinder
+	CinderInTreePluginName = "kubernetes.io/cinder"
+)
+
+var _ InTreePlugin = (*osCinderCSITranslator)(nil)
+
+// osCinderCSITranslator handles translation of PV spec from In-tree Cinder to CSI Cinder and vice versa
+type osCinderCSITranslator struct{}
+
+// NewOpenStackCinderCSITranslator returns a new instance of osCinderCSITranslator
+func NewOpenStackCinderCSITranslator() InTreePlugin {
+	return &osCinderCSITranslator{}
+}
+
+// TranslateInTreeStorageClassParametersToCSI translates InTree Cinder storage class parameters to CSI storage class
+func (t *osCinderCSITranslator) TranslateInTreeStorageClassToCSI(sc *storage.StorageClass) (*storage.StorageClass, error) {
+	return sc, nil
+}
+
+// TranslateInTreeInlineVolumeToCSI takes a Volume with Cinder set from in-tree
+// and converts the Cinder source to a CSIPersistentVolumeSource
+func (t *osCinderCSITranslator) TranslateInTreeInlineVolumeToCSI(volume *v1.Volume) (*v1.PersistentVolume, error) {
+	if volume == nil || volume.Cinder == nil {
+		return nil, fmt.Errorf("volume is nil or Cinder not defined on volume")
+	}
+
+	cinderSource := volume.Cinder
+	pv := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			// Must be unique per disk as it is used as the unique part of the
+			// staging path
+			Name: fmt.Sprintf("%s-%s", CinderDriverName, cinderSource.VolumeID),
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				CSI: &v1.CSIPersistentVolumeSource{
+					Driver:           CinderDriverName,
+					VolumeHandle:     cinderSource.VolumeID,
+					ReadOnly:         cinderSource.ReadOnly,
+					FSType:           cinderSource.FSType,
+					VolumeAttributes: map[string]string{},
+				},
+			},
+			AccessModes: []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce},
+		},
+	}
+	return pv, nil
+}
+
+// TranslateInTreePVToCSI takes a PV with Cinder set from in-tree
+// and converts the Cinder source to a CSIPersistentVolumeSource
+func (t *osCinderCSITranslator) TranslateInTreePVToCSI(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.Cinder == nil {
+		return nil, fmt.Errorf("pv is nil or Cinder not defined on pv")
+	}
+
+	cinderSource := pv.Spec.Cinder
+
+	csiSource := &v1.CSIPersistentVolumeSource{
+		Driver:           CinderDriverName,
+		VolumeHandle:     cinderSource.VolumeID,
+		ReadOnly:         cinderSource.ReadOnly,
+		FSType:           cinderSource.FSType,
+		VolumeAttributes: map[string]string{},
+	}
+
+	if err := translateTopology(pv, CinderTopologyKey); err != nil {
+		return nil, fmt.Errorf("failed to translate topology: %v", err)
+	}
+
+	pv.Spec.Cinder = nil
+	pv.Spec.CSI = csiSource
+	return pv, nil
+}
+
+// TranslateCSIPVToInTree takes a PV with CSIPersistentVolumeSource set and
+// translates the Cinder CSI source to a Cinder In-tree source.
+func (t *osCinderCSITranslator) TranslateCSIPVToInTree(pv *v1.PersistentVolume) (*v1.PersistentVolume, error) {
+	if pv == nil || pv.Spec.CSI == nil {
+		return nil, fmt.Errorf("pv is nil or CSI source not defined on pv")
+	}
+
+	csiSource := pv.Spec.CSI
+
+	cinderSource := &v1.CinderPersistentVolumeSource{
+		VolumeID: csiSource.VolumeHandle,
+		FSType:   csiSource.FSType,
+		ReadOnly: csiSource.ReadOnly,
+	}
+
+	pv.Spec.CSI = nil
+	pv.Spec.Cinder = cinderSource
+	return pv, nil
+}
+
+// CanSupport tests whether the plugin supports a given persistent volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *osCinderCSITranslator) CanSupport(pv *v1.PersistentVolume) bool {
+	return pv != nil && pv.Spec.Cinder != nil
+}
+
+// CanSupportInline tests whether the plugin supports a given inline volume
+// specification from the API.  The spec pointer should be considered
+// const.
+func (t *osCinderCSITranslator) CanSupportInline(volume *v1.Volume) bool {
+	return volume != nil && volume.Cinder != nil
+}
+
+// GetInTreePluginName returns the name of the intree plugin driver
+func (t *osCinderCSITranslator) GetInTreePluginName() string {
+	return CinderInTreePluginName
+}
+
+// GetCSIPluginName returns the name of the CSI plugin
+func (t *osCinderCSITranslator) GetCSIPluginName() string {
+	return CinderDriverName
+}
+
+func (t *osCinderCSITranslator) RepairVolumeHandle(volumeHandle, nodeID string) (string, error) {
+	return volumeHandle, nil
+}