refact(XFS-Quota): get XFS Quota parameters from StorageClass 'cas.openebs.io/config' annotation (#107)

* Use XFS Quota parameters from cas-config
* Add integration test changes
* Empty softLimitGrace and hardLimitGrace default to 0% and 0% respectively
* Extend timeout on integration test checks to account for delays

Signed-off-by: Niladri Halder <[email protected]>

Author: niladrih

cmd/provisioner-localpv/app/config.go

@@ -19,6 +19,7 @@ package app
 
 import (
 	"context"
+	"strconv"
 	"strings"
 
 	mconfig "github.com/openebs/maya/pkg/apis/openebs.io/v1alpha1"
@@ -113,6 +114,17 @@ const (
 	// is specified with PVC and is useful for granting shared access
 	// to underlying hostpaths across multiple pods.
 	//KeyPVAbsolutePath = "AbsolutePath"
+
+	//KeyXFSQuota enables/sets parameters for XFS Quota.
+	// Example StorageClass snippet:
+	//    - name: XFSQuota
+	//      enabled: true
+	//      data:
+	//        softLimitGrace: "80%"
+	//        hardLimitGrace: "85%"
+	KeyXFSQuota          = "XFSQuota"
+	KeyXfsQuotaSoftLimit = "softLimitGrace"
+	KeyXfsQuotaHardLimit = "hardLimitGrace"
 )
 
 const (
@@ -168,11 +180,17 @@ func (p *Provisioner) GetVolumeConfig(ctx context.Context, pvName string, pvc *c
 		return nil, errors.Wrapf(err, "unable to read volume config: pvc {%v}", pvc.ObjectMeta.Name)
 	}
 
+	dataPvConfigMap, err := dataConfigToMap(pvConfig)
+	if err != nil {
+		return nil, errors.Wrapf(err, "unable to read volume config: pvc {%v}", pvc.ObjectMeta.Name)
+	}
+
 	c := &VolumeConfig{
-		pvName:  pvName,
-		pvcName: pvc.ObjectMeta.Name,
-		scName:  *scName,
-		options: pvConfigMap,
+		pvName:     pvName,
+		pvcName:    pvc.ObjectMeta.Name,
+		scName:     *scName,
+		options:    pvConfigMap,
+		configData: dataPvConfigMap,
 	}
 	return c, nil
 }
@@ -262,6 +280,23 @@ func (c *VolumeConfig) GetPath() (string, error) {
 		ValidateAndBuild()
 }
 
+func (c *VolumeConfig) IsXfsQuotaEnabled() bool {
+	xfsQuotaEnabled := c.getEnabled(KeyXFSQuota)
+	xfsQuotaEnabled = strings.TrimSpace(xfsQuotaEnabled)
+
+	enableXfsQuotaBool, err := strconv.ParseBool(xfsQuotaEnabled)
+	//Default case
+	// this means that we have hit either of the two cases below:
+	//     i. The value was something other than a straightforward
+	//        true or false
+	//    ii. The value was empty
+	if err != nil {
+		return false
+	}
+
+	return enableXfsQuotaBool
+}
+
 //getValue is a utility function to extract the value
 // of the `key` from the ConfigMap object - which is
 // map[string]interface{map[string][string]}
@@ -283,6 +318,30 @@ func (c *VolumeConfig) getValue(key string) string {
 	return ""
 }
 
+//Similar to getValue() above. Returns value of the
+// 'Enabled' parameter.
+func (c *VolumeConfig) getEnabled(key string) string {
+	if configObj, ok := util.GetNestedField(c.options, key).(map[string]string); ok {
+		if val, p := configObj[string(mconfig.EnabledPTP)]; p {
+			return val
+		}
+	}
+	return ""
+}
+
+//This is similar to getValue() and getEnabled().
+// This gets the value for a specific
+// 'Data' parameter key-value pair.
+func (c *VolumeConfig) getData(key string, dataKey string) string {
+	if configData, ok := util.GetNestedField(c.configData, key).(map[string]string); ok {
+		if val, p := configData[dataKey]; p {
+			return val
+		}
+	}
+	//Default case
+	return ""
+}
+
 // GetStorageClassName extracts the StorageClass name from PVC
 func GetStorageClassName(pvc *corev1.PersistentVolumeClaim) *string {
 	// Use beta annotation first
@@ -347,3 +406,25 @@ func GetImagePullSecrets(s string) []corev1.LocalObjectReference {
 	}
 	return list
 }
+
+func dataConfigToMap(pvConfig []mconfig.Config) (map[string]interface{}, error) {
+	m := map[string]interface{}{}
+
+	for _, configObj := range pvConfig {
+		//No Data Parameter
+		if configObj.Data == nil {
+			continue
+		}
+
+		configName := strings.TrimSpace(configObj.Name)
+		confHierarchy := map[string]interface{}{
+			configName: configObj.Data,
+		}
+		isMerged := util.MergeMapOfObjects(m, confHierarchy)
+		if !isMerged {
+			return nil, errors.Errorf("failed to transform cas config 'Data' for configName '%s' to map: failed to merge: %s", configName, configObj)
+		}
+	}
+
+	return m, nil
+}

cmd/provisioner-localpv/app/config_test.go

@@ -21,6 +21,8 @@ import (
 	"reflect"
 	"testing"
 
+	mconfig "github.com/openebs/maya/pkg/apis/openebs.io/v1alpha1"
+
 	corev1 "k8s.io/api/core/v1"
 )
 
@@ -64,3 +66,42 @@ func TestGetImagePullSecrets(t *testing.T) {
 		})
 	}
 }
