cephcluster: tune devices according to the deviceType

pkg/controller/storagecluster/cephcluster.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"reflect"
 	"strconv"
+	"strings"
 
 	"github.com/go-logr/logr"
 	objectreferencesv1 "github.com/openshift/custom-resource-status/objectreferences/v1"
@@ -67,7 +68,7 @@ func (r *ReconcileStorageCluster) ensureCephCluster(sc *ocsv1.StorageCluster, re
 		sc.Spec.StorageDeviceSets[i].Config.TuneSlowDeviceClass = false
 		sc.Spec.StorageDeviceSets[i].Config.TuneFastDeviceClass = false
 
-		diskSpeed, err := r.checkTuneStorageDevices(*ds.DataPVCTemplate.Spec.StorageClassName)
+		diskSpeed, err := r.checkTuneStorageDevices(ds)
 		if err != nil {
 			return fmt.Errorf("Failed to check for known device types: %+v", err)
 		}
@@ -519,7 +520,18 @@ func newCephDaemonResources(custom map[string]corev1.ResourceRequirements) map[s
 // The checkTuneStorageDevices function checks whether devices from the given
 // storage class are a known type that should expclitly be tuned for fast or
 // slow access.
-func (r *ReconcileStorageCluster) checkTuneStorageDevices(storageClassName string) (diskSpeed, error) {
+func (r *ReconcileStorageCluster) checkTuneStorageDevices(ds ocsv1.StorageDeviceSet) (diskSpeed, error) {
+	deviceType := ds.DeviceType
+
+	if DeviceTypeHDD == strings.ToLower(deviceType) {
+		return diskSpeedSlow, nil
+	}
+
+	if DeviceTypeSSD == strings.ToLower(deviceType) || DeviceTypeNVMe == strings.ToLower(deviceType) {
+		return diskSpeedFast, nil
+	}
+
+	storageClassName := *ds.DataPVCTemplate.Spec.StorageClassName
 	storageClass := &storagev1.StorageClass{}
 	err := r.client.Get(context.TODO(), types.NamespacedName{Namespace: "", Name: storageClassName}, storageClass)
 	if err != nil {

pkg/controller/storagecluster/storagecluster_controller_test.go

@@ -69,6 +69,8 @@ var mockCephClusterNamespacedName = types.NamespacedName{
 }
 
 var storageClassName = "gp2"
+var storageClassName2 = "managed-premium"
+var fakestorageClassName = "st1"
 var volMode = corev1.PersistentVolumeBlock
 
 var mockDataPVCTemplate = corev1.PersistentVolumeClaim{
@@ -252,6 +254,7 @@ func TestThrottleStorageDevices(t *testing.T) {
 	testcases := []struct {
 		label          string
 		storageClass   *storagev1.StorageClass
+		deviceSets     []api.StorageDeviceSet
 		storageCluster *api.StorageCluster
 		expectedSpeed  diskSpeed
 	}{
@@ -266,6 +269,18 @@ func TestThrottleStorageDevices(t *testing.T) {
 					"type": "gp2",
 				},
 			},
+			deviceSets: []api.StorageDeviceSet{
+				{
+					Name:  "mock-sds",
+					Count: 3,
+					DataPVCTemplate: corev1.PersistentVolumeClaim{
+						Spec: corev1.PersistentVolumeClaimSpec{
+							StorageClassName: &storageClassName,
+						},
+					},
+					Portable: true,
+				},
+			},
 			storageCluster: &api.StorageCluster{},
 			expectedSpeed:  diskSpeedSlow,
 		},
@@ -280,6 +295,18 @@ func TestThrottleStorageDevices(t *testing.T) {
 					"type": "st1",
 				},
 			},
+			deviceSets: []api.StorageDeviceSet{
+				{
+					Name:  "mock-sds",
+					Count: 3,
+					DataPVCTemplate: corev1.PersistentVolumeClaim{
+						Spec: corev1.PersistentVolumeClaimSpec{
+							StorageClassName: &fakestorageClassName,
+						},
+					},
+					Portable: true,
+				},
+			},
 			storageCluster: &api.StorageCluster{},
 			expectedSpeed:  diskSpeedUnknown,
 		},
@@ -294,16 +321,111 @@ func TestThrottleStorageDevices(t *testing.T) {
 					"type": "managed-premium",
 				},
 			},
+			deviceSets: []api.StorageDeviceSet{
+				{
+					Name:  "mock-sds",
+					Count: 3,
+					DataPVCTemplate: corev1.PersistentVolumeClaim{
+						Spec: corev1.PersistentVolumeClaimSpec{
+							StorageClassName: &storageClassName2,
+						},
+					},
+					Portable: true,
+				},
+			},
+			storageCluster: &api.StorageCluster{},
+			expectedSpeed:  diskSpeedFast,
+		},
+		{
+			label: "Case 4", // storageclass is managed-premium but deviceType hdd
+			storageClass: &storagev1.StorageClass{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "managed-premium",
+				},
+				Provisioner: string(AzureDisk),
+				Parameters: map[string]string{
+					"type": "managed-premium",
+				},
+			},
+			deviceSets: []api.StorageDeviceSet{
+				{
+					Name:  "mock-sds",
+					Count: 3,
+					DataPVCTemplate: corev1.PersistentVolumeClaim{
+						Spec: corev1.PersistentVolumeClaimSpec{
+							StorageClassName: &storageClassName2,
+						},
+					},
+					Portable:   true,
+					DeviceType: "hdd",
+				},
+			},
+			storageCluster: &api.StorageCluster{},
+			expectedSpeed:  diskSpeedSlow,
+		},
+		{
+			label: "Case 5", // storageclass is gp2 but deviceType ssd
+			storageClass: &storagev1.StorageClass{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "gp2",
+				},
+				Provisioner: string(EBS),
+				Parameters: map[string]string{
+					"type": "gp2",
+				},
+			},
+			deviceSets: []api.StorageDeviceSet{
+				{
+					Name:  "mock-sds",
+					Count: 3,
+					DataPVCTemplate: corev1.PersistentVolumeClaim{
+						Spec: corev1.PersistentVolumeClaimSpec{
+							StorageClassName: &storageClassName,
+						},
+					},
+					Portable:   true,
+					DeviceType: "ssd",
+				},
+			},
+			storageCluster: &api.StorageCluster{},
+			expectedSpeed:  diskSpeedFast,
+		},
+		{
+			label: "Case 6", // storageclass is neither gp2 nor io1 but deviceType nvme
+			storageClass: &storagev1.StorageClass{
+				ObjectMeta: metav1.ObjectMeta{
+					Name: "st1",
+				},
+				Provisioner: string(EBS),
+				Parameters: map[string]string{
+					"type": "st1",
+				},
+			},
+			deviceSets: []api.StorageDeviceSet{
+				{
+					Name:  "mock-sds",
+					Count: 3,
+					DataPVCTemplate: corev1.PersistentVolumeClaim{
+						Spec: corev1.PersistentVolumeClaimSpec{
+							StorageClassName: &fakestorageClassName,
+						},
+					},
+					Portable:   true,
+					DeviceType: "nvme",
+				},
+			},
 			storageCluster: &api.StorageCluster{},
 			expectedSpeed:  diskSpeedFast,
 		},
 	}
 
 	for _, tc := range testcases {
 		reconciler := createFakeStorageClusterReconciler(t, tc.storageCluster, tc.storageClass)
-		actualSpeed, err := reconciler.checkTuneStorageDevices(tc.storageClass.Name)
-		assert.NoError(t, err)
-		assert.Equalf(t, tc.expectedSpeed, actualSpeed, "[%q]: failed to get expected output", tc.label)
+		for _, ds := range tc.deviceSets {
+			actualSpeed, err := reconciler.checkTuneStorageDevices(ds)
+			assert.NoError(t, err)
+			assert.Equalf(t, tc.expectedSpeed, actualSpeed, "[%q]: failed to get expected output", tc.label)
+		}
 	}
 }