mirrors/ceph-csi
1
0
Fork 0
mirror of https://github.com/ceph/ceph-csi.git synced 2024-11-09 16:00:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

util: address golangci-lint issues

Browse Source 
address golangci-lint issues in utils

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>
This commit is contained in:
Madhu Rajanna 2024-04-04 10:53:45 +02:00 committed by mergify[bot]
parent 8c4a38eec6
commit 4b7cafe821
17 changed files with 161 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
internal/util/cephcmds.go
View File

@ -48,7 +48,7 @@ func ExecuteCommandWithNSEnter(ctx context.Context, netPath, program string, arg
return "", "", fmt.Errorf("failed to get stat for %s %w", netPath, err) return "", "", fmt.Errorf("failed to get stat for %s %w", netPath, err)
} }
// nsenter --net=%s -- <program> <args> // nsenter --net=%s -- <program> <args>
args = append([]string{fmt.Sprintf("--net=%s", netPath), "--", program}, args...) args = append([]string{"--net=" + netPath, "--", program}, args...)
sanitizedArgs := StripSecretInArgs(args) sanitizedArgs := StripSecretInArgs(args)
cmd := exec.Command(nsenter, args...) // #nosec:G204, commands executing not vulnerable. cmd := exec.Command(nsenter, args...) // #nosec:G204, commands executing not vulnerable.
cmd.Stdout = &stdoutBuf cmd.Stdout = &stdoutBuf

2
internal/util/cluster_mapping_test.go
View File

