chore: fix golint

andyzhangx · andyzhangx · commit 3f38c89cbec5 · 2025-04-14T04:10:51.000Z
diff --git a/.github/workflows/static.yaml b/.github/workflows/static.yaml
@@ -15,5 +15,5 @@ jobs:
             - name: Run linter
               uses: golangci/golangci-lint-action@v6
               with:
-                  version: v1.60
-                  args: -E=gofmt,unused,ineffassign,revive,misspell,copyloopvar,asciicheck,bodyclose,depguard,dogsled,dupl,durationcheck,errname,forbidigo -D=staticcheck --timeout=30m0s
+                  version: v1.64
+                  args: -E=gofmt,unused,ineffassign,revive,misspell,copyloopvar,asciicheck,bodyclose,dogsled,dupl,durationcheck,errname,forbidigo -D=staticcheck --timeout=30m0s
diff --git a/pkg/azurefile/controllerserver.go b/pkg/azurefile/controllerserver.go
@@ -1389,16 +1389,16 @@ func isValidVolumeCapabilities(volCaps []*csi.VolumeCapability) error {
 	if len(volCaps) == 0 {
 		return fmt.Errorf("CreateVolume Volume capabilities must be provided")
 	}
-	hasSupport := func(cap *csi.VolumeCapability) error {
-		if blk := cap.GetBlock(); blk != nil {
+	hasSupport := func(c *csi.VolumeCapability) error {
+		if blk := c.GetBlock(); blk != nil {
 			return fmt.Errorf("driver does not support block volumes")
 		}
-		for _, c := range volumeCaps {
-			if c.GetMode() == cap.AccessMode.GetMode() {
+		for _, vc := range volumeCaps {
+			if vc.GetMode() == c.AccessMode.GetMode() {
 				return nil
 			}
 		}
-		return fmt.Errorf("driver does not support access mode %v", cap.AccessMode.GetMode())
+		return fmt.Errorf("driver does not support access mode %v", c.AccessMode.GetMode())
 	}
 
 	for _, c := range volCaps {
diff --git a/pkg/csi-common/driver.go b/pkg/csi-common/driver.go
@@ -65,8 +65,8 @@ func (d *CSIDriver) ValidateControllerServiceRequest(c csi.ControllerServiceCapa
 		return nil
 	}
 
-	for _, cap := range d.Cap {
-		if c == cap.GetRpc().GetType() {
+	for _, capability := range d.Cap {
+		if c == capability.GetRpc().GetType() {
 			return nil
 		}
 	}
@@ -78,8 +78,8 @@ func (d *CSIDriver) ValidateNodeServiceRequest(c csi.NodeServiceCapability_RPC_T
 		return nil
 	}
 
-	for _, cap := range d.NSCap {
-		if c == cap.GetRpc().GetType() {
+	for _, capability := range d.NSCap {
+		if c == capability.GetRpc().GetType() {
 			return nil
 		}
 	}
diff --git a/pkg/csi-common/utils.go b/pkg/csi-common/utils.go
@@ -71,21 +71,21 @@ func NewVolumeCapabilityAccessMode(mode csi.VolumeCapability_AccessMode_Mode) *c
 	return &csi.VolumeCapability_AccessMode{Mode: mode}
 }
 
-func NewControllerServiceCapability(cap csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {
+func NewControllerServiceCapability(c csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {
 	return &csi.ControllerServiceCapability{
 		Type: &csi.ControllerServiceCapability_Rpc{
 			Rpc: &csi.ControllerServiceCapability_RPC{
-				Type: cap,
+				Type: c,
 			},
 		},
 	}
 }
 
-func NewNodeServiceCapability(cap csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {
+func NewNodeServiceCapability(c csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {
 	return &csi.NodeServiceCapability{
 		Type: &csi.NodeServiceCapability_Rpc{
 			Rpc: &csi.NodeServiceCapability_RPC{
-				Type: cap,
+				Type: c,
 			},
 		},
 	}
diff --git a/pkg/csi-common/utils_test.go b/pkg/csi-common/utils_test.go
@@ -220,52 +220,52 @@ func TestNewVolumeCapabilityAccessMode(t *testing.T) {
 
 func TestNewControllerServiceCapability(t *testing.T) {
 	tests := []struct {
-		cap csi.ControllerServiceCapability_RPC_Type
+		c csi.ControllerServiceCapability_RPC_Type
 	}{
 		{
-			cap: csi.ControllerServiceCapability_RPC_UNKNOWN,
+			c: csi.ControllerServiceCapability_RPC_UNKNOWN,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,
+			c: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,
+			c: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,
+			c: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_GET_CAPACITY,
+			c: csi.ControllerServiceCapability_RPC_GET_CAPACITY,
 		},
 		{
-			cap: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,
+			c: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,
 		},
 	}
 	for _, test := range tests {
-		resp := NewControllerServiceCapability(test.cap)
+		resp := NewControllerServiceCapability(test.c)
 		assert.NotNil(t, resp)
 	}
 }
 
 func TestNewNodeServiceCapability(t *testing.T) {
 	tests := []struct {
-		cap csi.NodeServiceCapability_RPC_Type
+		c csi.NodeServiceCapability_RPC_Type
 	}{
 		{
-			cap: csi.NodeServiceCapability_RPC_UNKNOWN,
+			c: csi.NodeServiceCapability_RPC_UNKNOWN,
 		},
 		{
-			cap: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,
+			c: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,
 		},
 		{
-			cap: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,
+			c: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,
 		},
 		{
-			cap: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,
+			c: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,
 		},
 	}
 	for _, test := range tests {
-		resp := NewNodeServiceCapability(test.cap)
+		resp := NewNodeServiceCapability(test.c)
 		assert.NotNil(t, resp)
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -1389,16 +1389,16 @@ func isValidVolumeCapabilities(volCaps []*csi.VolumeCapability) error {`
`1389`	`1389`	`if len(volCaps) == 0 {`
`1390`	`1390`	`return fmt.Errorf("CreateVolume Volume capabilities must be provided")`
`1391`	`1391`	`}`
`1392`		`- hasSupport := func(cap *csi.VolumeCapability) error {`
`1393`		`- if blk := cap.GetBlock(); blk != nil {`
	`1392`	`+ hasSupport := func(c *csi.VolumeCapability) error {`
	`1393`	`+ if blk := c.GetBlock(); blk != nil {`
`1394`	`1394`	`return fmt.Errorf("driver does not support block volumes")`
`1395`	`1395`	`}`
`1396`		`- for _, c := range volumeCaps {`
`1397`		`- if c.GetMode() == cap.AccessMode.GetMode() {`
	`1396`	`+ for _, vc := range volumeCaps {`
	`1397`	`+ if vc.GetMode() == c.AccessMode.GetMode() {`
`1398`	`1398`	`return nil`
`1399`	`1399`	`}`
`1400`	`1400`	`}`
`1401`		`- return fmt.Errorf("driver does not support access mode %v", cap.AccessMode.GetMode())`
	`1401`	`+ return fmt.Errorf("driver does not support access mode %v", c.AccessMode.GetMode())`
`1402`	`1402`	`}`
`1403`	`1403`
`1404`	`1404`	`for _, c := range volCaps {`
Original file line number	Diff line number	Diff line change
`@@ -65,8 +65,8 @@ func (d *CSIDriver) ValidateControllerServiceRequest(c csi.ControllerServiceCapa`
`65`	`65`	`return nil`
`66`	`66`	`}`
`67`	`67`
`68`		`- for _, cap := range d.Cap {`
`69`		`- if c == cap.GetRpc().GetType() {`
	`68`	`+ for _, capability := range d.Cap {`
	`69`	`+ if c == capability.GetRpc().GetType() {`
`70`	`70`	`return nil`
`71`	`71`	`}`
`72`	`72`	`}`
`@@ -78,8 +78,8 @@ func (d *CSIDriver) ValidateNodeServiceRequest(c csi.NodeServiceCapability_RPC_T`
`78`	`78`	`return nil`
`79`	`79`	`}`
`80`	`80`
`81`		`- for _, cap := range d.NSCap {`
`82`		`- if c == cap.GetRpc().GetType() {`
	`81`	`+ for _, capability := range d.NSCap {`
	`82`	`+ if c == capability.GetRpc().GetType() {`
`83`	`83`	`return nil`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,21 +71,21 @@ func NewVolumeCapabilityAccessMode(mode csi.VolumeCapability_AccessMode_Mode) *c`
`71`	`71`	`return &csi.VolumeCapability_AccessMode{Mode: mode}`
`72`	`72`	`}`
`73`	`73`
`74`		`-func NewControllerServiceCapability(cap csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {`
	`74`	`+func NewControllerServiceCapability(c csi.ControllerServiceCapability_RPC_Type) *csi.ControllerServiceCapability {`
`75`	`75`	`return &csi.ControllerServiceCapability{`
`76`	`76`	`Type: &csi.ControllerServiceCapability_Rpc{`
`77`	`77`	`Rpc: &csi.ControllerServiceCapability_RPC{`
`78`		`- Type: cap,`
	`78`	`+ Type: c,`
`79`	`79`	`},`
`80`	`80`	`},`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`-func NewNodeServiceCapability(cap csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {`
	`84`	`+func NewNodeServiceCapability(c csi.NodeServiceCapability_RPC_Type) *csi.NodeServiceCapability {`
`85`	`85`	`return &csi.NodeServiceCapability{`
`86`	`86`	`Type: &csi.NodeServiceCapability_Rpc{`
`87`	`87`	`Rpc: &csi.NodeServiceCapability_RPC{`
`88`		`- Type: cap,`
	`88`	`+ Type: c,`
`89`	`89`	`},`
`90`	`90`	`},`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -220,52 +220,52 @@ func TestNewVolumeCapabilityAccessMode(t *testing.T) {`
`220`	`220`
`221`	`221`	`func TestNewControllerServiceCapability(t *testing.T) {`
`222`	`222`	`tests := []struct {`
`223`		`- cap csi.ControllerServiceCapability_RPC_Type`
	`223`	`+ c csi.ControllerServiceCapability_RPC_Type`
`224`	`224`	`}{`
`225`	`225`	`{`
`226`		`- cap: csi.ControllerServiceCapability_RPC_UNKNOWN,`
	`226`	`+ c: csi.ControllerServiceCapability_RPC_UNKNOWN,`
`227`	`227`	`},`
`228`	`228`	`{`
`229`		`- cap: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,`
	`229`	`+ c: csi.ControllerServiceCapability_RPC_CREATE_DELETE_VOLUME,`
`230`	`230`	`},`
`231`	`231`	`{`
`232`		`- cap: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,`
	`232`	`+ c: csi.ControllerServiceCapability_RPC_PUBLISH_UNPUBLISH_VOLUME,`
`233`	`233`	`},`
`234`	`234`	`{`
`235`		`- cap: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,`
	`235`	`+ c: csi.ControllerServiceCapability_RPC_LIST_VOLUMES,`
`236`	`236`	`},`
`237`	`237`	`{`
`238`		`- cap: csi.ControllerServiceCapability_RPC_GET_CAPACITY,`
	`238`	`+ c: csi.ControllerServiceCapability_RPC_GET_CAPACITY,`
`239`	`239`	`},`
`240`	`240`	`{`
`241`		`- cap: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,`
	`241`	`+ c: csi.ControllerServiceCapability_RPC_CLONE_VOLUME,`
`242`	`242`	`},`
`243`	`243`	`}`
`244`	`244`	`for _, test := range tests {`
`245`		`- resp := NewControllerServiceCapability(test.cap)`
	`245`	`+ resp := NewControllerServiceCapability(test.c)`
`246`	`246`	`assert.NotNil(t, resp)`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`func TestNewNodeServiceCapability(t *testing.T) {`
`251`	`251`	`tests := []struct {`
`252`		`- cap csi.NodeServiceCapability_RPC_Type`
	`252`	`+ c csi.NodeServiceCapability_RPC_Type`
`253`	`253`	`}{`
`254`	`254`	`{`
`255`		`- cap: csi.NodeServiceCapability_RPC_UNKNOWN,`
	`255`	`+ c: csi.NodeServiceCapability_RPC_UNKNOWN,`
`256`	`256`	`},`
`257`	`257`	`{`
`258`		`- cap: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,`
	`258`	`+ c: csi.NodeServiceCapability_RPC_STAGE_UNSTAGE_VOLUME,`
`259`	`259`	`},`
`260`	`260`	`{`
`261`		`- cap: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,`
	`261`	`+ c: csi.NodeServiceCapability_RPC_GET_VOLUME_STATS,`
`262`	`262`	`},`
`263`	`263`	`{`
`264`		`- cap: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,`
	`264`	`+ c: csi.NodeServiceCapability_RPC_EXPAND_VOLUME,`
`265`	`265`	`},`
`266`	`266`	`}`
`267`	`267`	`for _, test := range tests {`
`268`		`- resp := NewNodeServiceCapability(test.cap)`
	`268`	`+ resp := NewNodeServiceCapability(test.c)`
`269`	`269`	`assert.NotNil(t, resp)`
`270`	`270`	`}`
`271`	`271`	`}`