feat(localpv-device): allow local pv device on select devices

cmd/provisioner-localpv/app/config.go

@@ -37,12 +37,45 @@ const (
 	//KeyPVStorageType defines if the PV should be backed
 	// a hostpath ( sub directory or a storage device)
 	KeyPVStorageType = "StorageType"
+
 	//KeyPVBasePath defines base directory for hostpath volumes
 	// can be configured via the StorageClass annotations.
 	KeyPVBasePath = "BasePath"
+
 	//KeyPVFSType defines filesystem type to be used with devices
 	// and can be configured via the StorageClass annotations.
 	KeyPVFSType = "FSType"
+
+	//KeyBDPoolName defines the value for the Block Device Pool
+	//label selector configured via the StorageClass annotations.
+	//User can group block devices across nodes to form a block
+	//device pool, by setting the label on block devices as:
+	//  openebs.io/block-device-pool=<pool-name>
+	//
+	//The <pool-name> used above can be passsed to the
+	//Local PV device provisioner via the StorageClass
+	//CAS annotations.
+	//
+	//Example: Local PV device StorageClass for picking devices
+	//labeled as: openebs.io/block-device-pool=pool-x
+	//will be as follows
+	//
+	// kind: StorageClass
+	// metadata:
+	//   name: openebs-device-pool-x
+	//   annotations:
+	//     openebs.io/cas-type: local
+	//     cas.openebs.io/config: |
+	//       - name: StorageType
+	//         value: "device"
+	//       - name: BlockDevicePoolName
+	//         value: "pool-x"
+	// provisioner: openebs.io/local
+	// volumeBindingMode: WaitForFirstConsumer
+	// reclaimPolicy: Delete
+	//
+	KeyBDPoolName = "BlockDevicePoolName"
+
 	//KeyPVRelativePath defines the alternate folder name under the BasePath
 	// By default, the pv name will be used as the folder name.
 	// KeyPVBasePath can be useful for providing the same underlying folder
@@ -139,6 +172,20 @@ func (c *VolumeConfig) GetFSType() string {
 	return fsType
 }
 
+//GetBDPoolName returns the block device pool label
+//value configured in StorageClass.
+//
+//Default is "", no device pool will be set and all
+//the available block devices can be used for creating
+//Local PV.
+func (c *VolumeConfig) GetBDPoolName() string {
+	bdPoolName := c.getValue(KeyBDPoolName)
+	if len(strings.TrimSpace(bdPoolName)) == 0 {
+		return ""
+	}
+	return bdPoolName
+}
+
 //GetPath returns a valid PV path based on the configuration
 // or an error. The Path is constructed using the following rules:
 // If AbsolutePath is specified return it. (Future)

cmd/provisioner-localpv/app/helper_blockdevice.go

@@ -65,6 +65,10 @@ type HelperBlockDeviceOptions struct {
 	bdcName string
 	//  volumeMode of PVC
 	volumeMode corev1.PersistentVolumeMode
+
+	//bdPoolName is the value passed for
+	// BlockDevicePoolName via StorageClass config
+	bdPoolName string
 }
 
 // validate checks that the required fields to create BDC
@@ -120,14 +124,20 @@ func (p *Provisioner) createBlockDeviceClaim(blkDevOpts *HelperBlockDeviceOption
 		return nil
 	}
 
-	bdcObj, err := blockdeviceclaim.NewBuilder().
+	bdcObjBuilder := blockdeviceclaim.NewBuilder().
 		WithNamespace(p.namespace).
 		WithName(bdcName).
 		WithHostName(blkDevOpts.nodeHostname).
 		WithCapacity(blkDevOpts.capacity).
 		WithFinalizer(LocalPVFinalizer).
-		WithBlockVolumeMode(blkDevOpts.volumeMode).
-		Build()
+		WithBlockVolumeMode(blkDevOpts.volumeMode)
+
+	// If bdPoolName is configure, set it on the BDC
+	if len(blkDevOpts.bdPoolName) > 0 {
+		bdcObjBuilder.WithBlockDevicePoolName(blkDevOpts.bdPoolName)
+	}
+
+	bdcObj, err := bdcObjBuilder.Build()
 
 	if err != nil {
 		//TODO : Need to relook at this error

cmd/provisioner-localpv/app/provisioner_blockdevice.go

@@ -45,6 +45,7 @@ func (p *Provisioner) ProvisionBlockDevice(opts pvController.VolumeOptions, volu
 		name:         name,
 		capacity:     capacity.String(),
 		volumeMode:   *opts.PVC.Spec.VolumeMode,
+		bdPoolName:   volumeConfig.GetBDPoolName(),
 	}
 
 	path, blkPath, err := p.getBlockDevicePath(blkDevOpts)

pkg/blockdeviceclaim/v1alpha1/build.go

@@ -31,8 +31,13 @@ const (
 
 	// StoragePoolKindCSPC holds the value of CStorPoolCluster
 	StoragePoolKindCSPC = "CStorPoolCluster"
+
 	// APIVersion holds the value of OpenEBS version
 	APIVersion = "openebs.io/v1alpha1"
+
+	// bdPoolKey defines the label selector key
+	// used for grouping block devices on a given node
+	bdPoolKey = "openebs.io/block-device-pool"
 )
 
 // Builder is the builder object for BlockDeviceClaim
@@ -323,3 +328,28 @@ func (b *Builder) WithBlockVolumeMode(mode corev1.PersistentVolumeMode) *Builder
 
 	return b
 }
+
+// WithBlockDevicePoolName appends (or creates) the BDC Label Selector
+// by setting the provided value to the fixed key
+// openebs.io/block-device-pool
+// This will enable the NDM to pick only devices that
+// match the node (hostname) and block device pool label.
+func (b *Builder) WithBlockDevicePoolName(bdPoolName string) *Builder {
+	if len(bdPoolName) == 0 {
+		b.errs = append(
+			b.errs,
+			errors.New("failed to build BDC object: missing block device pool name"),
+		)
+		return b
+	}
+
+	if b.BDC.Object.Spec.Selector == nil {
+		b.BDC.Object.Spec.Selector = &metav1.LabelSelector{}
+	}
+	if b.BDC.Object.Spec.Selector.MatchLabels == nil {
+		b.BDC.Object.Spec.Selector.MatchLabels = map[string]string{}
+	}
+
+	b.BDC.Object.Spec.Selector.MatchLabels[bdPoolKey] = bdPoolName
+	return b
+}

pkg/blockdeviceclaim/v1alpha1/build_test.go

@@ -206,16 +206,46 @@ func TestBuildWithCapacity(t *testing.T) {
 	}
 }
 