@ -159,7 +159,7 @@ func TestGetClusterMappingInfo(t *testing.T) {
}) })
} }
clusterMappingConfigFile = fmt.Sprintf("%s/mapping.json", mappingBasePath) clusterMappingConfigFile = mappingBasePath + "/mapping.json"
err = os.WriteFile(clusterMappingConfigFile, mappingFileContent, 0o600) err = os.WriteFile(clusterMappingConfigFile, mappingFileContent, 0o600)
if err != nil { if err != nil {
t.Errorf("failed to write mapping content error = %v", err) t.Errorf("failed to write mapping content error = %v", err)

4
internal/util/crushlocation_test.go
View File

@ -19,7 +19,7 @@ package util
import ( import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
func Test_getCrushLocationMap(t *testing.T) { func Test_getCrushLocationMap(t *testing.T) {
@ -105,7 +105,7 @@ func Test_getCrushLocationMap(t *testing.T) {
currentTT := tt currentTT := tt
t.Run(currentTT.name, func(t *testing.T) { t.Run(currentTT.name, func(t *testing.T) {
t.Parallel() t.Parallel()
assert.Equal(t, require.Equal(t,
currentTT.want, currentTT.want,
getCrushLocationMap(currentTT.args.crushLocationLabels, currentTT.args.nodeLabels)) getCrushLocationMap(currentTT.args.crushLocationLabels, currentTT.args.nodeLabels))
}) })

47
internal/util/crypto_test.go
View File

@ -23,7 +23,6 @@ import (
"github.com/ceph/ceph-csi/internal/kms" "github.com/ceph/ceph-csi/internal/kms"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
@ -35,8 +34,8 @@ func TestGenerateNewEncryptionPassphrase(t *testing.T) {
// b64Passphrase is URL-encoded, decode to verify the length of the // b64Passphrase is URL-encoded, decode to verify the length of the
// passphrase // passphrase
passphrase, err := base64.URLEncoding.DecodeString(b64Passphrase) passphrase, err := base64.URLEncoding.DecodeString(b64Passphrase)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, defaultEncryptionPassphraseSize, len(passphrase)) require.Len(t, passphrase, defaultEncryptionPassphraseSize)
} }
func TestKMSWorkflow(t *testing.T) { func TestKMSWorkflow(t *testing.T) {
@ -47,52 +46,52 @@ func TestKMSWorkflow(t *testing.T) {
} }
kmsProvider, err := kms.GetDefaultKMS(secrets) kmsProvider, err := kms.GetDefaultKMS(secrets)
assert.NoError(t, err) require.NoError(t, err)
require.NotNil(t, kmsProvider) require.NotNil(t, kmsProvider)
ve, err := NewVolumeEncryption("", kmsProvider) ve, err := NewVolumeEncryption("", kmsProvider)
assert.NoError(t, err) require.NoError(t, err)
require.NotNil(t, ve) require.NotNil(t, ve)
assert.Equal(t, kms.DefaultKMSType, ve.GetID()) require.Equal(t, kms.DefaultKMSType, ve.GetID())
volumeID := "volume-id" volumeID := "volume-id"
ctx := context.TODO() ctx := context.TODO()
err = ve.StoreNewCryptoPassphrase(ctx, volumeID, defaultEncryptionPassphraseSize) err = ve.StoreNewCryptoPassphrase(ctx, volumeID, defaultEncryptionPassphraseSize)
assert.NoError(t, err) require.NoError(t, err)
passphrase, err := ve.GetCryptoPassphrase(ctx, volumeID) passphrase, err := ve.GetCryptoPassphrase(ctx, volumeID)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, secrets["encryptionPassphrase"], passphrase) require.Equal(t, secrets["encryptionPassphrase"], passphrase)
} }
func TestEncryptionType(t *testing.T) { func TestEncryptionType(t *testing.T) {
t.Parallel() t.Parallel()
assert.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("wat?")) require.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("wat?"))
assert.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("both")) require.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("both"))
assert.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("file,block")) require.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("file,block"))
assert.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("block,file")) require.EqualValues(t, EncryptionTypeInvalid, ParseEncryptionType("block,file"))
assert.EqualValues(t, EncryptionTypeBlock, ParseEncryptionType("block")) require.EqualValues(t, EncryptionTypeBlock, ParseEncryptionType("block"))
assert.EqualValues(t, EncryptionTypeFile, ParseEncryptionType("file")) require.EqualValues(t, EncryptionTypeFile, ParseEncryptionType("file"))
assert.EqualValues(t, EncryptionTypeNone, ParseEncryptionType("")) require.EqualValues(t, EncryptionTypeNone, ParseEncryptionType(""))
for _, s := range []string{"file", "block", ""} { for _, s := range []string{"file", "block", ""} {
assert.EqualValues(t, s, ParseEncryptionType(s).String()) require.EqualValues(t, s, ParseEncryptionType(s).String())
} }
} }
func TestFetchEncryptionType(t *testing.T) { func TestFetchEncryptionType(t *testing.T) {
t.Parallel() t.Parallel()
volOpts := map[string]string{} volOpts := map[string]string{}
assert.EqualValues(t, EncryptionTypeBlock, FetchEncryptionType(volOpts, EncryptionTypeBlock)) require.EqualValues(t, EncryptionTypeBlock, FetchEncryptionType(volOpts, EncryptionTypeBlock))
assert.EqualValues(t, EncryptionTypeFile, FetchEncryptionType(volOpts, EncryptionTypeFile)) require.EqualValues(t, EncryptionTypeFile, FetchEncryptionType(volOpts, EncryptionTypeFile))
assert.EqualValues(t, EncryptionTypeNone, FetchEncryptionType(volOpts, EncryptionTypeNone)) require.EqualValues(t, EncryptionTypeNone, FetchEncryptionType(volOpts, EncryptionTypeNone))
volOpts["encryptionType"] = "" volOpts["encryptionType"] = ""
assert.EqualValues(t, EncryptionTypeInvalid, FetchEncryptionType(volOpts, EncryptionTypeNone)) require.EqualValues(t, EncryptionTypeInvalid, FetchEncryptionType(volOpts, EncryptionTypeNone))
volOpts["encryptionType"] = "block" volOpts["encryptionType"] = "block"
assert.EqualValues(t, EncryptionTypeBlock, FetchEncryptionType(volOpts, EncryptionTypeNone)) require.EqualValues(t, EncryptionTypeBlock, FetchEncryptionType(volOpts, EncryptionTypeNone))
volOpts["encryptionType"] = "file" volOpts["encryptionType"] = "file"
assert.EqualValues(t, EncryptionTypeFile, FetchEncryptionType(volOpts, EncryptionTypeNone)) require.EqualValues(t, EncryptionTypeFile, FetchEncryptionType(volOpts, EncryptionTypeNone))
volOpts["encryptionType"] = "INVALID" volOpts["encryptionType"] = "INVALID"
assert.EqualValues(t, EncryptionTypeInvalid, FetchEncryptionType(volOpts, EncryptionTypeNone)) require.EqualValues(t, EncryptionTypeInvalid, FetchEncryptionType(volOpts, EncryptionTypeNone))
} }

2
internal/util/fscrypt/fscrypt.go
View File

