replace statter.go with k8s.io pkg to get statFS

pkg/driver/node.go

@@ -19,6 +19,8 @@ package driver
 import (
 	"context"
 	"fmt"
+	"golang.org/x/sys/unix"
+	"k8s.io/kubernetes/pkg/volume"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -74,7 +76,6 @@ var (
 type nodeService struct {
 	metadata      cloud.MetadataService
 	mounter       Mounter
-	statter       Statter
 	inFlight      *internal.InFlight
 	driverOptions *DriverOptions
 }
@@ -90,7 +91,6 @@ func newNodeService(driverOptions *DriverOptions) nodeService {
 	return nodeService{
 		metadata:      metadata,
 		mounter:       newNodeMounter(),
-		statter:       NewStatter(),
 		inFlight:      internal.NewInFlight(),
 		driverOptions: driverOptions,
 	}
@@ -364,7 +364,7 @@ func (d *nodeService) NodeGetVolumeStats(ctx context.Context, req *csi.NodeGetVo
 		return nil, status.Errorf(codes.NotFound, "path %s does not exist", req.VolumePath)
 	}
 
-	isBlock, err := d.statter.IsBlockDevice(req.VolumePath)
+	isBlock, err := d.IsBlockDevice(req.VolumePath)
 
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "failed to determine whether %s is block device: %v", req.VolumePath, err)
@@ -384,25 +384,26 @@ func (d *nodeService) NodeGetVolumeStats(ctx context.Context, req *csi.NodeGetVo
 		}, nil
 	}
 
-	available, capacity, used, inodesFree, inodes, inodesUsed, err := d.statter.StatFS(req.VolumePath)
+	metricsProvider := volume.NewMetricsStatFS(req.VolumePath)
+
+	metrics, err := metricsProvider.GetMetrics()
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "failed to get fs info on path %s: %v", req.VolumePath, err)
 	}
 
 	return &csi.NodeGetVolumeStatsResponse{
 		Usage: []*csi.VolumeUsage{
 			{
-				Available: available,
-				Total:     capacity,
-				Used:      used,
 				Unit:      csi.VolumeUsage_BYTES,
+				Available: metrics.Available.AsDec().UnscaledBig().Int64(),
+				Total:     metrics.Capacity.AsDec().UnscaledBig().Int64(),
+				Used:      metrics.Used.AsDec().UnscaledBig().Int64(),
 			},
-
 			{
-				Available: inodesFree,
-				Total:     inodes,
-				Used:      inodesUsed,
 				Unit:      csi.VolumeUsage_INODES,
+				Available: metrics.InodesFree.AsDec().UnscaledBig().Int64(),
+				Total:     metrics.Inodes.AsDec().UnscaledBig().Int64(),
+				Used:      metrics.InodesUsed.AsDec().UnscaledBig().Int64(),
 			},
 		},
 	}, nil
@@ -613,6 +614,17 @@ func hasMountOption(options []string, opt string) bool {
 	return false
 }
 
