Skip to content

Commit 4ba7312

Browse files
dharaneeshvrddharaneeshvrd
committed
GET_VOLUME_STATS node capability added
1 parent cafd830 commit 4ba7312

File tree

4 files changed

+346
-1
lines changed

4 files changed

+346
-1
lines changed

‎pkg/driver/mocks/mock_stats.go

Lines changed: 98 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎pkg/driver/node.go

Lines changed: 69 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,7 @@ var (
5656
nodeCaps = []csi.NodeServiceCapability_RPC_Type{
5757
csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,
5858
csi.NodeServiceCapability_RPC_EXPAND_VOLUME,
59+
csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,
5960
}
6061
)
6162

@@ -66,6 +67,7 @@ type nodeService struct {
6667
driverOptions *Options
6768
pvmInstanceId string
6869
volumeLocks *util.VolumeLocks
70+
stats StatsUtils
6971
}
7072

7173
// newNodeService creates a new node service
@@ -88,6 +90,7 @@ func newNodeService(driverOptions *Options) nodeService {
8890
driverOptions: driverOptions,
8991
pvmInstanceId: metadata.GetPvmInstanceId(),
9092
volumeLocks: util.NewVolumeLocks(),
93+
stats: &VolumeStatUtils{},
9194
}
9295
}
9396

@@ -380,7 +383,72 @@ func (d *nodeService) NodeUnpublishVolume(ctx context.Context, req *csi.NodeUnpu
380383
}
381384

382385
func (d *nodeService) NodeGetVolumeStats(ctx context.Context, req *csi.NodeGetVolumeStatsRequest) (*csi.NodeGetVolumeStatsResponse, error) {
383-
return nil, status.Error(codes.Unimplemented, "NodeGetVolumeStats is not implemented yet")
386+
klog.V(4).Infof("NodeGetVolumeStats: called with args %+v", *req)
387+
var resp *csi.NodeGetVolumeStatsResponse
388+
389+
if req == nil || req.VolumeId == "" {
390+
return nil, status.Error(codes.InvalidArgument, "Volume ID not provided")
391+
}
392+
393+
if req.VolumePath == "" {
394+
return nil, status.Error(codes.InvalidArgument, "VolumePath not provided")
395+
}
396+
397+
volumePath := req.VolumePath
398+
// return if path does not exist
399+
if d.stats.IsPathNotExist(volumePath) {
400+
return nil, status.Error(codes.NotFound, "VolumePath not exist")
401+
}
402+
403+
// check if volume mode is raw volume mode
404+
isBlock, err := d.stats.IsBlockDevice(volumePath)
405+
if err != nil {
406+
return nil, status.Error(codes.Internal, fmt.Sprintf("Failed to check volume %s is block device or not: %v", req.VolumeId, err))
407+
}
408+
// if block device, get deviceStats
409+
if isBlock {
410+
capacity, err := d.stats.DeviceInfo(volumePath)
411+
if err != nil {
412+
return nil, status.Error(codes.Internal, fmt.Sprintf("Failed to collect block device info: %v", err))
413+
}
414+
415+
resp = &csi.NodeGetVolumeStatsResponse{
416+
Usage: []*csi.VolumeUsage{
417+
{
418+
Total: capacity,
419+
Unit: csi.VolumeUsage_BYTES,
420+
},
421+
},
422+
}
423+
424+
klog.V(4).Infof("Block Device Volume stats collected: %+v\n", resp)
425+
return resp, nil
426+
}
427+
428+
// else get the file system stats
429+
available, capacity, usage, inodes, inodesFree, inodesUsed, err := d.stats.FSInfo(volumePath)
430+
if err != nil {
431+
return nil, status.Error(codes.Internal, fmt.Sprintf("Failed to collect FSInfo: %v", err))
432+
}
433+
resp = &csi.NodeGetVolumeStatsResponse{
434+
Usage: []*csi.VolumeUsage{
435+
{
436+
Available: available,
437+
Total: capacity,
438+
Used: usage,
439+
Unit: csi.VolumeUsage_BYTES,
440+
},
441+
{
442+
Available: inodesFree,
443+
Total: inodes,
444+
Used: inodesUsed,
445+
Unit: csi.VolumeUsage_INODES,
446+
},
447+
},
448+
}
449+
450+
klog.V(4).Infof("FS Volume stats collected: %+v\n", resp)
451+
return resp, nil
384452
}
385453