@ -463,5 +463,5 @@ func Unlock(
return initializeAndUnlock(ctx, fscryptContext, encryptedPath, protectorName, keyFn) return initializeAndUnlock(ctx, fscryptContext, encryptedPath, protectorName, keyFn)
} }
return fmt.Errorf("unsupported") return errors.New("unsupported")
} }

10
internal/util/getsecret_test.go
View File

@ -20,7 +20,7 @@ import (
kmsapi "github.com/ceph/ceph-csi/internal/kms" kmsapi "github.com/ceph/ceph-csi/internal/kms"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
func TestGetPassphraseFromKMS(t *testing.T) { func TestGetPassphraseFromKMS(t *testing.T) {
@ -31,7 +31,7 @@ func TestGetPassphraseFromKMS(t *testing.T) {
continue continue
} }
kms := kmsapi.GetKMSTestDummy(provider.UniqueID) kms := kmsapi.GetKMSTestDummy(provider.UniqueID)
assert.NotNil(t, kms) require.NotNil(t, kms)
volEnc, err := NewVolumeEncryption(provider.UniqueID, kms) volEnc, err := NewVolumeEncryption(provider.UniqueID, kms)
if errors.Is(err, ErrDEKStoreNeeded) { if errors.Is(err, ErrDEKStoreNeeded) {
@ -40,14 +40,14 @@ func TestGetPassphraseFromKMS(t *testing.T) {
continue // currently unsupported by fscrypt integration continue // currently unsupported by fscrypt integration
} }
} }
assert.NotNil(t, volEnc) require.NotNil(t, volEnc)
if kms.RequiresDEKStore() == kmsapi.DEKStoreIntegrated { if kms.RequiresDEKStore() == kmsapi.DEKStoreIntegrated {
continue continue
} }
secret, err := kms.GetSecret(context.TODO(), "") secret, err := kms.GetSecret(context.TODO(), "")
assert.NoError(t, err, provider.UniqueID) require.NoError(t, err, provider.UniqueID)
assert.NotEmpty(t, secret, provider.UniqueID) require.NotEmpty(t, secret, provider.UniqueID)
} }
} }

4
internal/util/pidlimit.go
View File

@ -70,7 +70,7 @@ func getCgroupPidsFile() (string, error) {
} }
} }
if slice == "" { if slice == "" {
return "", fmt.Errorf("could not find a cgroup for 'pids'") return "", errors.New("could not find a cgroup for 'pids'")
} }
return pidsMax, nil return pidsMax, nil
@ -112,7 +112,7 @@ func GetPIDLimit() (int, error) {
func SetPIDLimit(limit int) error { func SetPIDLimit(limit int) error {
limitStr := "max" limitStr := "max"
if limit != -1 { if limit != -1 {
limitStr = fmt.Sprintf("%d", limit) limitStr = strconv.Itoa(limit)
} }
pidsMax, err := getCgroupPidsFile() pidsMax, err := getCgroupPidsFile()

4
internal/util/read_affinity_test.go
View File

@ -19,7 +19,7 @@ package util
import ( import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
func TestReadAffinity_ConstructReadAffinityMapOption(t *testing.T) { func TestReadAffinity_ConstructReadAffinityMapOption(t *testing.T) {
@ -62,7 +62,7 @@ func TestReadAffinity_ConstructReadAffinityMapOption(t *testing.T) {
currentTT := tt currentTT := tt
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
t.Parallel() t.Parallel()
assert.Contains(t, currentTT.wantAny, ConstructReadAffinityMapOption(currentTT.crushLocationmap)) require.Contains(t, currentTT.wantAny, ConstructReadAffinityMapOption(currentTT.crushLocationmap))
}) })
} }
} }

1
internal/util/reftracker/errors/errors.go
View File