+// IsBlock checks if the given path is a block device
+func (d *nodeService) IsBlockDevice(fullPath string) (bool, error) {
+	var st unix.Stat_t
+	err := unix.Stat(fullPath, &st)
+	if err != nil {
+		return false, err
+	}
+
+	return (st.Mode & unix.S_IFMT) == unix.S_IFBLK, nil
+}
+
 func (d *nodeService) getBlockSizeBytes(devicePath string) (int64, error) {
 	cmd := d.mounter.Command("blockdev", "--getsize64", devicePath)
 	output, err := cmd.Output()

pkg/driver/node_test.go

@@ -19,6 +19,7 @@ package driver
 import (
 	"context"
 	"errors"
+	"os"
 	"reflect"
 	"strings"
 	"testing"
@@ -1182,29 +1183,82 @@ func TestNodeGetVolumeStats(t *testing.T) {
 
 				mockMetadata := mocks.NewMockMetadataService(mockCtl)
 				mockMounter := mocks.NewMockMounter(mockCtl)
-				mockStatter := mocks.NewMockStatter(mockCtl)
-				VolumePath := "/test"
-				one := int64(1)
+				VolumePath := "./test"
+
+				err := os.MkdirAll(VolumePath, 0644)
+				if err != nil {
+					t.Fatalf("fail to create dir: %v", err)
+				}
+				defer os.RemoveAll(VolumePath)
 
 				mockMounter.EXPECT().ExistsPath(VolumePath).Return(true, nil)
-				mockStatter.EXPECT().IsBlockDevice(VolumePath).Return(false, nil)
-				mockStatter.EXPECT().StatFS(VolumePath).Return(one, one, one, one, one, one, nil)
 
 				awsDriver := nodeService{
 					metadata: mockMetadata,
 					mounter:  mockMounter,
-					statter:  mockStatter,
 					inFlight: internal.NewInFlight(),
 				}
 
 				req := &csi.NodeGetVolumeStatsRequest{
 					VolumeId:   "vol-test",
 					VolumePath: VolumePath,
 				}
-				_, err := awsDriver.NodeGetVolumeStats(context.TODO(), req)
+				_, err = awsDriver.NodeGetVolumeStats(context.TODO(), req)
 				if err != nil {
-					t.Fatalf("Expected no error but got err %v", err)
+					t.Fatalf("Expect no error but got: %v", err)
+				}
+			},
+		},
+		{
+			name: "fail path not exist",
+			testFunc: func(t *testing.T) {
+				mockCtl := gomock.NewController(t)
+				defer mockCtl.Finish()
+
+				mockMetadata := mocks.NewMockMetadataService(mockCtl)
+				mockMounter := mocks.NewMockMounter(mockCtl)
+				VolumePath := "/test"
+
+				mockMounter.EXPECT().ExistsPath(VolumePath).Return(false, nil)
+
+				awsDriver := nodeService{
+					metadata: mockMetadata,
+					mounter:  mockMounter,
+					inFlight: internal.NewInFlight(),
+				}
+
+				req := &csi.NodeGetVolumeStatsRequest{
+					VolumeId:   "vol-test",
+					VolumePath: VolumePath,
 				}
+				_, err := awsDriver.NodeGetVolumeStats(context.TODO(), req)
+				expectErr(t, err, codes.NotFound)
+			},
+		},
+		{
+			name: "fail can't determine block device",
+			testFunc: func(t *testing.T) {
+				mockCtl := gomock.NewController(t)
+				defer mockCtl.Finish()
+
+				mockMetadata := mocks.NewMockMetadataService(mockCtl)
+				mockMounter := mocks.NewMockMounter(mockCtl)
+				VolumePath := "/test"
+
+				mockMounter.EXPECT().ExistsPath(VolumePath).Return(true, nil)
+
+				awsDriver := nodeService{
+					metadata: mockMetadata,
+					mounter:  mockMounter,
+					inFlight: internal.NewInFlight(),
+				}
+
+				req := &csi.NodeGetVolumeStatsRequest{
+					VolumeId:   "vol-test",
+					VolumePath: VolumePath,
+				}
+				_, err := awsDriver.NodeGetVolumeStats(context.TODO(), req)
+				expectErr(t, err, codes.Internal)
 			},
 		},
 	}

pkg/driver/sanity_test.go

@@ -56,7 +56,6 @@ func TestSanity(t *testing.T) {
 				AvailabilityZone: "az",
 			},
 			mounter:       newFakeMounter(),
-			statter:       NewFakeStatter(),
 			inFlight:      internal.NewInFlight(),
 			driverOptions: &DriverOptions{},
 		},
@@ -351,19 +350,3 @@ func (f *fakeMounter) ExistsPath(filename string) (bool, error) {
 	}
 	return true, nil
 }
-
-type fakeStatter struct{}
-
-func NewFakeStatter() fakeStatter {
-	return fakeStatter{}
-}
-
-func (fakeStatter) StatFS(path string) (available, capacity, used, inodesFree, inodes, inodesUsed int64, err error) {
-	// Assume the file exists and give some dummy values back
-	one := int64(1)
-	return one, one, one, one, one, one, nil
-}
-
-func (fakeStatter) IsBlockDevice(fullPath string) (bool, error) {
-	return false, nil
-}