+func TestBuilderWithBlockDevicePoolName(t *testing.T) {
+	tests := map[string]struct {
+		name      string
+		expectErr bool
+	}{
+		"Test Builder with pool name": {
+			name:      "test",
+			expectErr: false,
+		},
+		"Test Builder without pool name": {
+			name:      "",
+			expectErr: true,
+		},
+	}
+	for name, mock := range tests {
+		name, mock := name, mock
+		t.Run(name, func(t *testing.T) {
+			b := NewBuilder().WithBlockDevicePoolName(mock.name)
+			if mock.expectErr && len(b.errs) == 0 {
+				t.Fatalf("Test %q failed: expected error not to be nil", name)
+			}
+			if !mock.expectErr && len(b.errs) > 0 {
+				t.Fatalf("Test %q failed: expected error to be nil", name)
+			}
+		})
+	}
+}
+
 func TestBuild(t *testing.T) {
 	tests := map[string]struct {
 		name        string
 		capacity    string
+		poolName    string
 		expectedBDC *apis.BlockDeviceClaim
 		expectedErr bool
 	}{
 		"BDC with correct details": {
 			name:     "BDC1",
 			capacity: "10Ti",
+			poolName: "",
 			expectedBDC: &apis.BlockDeviceClaim{
 				ObjectMeta: metav1.ObjectMeta{Name: "BDC1"},
 				Spec: apis.DeviceClaimSpec{
@@ -228,17 +258,48 @@ func TestBuild(t *testing.T) {
 			},
 			expectedErr: false,
 		},
+		"BDC with correct details, including device pool": {
+			name:     "BDC1",
+			capacity: "10Ti",
+			poolName: "test",
+			expectedBDC: &apis.BlockDeviceClaim{
+				ObjectMeta: metav1.ObjectMeta{Name: "BDC1"},
+				Spec: apis.DeviceClaimSpec{
+					Resources: apis.DeviceClaimResources{
+						Requests: corev1.ResourceList{
+							corev1.ResourceName(ndm.ResourceStorage): fakeCapacity("10Ti"),
+						},
+					},
+					Selector: &metav1.LabelSelector{
+						MatchLabels: map[string]string{
+							bdPoolKey: "test",
+						},
+					},
+				},
+			},
+			expectedErr: false,
+		},
 		"BDC with error": {
 			name:        "",
 			capacity:    "500Gi",
+			poolName:    "test",
 			expectedBDC: nil,
 			expectedErr: true,
 		},
 	}
 	for name, mock := range tests {
 		name, mock := name, mock
 		t.Run(name, func(t *testing.T) {
-			bdcObj, err := NewBuilder().WithName(mock.name).WithCapacity(mock.capacity).Build()
+			bdcObjBuilder := NewBuilder().
+				WithName(mock.name).
+				WithCapacity(mock.capacity)
+
+			if len(mock.poolName) > 0 {
+				bdcObjBuilder.WithBlockDevicePoolName(mock.poolName)
+			}
+
+			bdcObj, err := bdcObjBuilder.Build()
+
 			if mock.expectedErr && err == nil {
 				t.Fatalf("Test %q failed: expected error not to be nil", name)
 			}