@ -70,7 +70,6 @@ func TryRADOSAborted(opErr error) error {
return opErr return opErr
} }
//nolint:errorlint // Can't use errors.As() because rados.radosError is private.
errnoErr, ok := radosOpErr.OpError.(interface{ ErrorCode() int }) errnoErr, ok := radosOpErr.OpError.(interface{ ErrorCode() int })
if !ok { if !ok {
return opErr return opErr

170
internal/util/reftracker/reftracker_test.go
View File

@ -22,7 +22,7 @@ import (
"github.com/ceph/ceph-csi/internal/util/reftracker/radoswrapper" "github.com/ceph/ceph-csi/internal/util/reftracker/radoswrapper"
"github.com/ceph/ceph-csi/internal/util/reftracker/reftype" "github.com/ceph/ceph-csi/internal/util/reftracker/reftype"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
const rtName = "hello-rt" const rtName = "hello-rt"
@ -36,8 +36,8 @@ func TestRTAdd(t *testing.T) {
ioctx := radoswrapper.NewFakeIOContext(radoswrapper.NewFakeRados()) ioctx := radoswrapper.NewFakeIOContext(radoswrapper.NewFakeRados())
created, err := Add(ioctx, "", nil) created, err := Add(ioctx, "", nil)
assert.Error(ts, err) require.Error(ts, err)
assert.False(ts, created) require.False(ts, created)
}) })
// Verify input validation for nil and empty refs. // Verify input validation for nil and empty refs.
@ -51,8 +51,8 @@ func TestRTAdd(t *testing.T) {
} }
for _, ref := range refs { for _, ref := range refs {
created, err := Add(ioctx, rtName, ref) created, err := Add(ioctx, rtName, ref)
assert.Error(ts, err) require.Error(ts, err)
assert.False(ts, created) require.False(ts, created)
} }
}) })
@ -66,8 +66,8 @@ func TestRTAdd(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
}) })
// Add refs where each Add() has some of the refs overlapping // Add refs where each Add() has some of the refs overlapping
@ -80,8 +80,8 @@ func TestRTAdd(t *testing.T) {
"ref1": {}, "ref1": {},
"ref2": {}, "ref2": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
refsTable := []map[string]struct{}{ refsTable := []map[string]struct{}{
{"ref2": {}, "ref3": {}}, {"ref2": {}, "ref3": {}},
@ -90,8 +90,8 @@ func TestRTAdd(t *testing.T) {
} }
for _, refs := range refsTable { for _, refs := range refsTable {
created, err = Add(ioctx, rtName, refs) created, err = Add(ioctx, rtName, refs)
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, created) require.False(ts, created)
} }
}) })
} }
@ -110,8 +110,8 @@ func TestRTRemove(t *testing.T) {
} }
for _, ref := range refs { for _, ref := range refs {
created, err := Remove(ioctx, rtName, ref) created, err := Remove(ioctx, rtName, ref)
assert.Error(ts, err) require.Error(ts, err)
assert.False(ts, created) require.False(ts, created)
} }
}) })
@ -124,8 +124,8 @@ func TestRTRemove(t *testing.T) {
deleted, err := Remove(ioctx, "xxx", map[string]reftype.RefType{ deleted, err := Remove(ioctx, "xxx", map[string]reftype.RefType{
"ref1": reftype.Normal, "ref1": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Removing only non-existent refs should not result in reftracker object // Removing only non-existent refs should not result in reftracker object
@ -140,16 +140,16 @@ func TestRTRemove(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"refX": reftype.Normal, "refX": reftype.Normal,
"refY": reftype.Normal, "refY": reftype.Normal,
"refZ": reftype.Normal, "refZ": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, deleted) require.False(ts, deleted)
}) })
// Removing all refs plus some surplus should result in reftracker object // Removing all refs plus some surplus should result in reftracker object
@ -162,8 +162,8 @@ func TestRTRemove(t *testing.T) {
created, err := Add(ioctx, rtName, map[string]struct{}{ created, err := Add(ioctx, rtName, map[string]struct{}{
"ref": {}, "ref": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"refX": reftype.Normal, "refX": reftype.Normal,
@ -171,8 +171,8 @@ func TestRTRemove(t *testing.T) {
"ref": reftype.Normal, "ref": reftype.Normal,
"refZ": reftype.Normal, "refZ": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Bulk removal of all refs should result in reftracker object deletion. // Bulk removal of all refs should result in reftracker object deletion.
@ -189,12 +189,12 @@ func TestRTRemove(t *testing.T) {
} }
created, err := Add(ioctx, rtName, refsToAdd) created, err := Add(ioctx, rtName, refsToAdd)
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, refsToRemove) deleted, err := Remove(ioctx, rtName, refsToRemove)
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Removal of all refs one-by-one should result in reftracker object deletion // Removal of all refs one-by-one should result in reftracker object deletion
@ -209,23 +209,23 @@ func TestRTRemove(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
for _, k := range []string{"ref3", "ref2"} { for _, k := range []string{"ref3", "ref2"} {
deleted, errRemove := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, errRemove := Remove(ioctx, rtName, map[string]reftype.RefType{
k: reftype.Normal, k: reftype.Normal,
}) })
assert.NoError(ts, errRemove) require.NoError(ts, errRemove)
assert.False(ts, deleted) require.False(ts, deleted)
} }
// Remove the last reference. It should remove the whole reftracker object too. // Remove the last reference. It should remove the whole reftracker object too.
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Normal, "ref1": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Cycle through reftracker object twice. // Cycle through reftracker object twice.
@ -246,12 +246,12 @@ func TestRTRemove(t *testing.T) {
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
created, err := Add(ioctx, rtName, refsToAdd) created, err := Add(ioctx, rtName, refsToAdd)
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, refsToRemove) deleted, err := Remove(ioctx, rtName, refsToRemove)
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
} }
}) })
@ -265,8 +265,8 @@ func TestRTRemove(t *testing.T) {
"ref1": {}, "ref1": {},
"ref2": {}, "ref2": {},
}) })
assert.True(ts, created) require.True(ts, created)
assert.NoError(ts, err) require.NoError(ts, err)
refsTable := []map[string]struct{}{ refsTable := []map[string]struct{}{
{"ref2": {}, "ref3": {}}, {"ref2": {}, "ref3": {}},
{"ref3": {}, "ref4": {}}, {"ref3": {}, "ref4": {}},
@ -274,8 +274,8 @@ func TestRTRemove(t *testing.T) {
} }
for _, refs := range refsTable { for _, refs := range refsTable {
created, err = Add(ioctx, rtName, refs) created, err = Add(ioctx, rtName, refs)
assert.False(ts, created) require.False(ts, created)
assert.NoError(ts, err) require.NoError(ts, err)
} }
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
@ -285,8 +285,8 @@ func TestRTRemove(t *testing.T) {
"ref4": reftype.Normal, "ref4": reftype.Normal,
"ref5": reftype.Normal, "ref5": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
} }
@ -307,12 +307,12 @@ func TestRTMask(t *testing.T) {
} }
created, err := Add(ioctx, rtName, refsToAdd) created, err := Add(ioctx, rtName, refsToAdd)
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, refsToRemove) deleted, err := Remove(ioctx, rtName, refsToRemove)
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Masking all refs one-by-one should result in reftracker object deletion in // Masking all refs one-by-one should result in reftracker object deletion in
@ -327,15 +327,15 @@ func TestRTMask(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
for _, k := range []string{"ref3", "ref2"} { for _, k := range []string{"ref3", "ref2"} {
deleted, errRemove := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, errRemove := Remove(ioctx, rtName, map[string]reftype.RefType{
k: reftype.Mask, k: reftype.Mask,
}) })
assert.NoError(ts, errRemove) require.NoError(ts, errRemove)
assert.False(ts, deleted) require.False(ts, deleted)
} }
// Remove the last reference. It should delete the whole reftracker object // Remove the last reference. It should delete the whole reftracker object
@ -343,8 +343,8 @@ func TestRTMask(t *testing.T) {
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Mask, "ref1": reftype.Mask,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Bulk removing two (out of 3) refs and then masking the ref that's left // Bulk removing two (out of 3) refs and then masking the ref that's left
@ -359,21 +359,21 @@ func TestRTMask(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Normal, "ref1": reftype.Normal,
"ref2": reftype.Normal, "ref2": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, deleted) require.False(ts, deleted)
deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{
"ref3": reftype.Mask, "ref3": reftype.Mask,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Bulk masking two (out of 3) refs and then removing the ref that's left // Bulk masking two (out of 3) refs and then removing the ref that's left
@ -388,21 +388,21 @@ func TestRTMask(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Mask, "ref1": reftype.Mask,
"ref2": reftype.Mask, "ref2": reftype.Mask,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, deleted) require.False(ts, deleted)
deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{
"ref3": reftype.Normal, "ref3": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Verify that masking refs hides them from future Add()s. // Verify that masking refs hides them from future Add()s.
@ -416,28 +416,28 @@ func TestRTMask(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Mask, "ref1": reftype.Mask,
"ref2": reftype.Mask, "ref2": reftype.Mask,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, deleted) require.False(ts, deleted)
created, err = Add(ioctx, rtName, map[string]struct{}{ created, err = Add(ioctx, rtName, map[string]struct{}{
"ref1": {}, "ref1": {},
"ref2": {}, "ref2": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, created) require.False(ts, created)
deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{
"ref3": reftype.Normal, "ref3": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
// Verify that masked refs may be removed with reftype.Normal and re-added. // Verify that masked refs may be removed with reftype.Normal and re-added.
@ -451,41 +451,41 @@ func TestRTMask(t *testing.T) {
"ref2": {}, "ref2": {},
"ref3": {}, "ref3": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, created) require.True(ts, created)
deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err := Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Mask, "ref1": reftype.Mask,
"ref2": reftype.Mask, "ref2": reftype.Mask,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, deleted) require.False(ts, deleted)
deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Normal, "ref1": reftype.Normal,
"ref2": reftype.Normal, "ref2": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, deleted) require.False(ts, deleted)
created, err = Add(ioctx, rtName, map[string]struct{}{ created, err = Add(ioctx, rtName, map[string]struct{}{
"ref1": {}, "ref1": {},
"ref2": {}, "ref2": {},
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, created) require.False(ts, created)
deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{
"ref3": reftype.Normal, "ref3": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.False(ts, deleted) require.False(ts, deleted)
deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{ deleted, err = Remove(ioctx, rtName, map[string]reftype.RefType{
"ref1": reftype.Normal, "ref1": reftype.Normal,
"ref2": reftype.Normal, "ref2": reftype.Normal,
}) })
assert.NoError(ts, err) require.NoError(ts, err)
assert.True(ts, deleted) require.True(ts, deleted)
}) })
} }

12
internal/util/reftracker/reftype/reftype_test.go
View File

@ -19,7 +19,7 @@ package reftype
import ( import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
func TestRefTypeBytes(t *testing.T) { func TestRefTypeBytes(t *testing.T) {
@ -41,7 +41,7 @@ func TestRefTypeBytes(t *testing.T) {
for i := range expectedBytes { for i := range expectedBytes {
bs := ToBytes(refTypes[i]) bs := ToBytes(refTypes[i])
assert.Equal(ts, expectedBytes[i], bs) require.Equal(ts, expectedBytes[i], bs)
} }
}) })
@ -50,14 +50,14 @@ func TestRefTypeBytes(t *testing.T) {
for i := range refTypes { for i := range refTypes {
refType, err := FromBytes(expectedBytes[i]) refType, err := FromBytes(expectedBytes[i])
assert.NoError(ts, err) require.NoError(ts, err)
assert.Equal(ts, refTypes[i], refType) require.Equal(ts, refTypes[i], refType)
} }
_, err := FromBytes(refTypeInvalidBytes) _, err := FromBytes(refTypeInvalidBytes)
assert.Error(ts, err) require.Error(ts, err)
_, err = FromBytes(refTypeWrongSizeBytes) _, err = FromBytes(refTypeWrongSizeBytes)
assert.Error(ts, err) require.Error(ts, err)
}) })
} }