+
+func TestDataConfigToMap(t *testing.T) {
+	hostpathConfig := mconfig.Config{Name: "StorageType", Value: "hostpath"}
+	xfsQuotaConfig := mconfig.Config{Name: "XFSQuota", Enabled: "true",
+		Data: map[string]string{
+			"SoftLimitGrace": "20%",
+			"HardLimitGrace": "80%",
+		},
+	}
+
+	testCases := map[string]struct {
+		config        []mconfig.Config
+		expectedValue map[string]interface{}
+	}{
+		"nil 'Data' map": {
+			config: []mconfig.Config{hostpathConfig, xfsQuotaConfig},
+			expectedValue: map[string]interface{}{
+				"XFSQuota": map[string]string{
+					"SoftLimitGrace": "20%",
+					"HardLimitGrace": "80%",
+				},
+			},
+		},
+	}
+
+	for k, v := range testCases {
+		v := v
+		k := k
+		t.Run(k, func(t *testing.T) {
+			actualValue, err := dataConfigToMap(v.config)
+			if err != nil {
+				t.Errorf("expected error to be nil, but got %v", err)
+			}
+			if !reflect.DeepEqual(actualValue, v.expectedValue) {
+				t.Errorf("expected %v, but got %v", v.expectedValue, actualValue)
+			}
+		})
+	}
+}

cmd/provisioner-localpv/app/helper_hostpath.go

