Storage type used to dispatch custom logic

Author: Harvey Lowndes

pkg/provisioner/block/block.go

@@ -41,7 +41,16 @@ const (
 	ociVolumeID            = "ociVolumeID"
 	ociVolumeBackupID      = "volume.beta.kubernetes.io/oci-volume-source"
 	volumePrefixEnvVarName = "OCI_VOLUME_NAME_PREFIX"
-	fsType                 = "fsType"
+
+	typeParameter    = "type"
+	fsTypeParameter  = "fsType"
+	blockStorageType = "blockStorage"
+	defaultType      = blockStorageType
+	defaultFsType    = "ext4"
+)
+
+var (
+	validFsTypes = [2]string{"ext3", "ext4"}
 )
 
 // blockProvisioner is the internal provisioner for OCI block volumes
@@ -68,12 +77,33 @@ func mapVolumeIDToName(volumeID string) string {
 	return strings.Split(volumeID, ".")[4]
 }
 
-func resolveFSType(options controller.VolumeOptions) string {
-	fs := "ext4" // default to ext4
-	if fsType, ok := options.Parameters[fsType]; ok {
+func resolveStorageType(options controller.VolumeOptions) string {
+	t := defaultType
+	if sType, ok := options.Parameters[typeParameter]; ok {
+		t = sType
+	}
+	return t
+}
+
+func resolveFSType(options controller.VolumeOptions) (string, error) {
+	fs := defaultFsType
+	if fsType, ok := options.Parameters[fsTypeParameter]; ok {
 		fs = fsType
 	}
-	return fs
+	err := validateFSType(fs)
+	if err != nil {
+		return "", err
+	}
+	return fs, nil
+}
+
+func validateFSType(fsType string) error {
+	for _, f := range validFsTypes {
+		if f == fsType {
+			return nil
+		}
+	}
+	return fmt.Errorf("invalid fsType value '%s'", fsType)
 }
 
 func roundUpSize(volumeSizeBytes int64, allocationUnitBytes int64) int64 {
@@ -132,7 +162,7 @@ func (block *blockProvisioner) Provision(options controller.VolumeOptions, ad *i
 		return nil, err
 	}
 
-	filesystemType := resolveFSType(options)
+	storageType := resolveStorageType(options)
 
 	region, ok := os.LookupEnv("OCI_SHORT_REGION")
 	if !ok {
@@ -162,13 +192,22 @@ func (block *blockProvisioner) Provision(options controller.VolumeOptions, ad *i
 			},
 			PersistentVolumeSource: v1.PersistentVolumeSource{
 				FlexVolume: &v1.FlexVolumeSource{
-					Driver: plugin.OCIProvisionerName,
-					FSType: filesystemType,
+					Driver:  plugin.OCIProvisionerName,
+					Options: map[string]string{typeParameter: storageType},
 				},
 			},
 		},
 	}
 
+	// FsType only concerns blockStorage volumes
+	if pv.Spec.PersistentVolumeSource.FlexVolume.Options[typeParameter] == "blockStorage" {
+		filesystemType, err := resolveFSType(options)
+		if err != nil {
+			return nil, err
+		}
+		pv.Spec.PersistentVolumeSource.FlexVolume.FSType = filesystemType
+	}
+
 	return pv, nil
 }
 

pkg/provisioner/block/block_test.go

@@ -37,19 +37,35 @@ var (
 	defaultAD      = identity.AvailabilityDomain{Name: common.String("PHX-AD-1"), CompartmentId: common.String("ocid1.compartment.oc1")}
 )
 
+func TestValidateFsType(t *testing.T) {
+	err := validateFSType("ext3")
+	if err != nil {
+		t.Fatalf("Unexpected validation error for fsType: '%s'", "ext3")
+	}
+	err = validateFSType("ext4")
+	if err != nil {
+		t.Fatalf("Unexpected validation error for fsType: '%s'", "ext4")
+	}
+	err = validateFSType("abc3")
+	if err == nil {
+		t.Fatalf("Unexpected validation pass for fsType: '%s'", "abc3")
+	}
+}
+
 func TestResolveFSTypeWhenNotConfigured(t *testing.T) {
 	options := controller.VolumeOptions{Parameters: make(map[string]string)}
 	// test default fsType of 'ext4' is always returned.
-	fst := resolveFSType(options)
+	fst, _ := resolveFSType(options)
 	if fst != "ext4" {
 		t.Fatalf("Unexpected filesystem type: '%s'.", fst)
 	}
 }
 
 func TestResolveFSTypeWhenConfigured(t *testing.T) {
 	// test default fsType of 'ext3' is always returned when configured.
-	options := controller.VolumeOptions{Parameters: map[string]string{fsType: "ext3"}}
-	fst := resolveFSType(options)
+	parameters := map[string]string{"fsType": "ext3"}
+	options := controller.VolumeOptions{Parameters: parameters}
+	fst, _ := resolveFSType(options)
 	if fst != "ext3" {
 		t.Fatalf("Unexpected filesystem type: '%s'.", fst)
 	}

pkg/provisioner/core/provisioner.go

@@ -42,6 +42,11 @@ const (
 	ociAvailabilityDomain  = "ociAvailabilityDomain"
 	ociCompartment         = "ociCompartment"
 	configFilePath         = "/etc/oci/config.yaml"
+	typeParameter          = "type"
+	fsTypeParameter        = "fsType"
+	blockStorageType       = "blockStorage"
+	defaultType            = blockStorageType
+	defaultFsType          = "ext4"
 )
 
 // OCIProvisioner is a dynamic volume provisioner that satisfies
@@ -87,8 +92,7 @@ func NewOCIProvisioner(kubeClient kubernetes.Interface, nodeInformer informersv1
 		nodeLister:       nodeInformer.Lister(),
 		nodeListerSynced: nodeInformer.Informer().HasSynced,
 		storageClassProvisioners: map[string]plugin.ProvisionerPlugin{
-			"oci":      blockProvisioner,
-			"oci-ext3": blockProvisioner,
+			defaultType: blockProvisioner,
 		},
 	}
 }
@@ -109,16 +113,29 @@ func mapAvailabilityDomainToFailureDomain(AD string) string {
 	return parts[len(parts)-1]
 }
 
+func resolveStorageType(options controller.VolumeOptions) string {
+	return getStorageTypeWithDefault(options.Parameters[typeParameter])
+}
+
+func getStorageTypeWithDefault(sType string) string {
+	t := defaultType
+	if sType != "" {
+		t = sType
+	}
+	return t
+}
+
 // Provision creates a storage asset and returns a PV object representing it.
 func (p *OCIProvisioner) Provision(options controller.VolumeOptions) (*v1.PersistentVolume, error) {
 	availabilityDomainName, availabilityDomain, err := p.chooseAvailabilityDomain(options.PVC)
 	if err != nil {
 		return nil, err
 	}
 
-	provisioner, ok := p.storageClassProvisioners[*options.PVC.Spec.StorageClassName]
+	storageType := resolveStorageType(options)
+	provisioner, ok := p.storageClassProvisioners[storageType]
 	if !ok {
-		return nil, fmt.Errorf("Storage class '%s' not supported", *options.PVC.Spec.StorageClassName)
+		return nil, fmt.Errorf("Storage type '%s' not supported", storageType)
 	}
 
 	persistentVolume, err := provisioner.Provision(options, availabilityDomain)
@@ -142,9 +159,15 @@ func (p *OCIProvisioner) Delete(volume *v1.PersistentVolume) error {
 		return &controller.IgnoredError{Reason: "identity annotation on PV does not match ours"}
 	}
 
-	provisioner, ok := p.storageClassProvisioners[volume.Spec.StorageClassName]
+	storageClass, err := p.kubeClient.Storage().StorageClasses().Get(volume.Spec.StorageClassName, metav1.GetOptions{})
+	if err != nil {
+		return fmt.Errorf("Could not find storage class '%q'", volume.Spec.StorageClassName)
+	}
+
+	storageType := getStorageTypeWithDefault(storageClass.Parameters[typeParameter])
+	provisioner, ok := p.storageClassProvisioners[storageType]
 	if !ok {
-		return fmt.Errorf("Storage class '%s' not supported", volume.Spec.StorageClassName)
+		return fmt.Errorf("Could not find a provisioner for storageType '%s'", storageType)
 	}
 
 	return provisioner.Delete(volume)