10
internal/util/reftracker/v1/refcount_test.go
View File

@ -19,7 +19,7 @@ package v1
import ( import (
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
func TestV1RefCountBytes(t *testing.T) { func TestV1RefCountBytes(t *testing.T) {
@ -35,17 +35,17 @@ func TestV1RefCountBytes(t *testing.T) {
ts.Parallel() ts.Parallel()
bs := refCountValue.toBytes() bs := refCountValue.toBytes()
assert.Equal(ts, refCountBytes, bs) require.Equal(ts, refCountBytes, bs)
}) })
t.Run("FromBytes", func(ts *testing.T) { t.Run("FromBytes", func(ts *testing.T) {
ts.Parallel() ts.Parallel()
rc, err := refCountFromBytes(refCountBytes) rc, err := refCountFromBytes(refCountBytes)
assert.NoError(ts, err) require.NoError(ts, err)
assert.Equal(ts, refCountValue, rc) require.Equal(ts, refCountValue, rc)
_, err = refCountFromBytes(wrongSizeRefCountBytes) _, err = refCountFromBytes(wrongSizeRefCountBytes)
assert.Error(ts, err) require.Error(ts, err)
}) })
} }

2
internal/util/reftracker/v1/v1.go
View File

@ -205,7 +205,7 @@ func Remove(
if rcToSubtract > readRes.total { if rcToSubtract > readRes.total {
// BUG: this should never happen! // BUG: this should never happen!
return false, fmt.Errorf("refcount underflow, reftracker object corrupted") return false, goerrors.New("refcount underflow, reftracker object corrupted")
} }
newRC := readRes.total - rcToSubtract newRC := readRes.total - rcToSubtract

35
internal/util/reftracker/v1/v1_test.go
View File

@ -17,14 +17,13 @@ limitations under the License.
package v1 package v1
import ( import (
goerrors "errors"
"testing" "testing"
"github.com/ceph/ceph-csi/internal/util/reftracker/errors" "github.com/ceph/ceph-csi/internal/util/reftracker/errors"
"github.com/ceph/ceph-csi/internal/util/reftracker/radoswrapper" "github.com/ceph/ceph-csi/internal/util/reftracker/radoswrapper"
"github.com/ceph/ceph-csi/internal/util/reftracker/reftype" "github.com/ceph/ceph-csi/internal/util/reftracker/reftype"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
func TestV1Read(t *testing.T) { func TestV1Read(t *testing.T) {
@ -73,17 +72,17 @@ func TestV1Read(t *testing.T) {
) )
err := Add(validObj, rtName, gen, refsToAdd) err := Add(validObj, rtName, gen, refsToAdd)
assert.NoError(t, err) require.NoError(t, err)
for i := range invalidObjs { for i := range invalidObjs {
err = Add(invalidObjs[i], rtName, gen, refsToAdd) err = Add(invalidObjs[i], rtName, gen, refsToAdd)
assert.Error(t, err) require.Error(t, err)
} }
// Check for correct error type for wrong gen num. // Check for correct error type for wrong gen num.
err = Add(invalidObjs[1], rtName, gen, refsToAdd) err = Add(invalidObjs[1], rtName, gen, refsToAdd)
assert.Error(t, err) require.Error(t, err)
assert.True(t, goerrors.Is(err, errors.ErrObjectOutOfDate)) require.ErrorIs(t, err, errors.ErrObjectOutOfDate)
} }
func TestV1Init(t *testing.T) { func TestV1Init(t *testing.T) {
@ -106,10 +105,10 @@ func TestV1Init(t *testing.T) {
) )
err := Init(emptyRados, rtName, refsToInit) err := Init(emptyRados, rtName, refsToInit)
assert.NoError(t, err) require.NoError(t, err)
err = Init(alreadyExists, rtName, refsToInit) err = Init(alreadyExists, rtName, refsToInit)
assert.Error(t, err) require.Error(t, err)
} }
func TestV1Add(t *testing.T) { func TestV1Add(t *testing.T) {
@ -224,19 +223,19 @@ func TestV1Add(t *testing.T) {
ioctx.Rados.Objs[rtName] = shouldSucceed[i].before ioctx.Rados.Objs[rtName] = shouldSucceed[i].before
err := Add(ioctx, rtName, 0, shouldSucceed[i].refsToAdd) err := Add(ioctx, rtName, 0, shouldSucceed[i].refsToAdd)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, shouldSucceed[i].after, ioctx.Rados.Objs[rtName]) require.Equal(t, shouldSucceed[i].after, ioctx.Rados.Objs[rtName])
} }
for i := range shouldFail { for i := range shouldFail {
err := Add(shouldFail[i], rtName, 0, map[string]struct{}{"ref1": {}}) err := Add(shouldFail[i], rtName, 0, map[string]struct{}{"ref1": {}})
assert.Error(t, err) require.Error(t, err)
} }
// Check for correct error type for wrong gen num. // Check for correct error type for wrong gen num.
err := Add(shouldFail[1], rtName, 0, map[string]struct{}{"ref1": {}}) err := Add(shouldFail[1], rtName, 0, map[string]struct{}{"ref1": {}})
assert.Error(t, err) require.Error(t, err)
assert.True(t, goerrors.Is(err, errors.ErrObjectOutOfDate)) require.ErrorIs(t, err, errors.ErrObjectOutOfDate)
} }
func TestV1Remove(t *testing.T) { func TestV1Remove(t *testing.T) {
@ -412,12 +411,12 @@ func TestV1Remove(t *testing.T) {
ioctx.Rados.Objs[rtName] = shouldSucceed[i].before ioctx.Rados.Objs[rtName] = shouldSucceed[i].before
deleted, err := Remove(ioctx, rtName, 0, shouldSucceed[i].refsToRemove) deleted, err := Remove(ioctx, rtName, 0, shouldSucceed[i].refsToRemove)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, shouldSucceed[i].deleted, deleted) require.Equal(t, shouldSucceed[i].deleted, deleted)
assert.Equal(t, shouldSucceed[i].after, ioctx.Rados.Objs[rtName]) require.Equal(t, shouldSucceed[i].after, ioctx.Rados.Objs[rtName])
} }
_, err := Remove(badGen, rtName, 0, map[string]reftype.RefType{"ref": reftype.Normal}) _, err := Remove(badGen, rtName, 0, map[string]reftype.RefType{"ref": reftype.Normal})
assert.Error(t, err) require.Error(t, err)
assert.True(t, goerrors.Is(err, errors.ErrObjectOutOfDate)) require.ErrorIs(t, err, errors.ErrObjectOutOfDate)
} }