@@ -109,7 +109,12 @@ func (pOpts *HelperPodOptions) validate() error {
 func (pOpts *HelperPodOptions) validateLimits() error {
 	if pOpts.softLimitGrace == "0k" &&
 		pOpts.hardLimitGrace == "0k" {
-		return errors.Errorf("both limits cannot be 0")
+		// Hack: using convertToK() style converstion
+		// TODO: Refactor this section of the code
+		pvcStorageInK := math.Ceil(float64(pOpts.pvcStorage) / 1000)
+		pvcStorageInKString := strconv.FormatFloat(pvcStorageInK, 'f', -1, 64) + "k"
+		pOpts.softLimitGrace, pOpts.hardLimitGrace = pvcStorageInKString, pvcStorageInKString
+		return nil
 	}
 
 	if pOpts.softLimitGrace == "0k" ||
@@ -154,10 +159,7 @@ func convertToK(limit string, pvcStorage int64) (string, error) {
 	value += float64(pvcStorage)
 	value /= 1000
 
-	if value != math.Trunc(value) {
-		value++
-	}
-	value = math.Trunc(value)
+	value = math.Ceil(value)
 	valueString = strconv.FormatFloat(value, 'f', -1, 64)
 	valueString += "k"
 	return valueString, nil

cmd/provisioner-localpv/app/provisioner.go

@@ -80,7 +80,7 @@ func NewProvisioner(kubeClient *clientset.Clientset) (*Provisioner, error) {
 
 // SupportsBlock will be used by controller to determine if block mode is
 //  supported by the host path provisioner.
-func (p *Provisioner) SupportsBlock(ctx context.Context) bool {
+func (p *Provisioner) SupportsBlock(_ context.Context) bool {
 	return true
 }
 

cmd/provisioner-localpv/app/provisioner_hostpath.go

@@ -93,11 +93,9 @@ func (p *Provisioner) ProvisionHostPath(ctx context.Context, opts pvController.P
 		return nil, pvController.ProvisioningFinished, iErr
 	}
 
-	enableXfsQuota := opts.StorageClass.Parameters[EnableXfsQuota]
-
-	if enableXfsQuota == "true" {
-		softLimitGrace := opts.StorageClass.Parameters[SoftLimitGrace]
-		hardLimitGrace := opts.StorageClass.Parameters[HardLimitGrace]
+	if volumeConfig.IsXfsQuotaEnabled() {
+		softLimitGrace := volumeConfig.getData(KeyXFSQuota, KeyXfsQuotaSoftLimit)
+		hardLimitGrace := volumeConfig.getData(KeyXFSQuota, KeyXfsQuotaHardLimit)
 		pvcStorage := opts.PVC.Spec.Resources.Requests.Storage().Value()
 
 		podOpts := &HelperPodOptions{

cmd/provisioner-localpv/app/types.go

@@ -60,10 +60,11 @@ type Provisioner struct {
 //   },
 // }
 type VolumeConfig struct {
-	pvName  string
-	pvcName string
-	scName  string
-	options map[string]interface{}
+	pvName     string
+	pvcName    string
+	scName     string
+	options    map[string]interface{}
+	configData map[string]interface{}
 }
 
 // GetVolumeConfigFn allows to plugin a custom function

pkg/kubernetes/api/storage/v1/storageclass/build.go

@@ -27,12 +27,17 @@ import (
 const (
 	localPVcasTypeValue = "local"
 
-	// Provisioner Name
+	//Provisioner Name
 	localPVprovisionerName = "openebs.io/local"
 
-	// The following are imported from mconfig at the moment
+	//The following are imported from mconfig at the moment
 	// CASConfigKey = "cas.openebs.io/config"
 	// CASTypeKey = "openebs.io/cas-type"
+
+	//These are from 'app' package
+	// cmd/provisioner-localpv/app/config.go
+	KeyXfsQuotaSoftLimit = "softLimitGrace"
+	KeyXfsQuotaHardLimit = "hardLimitGrace"
 )
 
 type StorageClassOption func(*storagev1.StorageClass) error
@@ -186,6 +191,43 @@ func WithDevice() StorageClassOption {
 	}
 }
 
+func WithXfsQuota(softLimit, hardLimit string) StorageClassOption {
+	return func(s *storagev1.StorageClass) error {
+		if !isCompatibleWithXfsQuota(s) {
+			return errors.New("Failed to set XFSQuota parameters. " +
+				"Invalid existing '" + string(mconfig.CASConfigKey) + "' annotation" +
+				" parameters or Provisioner name.")
+		}
+
+		// TODO: Refactor this code
+
+		config := "- name: XFSQuota\n" +
+			"  enabled: \"true\"\n"
+
+		if len(softLimit) > 0 || len(hardLimit) > 0 {
+			if !isValidXfsQuotaData(map[string]string{
+				KeyXfsQuotaSoftLimit: softLimit,
+				KeyXfsQuotaHardLimit: hardLimit,
+			}) {
+				return errors.New("Failed to set XFSQuota parameters. " +
+					"Invalid " + KeyXfsQuotaSoftLimit + " and " +
+					KeyXfsQuotaHardLimit + " values")
+			}
+
+			config = config +
+				"  data:\n" +
+				"    " + KeyXfsQuotaSoftLimit + ": \"" + softLimit + "\"\n" +
+				"    " + KeyXfsQuotaHardLimit + ": \"" + hardLimit + "\"\n"
+		}
+
+		ok := writeOrAppendCASConfig(s, config)
+		if !ok {
+			return errors.New("Failed to set XFSQuota parameters")
+		}
+		return nil
+	}
+}
+
 func WithVolumeBindingMode(volBindingMode storagev1.VolumeBindingMode) StorageClassOption {
 	return func(s *storagev1.StorageClass) error {
 		if len(volBindingMode) == 0 {