386454
func (d *nodeService) NodeGetCapabilities(ctx context.Context, req *csi.NodeGetCapabilitiesRequest) (*csi.NodeGetCapabilitiesResponse, error) {

‎pkg/driver/node_test.go

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@ package driver
1616
import (
1717
"context"
1818
"errors"
19+
"fmt"
1920
"reflect"
2021
"testing"
2122

@@ -540,6 +541,117 @@ func TestNodeGetInfo(t *testing.T) {
540541
}
541542
}
542543

544+
func TestNodeGetVolumeStats(t *testing.T) {
545+
testCases := []struct {
546+
name string
547+
testFunc func(t *testing.T)
548+
}{
549+
{name: "success block device volume",
550+
testFunc: func(t *testing.T) {
551+
mockCtl := gomock.NewController(t)
552+
defer mockCtl.Finish()
553+
mockStatUtils := mocks.NewMockStatsUtils(mockCtl)
554+
555+
volumePath := "./test"
556+
var mockCapacity int64 = 100
557+
mockStatUtils.EXPECT().IsPathNotExist(volumePath).Return(false)
558+
mockStatUtils.EXPECT().IsBlockDevice(volumePath).Return(true, nil)
559+
mockStatUtils.EXPECT().DeviceInfo(volumePath).Return(mockCapacity, nil)
560+
driver := &nodeService{stats: mockStatUtils}
561+
562+
req := csi.NodeGetVolumeStatsRequest{VolumeId: volumeID, VolumePath: volumePath}
563+
564+
resp, err := driver.NodeGetVolumeStats(context.TODO(), &req)
565+
if err != nil {
566+
t.Fatalf("Expect no error but got: %v", err)
567+
}
568+
569+
if resp.Usage[0].Total != mockCapacity {
570+
t.Fatalf("Expected total capacity as %d, got %d", mockCapacity, resp.Usage[0].Total)
571+
}
572+
},
573+
}, {
574+
name: "failure path not exist",
575+
testFunc: func(t *testing.T) {
576+
mockCtl := gomock.NewController(t)
577+
defer mockCtl.Finish()
578+
mockStatUtils := mocks.NewMockStatsUtils(mockCtl)
579+
580+
volumePath := "./test"
581+
mockStatUtils.EXPECT().IsPathNotExist(volumePath).Return(true)
582+
driver := &nodeService{stats: mockStatUtils}
583+
584+
req := csi.NodeGetVolumeStatsRequest{VolumeId: volumeID, VolumePath: volumePath}
585+
586+
_, err := driver.NodeGetVolumeStats(context.TODO(), &req)
587+
expectErr(t, err, codes.NotFound)
588+
},
589+
}, {
590+
name: "failure checking for block device",
591+
testFunc: func(t *testing.T) {
592+
mockCtl := gomock.NewController(t)
593+
defer mockCtl.Finish()
594+
mockStatUtils := mocks.NewMockStatsUtils(mockCtl)
595+
596+
volumePath := "./test"
597+
mockStatUtils.EXPECT().IsPathNotExist(volumePath).Return(false)
598+
mockStatUtils.EXPECT().IsBlockDevice(volumePath).Return(false, errors.New("Error checking for block device"))
599+
driver := &nodeService{stats: mockStatUtils}
600+
601+
req := csi.NodeGetVolumeStatsRequest{VolumeId: volumeID, VolumePath: volumePath}
602+
603+
_, err := driver.NodeGetVolumeStats(context.TODO(), &req)
604+
expectErr(t, err, codes.Internal)
605+
},
606+
}, {
607+
name: "failure collecting block device info",
608+
testFunc: func(t *testing.T) {
609+
mockCtl := gomock.NewController(t)
610+
defer mockCtl.Finish()
611+
mockStatUtils := mocks.NewMockStatsUtils(mockCtl)
612+
613+
volumePath := "./test"
614+
mockStatUtils.EXPECT().IsPathNotExist(volumePath).Return(false)
615+
mockStatUtils.EXPECT().IsBlockDevice(volumePath).Return(true, nil)
616+
mockStatUtils.EXPECT().DeviceInfo(volumePath).Return(int64(0), errors.New("Error collecting block device info"))
617+
618+
driver := &nodeService{stats: mockStatUtils}
619+
620+
req := csi.NodeGetVolumeStatsRequest{VolumeId: volumeID, VolumePath: volumePath}
621+
622+
_, err := driver.NodeGetVolumeStats(context.TODO(), &req)
623+
fmt.Println(err)
624+
expectErr(t, err, codes.Internal)
625+
},
626+
},
627+
{
628+
name: "failure collecting fs info",
629+
testFunc: func(t *testing.T) {
630+
mockCtl := gomock.NewController(t)
631+
defer mockCtl.Finish()
632+
mockStatUtils := mocks.NewMockStatsUtils(mockCtl)
633+
634+
volumePath := "./test"
635+
mockStatUtils.EXPECT().IsPathNotExist(volumePath).Return(false)
636+
mockStatUtils.EXPECT().IsBlockDevice(volumePath).Return(false, nil)
637+
var statUnit int64 = 0
638+
mockStatUtils.EXPECT().FSInfo(volumePath).Return(statUnit, statUnit, statUnit, statUnit, statUnit, statUnit, errors.New("Error collecting FS Info"))
639+
driver := &nodeService{stats: mockStatUtils}
640+
641+
req := csi.NodeGetVolumeStatsRequest{VolumeId: volumeID, VolumePath: volumePath}
642+
643+
_, err := driver.NodeGetVolumeStats(context.TODO(), &req)
644+
fmt.Println(err)
645+
646+
expectErr(t, err, codes.Internal)
647+
},
648+
},
649+
}
650+
for _, tc := range testCases {
651+
t.Run(tc.name, tc.testFunc)
652+
}
653+
}
654+
543655
func expectErr(t *testing.T, actualErr error, expectedCode codes.Code) {
544656
if actualErr == nil {
545657
t.Fatalf("Expect error but got no error")

‎pkg/driver/stats.go

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
package driver
2+
3+
import (
4+
"fmt"
5+
"os"
6+
"os/exec"
7+
"strconv"
8+
"strings"
9+
10+
"golang.org/x/sys/unix"
11+
"k8s.io/kubernetes/pkg/volume/util/fs"
12+
)
13+
14+
// StatsUtils ...
15+
type StatsUtils interface {
16+
FSInfo(path string) (int64, int64, int64, int64, int64, int64, error)
17+
IsBlockDevice(devicePath string) (bool, error)
18+
DeviceInfo(devicePath string) (int64, error)
19+
IsPathNotExist(path string) bool
20+
}
21+
22+
// VolumeStatUtils ...
23+
type VolumeStatUtils struct {
24+
}
25+
26+
// IsDevicePathNotExist ...
27+
func (su *VolumeStatUtils) IsPathNotExist(path string) bool {
28+
var stat unix.Stat_t
29+
err := unix.Stat(path, &stat)
30+
if err != nil {
31+
if os.IsNotExist(err) {
32+
return true
33+
}
34+
}
35+
return false
36+
}
37+
38+
// IsBlockDevice ...
39+
func (su *VolumeStatUtils) IsBlockDevice(devicePath string) (bool, error) {
40+
var stat unix.Stat_t
41+
err := unix.Stat(devicePath, &stat)
42+
if err != nil {
43+
return false, err
44+
}
45+
46+
return (stat.Mode & unix.S_IFMT) == unix.S_IFBLK, nil
47+
}
48+
49+
// DeviceInfo ...
50+
func (su *VolumeStatUtils) DeviceInfo(devicePath string) (int64, error) {
51+
output, err := exec.Command("blockdev", "--getsize64", devicePath).CombinedOutput()
52+
if err != nil {
53+
return 0, fmt.Errorf("failed to get size of block volume at path %s: output: %s, err: %v", devicePath, string(output), err)
54+
}
55+
strOut := strings.TrimSpace(string(output))
56+
gotSizeBytes, err := strconv.ParseInt(strOut, 10, 64)
57+
if err != nil {
58+
return 0, fmt.Errorf("failed to parse size '%s' into int", strOut)
59+
}
60+
61+
return gotSizeBytes, nil
62+
}
63+
64+
//FSInfo ...
65+
func (su *VolumeStatUtils) FSInfo(path string) (int64, int64, int64, int64, int64, int64, error) {
66+
return fs.Info(path)
67+
}

0 commit comments

Comments
 (0)