16
internal/util/reftracker/version/version_test.go
View File

@ -21,7 +21,7 @@ import (
"github.com/ceph/ceph-csi/internal/util/reftracker/radoswrapper" "github.com/ceph/ceph-csi/internal/util/reftracker/radoswrapper"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/require"
) )
var ( var (
@ -38,18 +38,18 @@ func TestVersionBytes(t *testing.T) {
ts.Parallel() ts.Parallel()
bs := ToBytes(v1Value) bs := ToBytes(v1Value)
assert.Equal(ts, v1Bytes, bs) require.Equal(ts, v1Bytes, bs)
}) })
t.Run("FromBytes", func(ts *testing.T) { t.Run("FromBytes", func(ts *testing.T) {
ts.Parallel() ts.Parallel()
ver, err := FromBytes(v1Bytes) ver, err := FromBytes(v1Bytes)
assert.NoError(ts, err) require.NoError(ts, err)
assert.Equal(ts, v1Value, ver) require.Equal(ts, v1Value, ver)
_, err = FromBytes(wrongSizeVersionBytes) _, err = FromBytes(wrongSizeVersionBytes)
assert.Error(ts, err) require.Error(ts, err)
}) })
} }
@ -101,11 +101,11 @@ func TestVersionRead(t *testing.T) {
) )
ver, err := Read(validObj, rtName) ver, err := Read(validObj, rtName)
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, v1Value, ver) require.Equal(t, v1Value, ver)
for i := range invalidObjs { for i := range invalidObjs {
_, err = Read(invalidObjs[i], rtName) _, err = Read(invalidObjs[i], rtName)
assert.Error(t, err) require.Error(t, err)
} }
} }

2
internal/util/util.go
View File

@ -212,7 +212,7 @@ func parseKernelRelease(release string) (int, int, int, int, error) {
extraversion := 0 extraversion := 0
if n > minVersions { if n > minVersions {
n, err = fmt.Sscanf(extra, ".%d%s", &sublevel, &extra) n, err = fmt.Sscanf(extra, ".%d%s", &sublevel, &extra)
if err != nil && n == 0 && len(extra) > 0 && extra[0] != '-' && extra[0] == '.' { if err != nil && n == 0 && extra != "" && extra[0] != '-' && extra[0] == '.' {
return 0, 0, 0, 0, fmt.Errorf("failed to parse subversion from %s: %w", release, err) return 0, 0, 0, 0, fmt.Errorf("failed to parse subversion from %s: %w", release, err)
} }

2
internal/util/validate.go
View File

@ -87,7 +87,7 @@ func ValidateNodeUnpublishVolumeRequest(req *csi.NodeUnpublishVolumeRequest) err
// volume is from source as empty ReadOnlyMany is not supported. // volume is from source as empty ReadOnlyMany is not supported.
func CheckReadOnlyManyIsSupported(req *csi.CreateVolumeRequest) error { func CheckReadOnlyManyIsSupported(req *csi.CreateVolumeRequest) error {
for _, capability := range req.GetVolumeCapabilities() { for _, capability := range req.GetVolumeCapabilities() {
if m := capability.GetAccessMode().Mode; m == csi.VolumeCapability_AccessMode_MULTI_NODE_READER_ONLY || if m := capability.GetAccessMode().GetMode(); m == csi.VolumeCapability_AccessMode_MULTI_NODE_READER_ONLY ||
m == csi.VolumeCapability_AccessMode_SINGLE_NODE_READER_ONLY { m == csi.VolumeCapability_AccessMode_SINGLE_NODE_READER_ONLY {
if req.GetVolumeContentSource() == nil { if req.GetVolumeContentSource() == nil {
return status.Error(codes.InvalidArgument, "readOnly accessMode is supported only with content source") return status.Error(codes.InvalidArgument, "readOnly accessMode is supported only with content source")