chore: enable errorlint linter

Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>

Author: mmorel-35

.golangci.yaml

@@ -314,6 +314,7 @@ linters:
     - durationcheck
     - errcheck
     - errchkjson
+    - errorlint
     - ginkgolinter
     - goconst
     - goheader

internal/hook/wait_exec_hook_handler.go

@@ -190,7 +190,7 @@ func (e *DefaultWaitExecHookHandler) HandleHooks(
 				var hookErr error
 				if hookErr = e.PodCommandExecutor.ExecutePodCommand(hookLog, podMap, pod.Namespace, pod.Name, hook.HookName, eh); hookErr != nil {
 					hookLog.WithError(hookErr).Error("Error executing hook")
-					hookErr = fmt.Errorf("hook %s in container %s failed to execute, err: %v", hook.HookName, hook.Hook.Container, hookErr)
+					hookErr = fmt.Errorf("hook %s in container %s failed to execute, err: %w", hook.HookName, hook.Hook.Container, hookErr)
 					errors = append(errors, hookErr)
 					hookFailed = true
 				}
@@ -243,7 +243,7 @@ func (e *DefaultWaitExecHookHandler) HandleHooks(
 			if hook.executed {
 				continue
 			}
-			err := fmt.Errorf("hook %s in container %s in pod %s not executed: %v", hook.HookName, hook.Hook.Container, kube.NamespaceAndName(pod), ctx.Err())
+			err := fmt.Errorf("hook %s in container %s in pod %s not executed: %w", hook.HookName, hook.Hook.Container, kube.NamespaceAndName(pod), ctx.Err())
 			hookLog := log.WithFields(
 				logrus.Fields{
 					"hookSource": hook.HookSource,

internal/resourcemodifiers/json_merge_patch.go

@@ -20,13 +20,13 @@ type JSONMergePatcher struct {
 func (p *JSONMergePatcher) Patch(u *unstructured.Unstructured, _ logrus.FieldLogger) (*unstructured.Unstructured, error) {
 	objBytes, err := u.MarshalJSON()
 	if err != nil {
-		return nil, fmt.Errorf("error in marshaling object %s", err)
+		return nil, fmt.Errorf("error in marshaling object %w", err)
 	}
 
 	for _, patch := range p.patches {
 		patchBytes, err := yaml.YAMLToJSON([]byte(patch.PatchData))
 		if err != nil {
-			return nil, fmt.Errorf("error in converting YAML to JSON %s", err)
+			return nil, fmt.Errorf("error in converting YAML to JSON %w", err)
 		}
 
 		objBytes, err = jsonpatch.MergePatch(objBytes, patchBytes)

internal/resourcemodifiers/resource_modifiers.go

@@ -194,7 +194,7 @@ func unmarshalResourceModifiers(yamlData []byte) (*ResourceModifiers, error) {
 	resModifiers := &ResourceModifiers{}
 	err := yaml.UnmarshalStrict(yamlData, resModifiers)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decode yaml data into resource modifiers, err: %s", err)
+		return nil, fmt.Errorf("failed to decode yaml data into resource modifiers, err: %w", err)
 	}
 	return resModifiers, nil
 }
@@ -217,7 +217,7 @@ func (r *ResourceModifierRule) applyPatch(u *unstructured.Unstructured, scheme *
 
 	updated, err := p.Patch(u, logger)
 	if err != nil {
-		return fmt.Errorf("error in applying patch %s", err)
+		return fmt.Errorf("error in applying patch %w", err)
 	}
 
 	u.SetUnstructuredContent(updated.Object)

internal/resourcemodifiers/strategic_merge_patch.go

@@ -1,6 +1,7 @@
 package resourcemodifiers
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
 
@@ -37,7 +38,7 @@ func (p *StrategicMergePatcher) Patch(u *unstructured.Unstructured, _ logrus.Fie
 	for _, patch := range p.patches {
 		patchBytes, err := yaml.YAMLToJSON([]byte(patch.PatchData))
 		if err != nil {
-			return nil, fmt.Errorf("error in converting YAML to JSON %s", err)
+			return nil, fmt.Errorf("error in converting YAML to JSON %w", err)
 		}
 
 		err = strategicPatchObject(origin, patchBytes, updated, schemaReferenceObj)
@@ -127,10 +128,15 @@ func applyPatchToObject(
 
 // interpretStrategicMergePatchError interprets the error type and returns an error with appropriate HTTP code.
 func interpretStrategicMergePatchError(err error) error {
-	switch err {
-	case mergepatch.ErrBadJSONDoc, mergepatch.ErrBadPatchFormatForPrimitiveList, mergepatch.ErrBadPatchFormatForRetainKeys, mergepatch.ErrBadPatchFormatForSetElementOrderList, mergepatch.ErrUnsupportedStrategicMergePatchFormat:
+	switch {
+	case errors.Is(err, mergepatch.ErrBadJSONDoc),
+		errors.Is(err, mergepatch.ErrBadPatchFormatForPrimitiveList),
+		errors.Is(err, mergepatch.ErrBadPatchFormatForRetainKeys),
+		errors.Is(err, mergepatch.ErrBadPatchFormatForSetElementOrderList),
+		errors.Is(err, mergepatch.ErrUnsupportedStrategicMergePatchFormat):
 		return apierrors.NewBadRequest(err.Error())
-	case mergepatch.ErrNoListOfLists, mergepatch.ErrPatchContentNotMatchRetainKeys:
+	case errors.Is(err, mergepatch.ErrNoListOfLists),
+		errors.Is(err, mergepatch.ErrPatchContentNotMatchRetainKeys):
 		return apierrors.NewGenericServerResponse(http.StatusUnprocessableEntity, "", schema.GroupResource{}, "", err.Error(), 0, false)
 	default:
 		return err

internal/resourcepolicies/resource_policies.go

@@ -74,7 +74,7 @@ func unmarshalResourcePolicies(yamlData *string) (*ResourcePolicies, error) {
 	resPolicies := &ResourcePolicies{}
 	err := decodeStruct(strings.NewReader(*yamlData), resPolicies)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decode yaml data into resource policies  %v", err)
+		return nil, fmt.Errorf("failed to decode yaml data into resource policies  %w", err)
 	}
 
 	for _, vp := range resPolicies.VolumePolicies {

internal/resourcepolicies/volume_resources.go

@@ -230,7 +230,7 @@ func parseCapacity(cap string) (*capacity, error) {
 		} else {
 			quantity, err := resource.ParseQuantity(strings.TrimSpace(v))
 			if err != nil {
-				return nil, fmt.Errorf("wrong format of Capacity %v with err %v", v, err)
+				return nil, fmt.Errorf("wrong format of Capacity %v with err %w", v, err)
 			}
 			quantities = append(quantities, quantity)
 		}

pkg/backup/backup.go

@@ -855,7 +855,8 @@ func (kb *kubernetesBackupper) waitUntilPVBsProcessed(ctx context.Context, log l
 
 func (kb *kubernetesBackupper) backupItem(log logrus.FieldLogger, gr schema.GroupResource, itemBackupper *itemBackupper, unstructured *unstructured.Unstructured, preferredGVR schema.GroupVersionResource, itemBlock *BackupItemBlock) bool {
 	backedUpItem, _, err := itemBackupper.backupItem(log, unstructured, gr, preferredGVR, false, false, itemBlock)
-	if aggregate, ok := err.(kubeerrs.Aggregate); ok {
+	var aggregate kubeerrs.Aggregate
+	if errors.As(err, &aggregate) {
 		log.WithField("name", unstructured.GetName()).Infof("%d errors encountered backup up item", len(aggregate.Errors()))
 		// log each error separately so we get error location info in the log, and an
 		// accurate count of errors
@@ -880,7 +881,8 @@ func (kb *kubernetesBackupper) finalizeItem(
 	preferredGVR schema.GroupVersionResource,
 ) (bool, []FileForArchive) {
 	backedUpItem, updateFiles, err := itemBackupper.backupItem(log, unstructured, gr, preferredGVR, true, true, nil)
-	if aggregate, ok := err.(kubeerrs.Aggregate); ok {
+	var aggregate kubeerrs.Aggregate
+	if errors.As(err, &aggregate) {
 		log.WithField("name", unstructured.GetName()).Infof("%d errors encountered backup up item", len(aggregate.Errors()))
 		// log each error separately so we get error location info in the log, and an
 		// accurate count of errors

pkg/backup/backup_test.go

@@ -4402,7 +4402,7 @@ func assertTarballFileContents(t *testing.T, backupFile io.Reader, want map[stri
 
 	for {
 		hdr, err := r.Next()
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			break
 		}
 		require.NoError(t, err)

pkg/cmd/cli/backup/logs.go

@@ -66,7 +66,7 @@ func (l *LogsOptions) Run(c *cobra.Command, f client.Factory) error {
 	if apierrors.IsNotFound(err) {
 		return fmt.Errorf("backup %q does not exist", l.BackupName)
 	} else if err != nil {
-		return fmt.Errorf("error checking for backup %q: %v", l.BackupName, err)
+		return fmt.Errorf("error checking for backup %q: %w", l.BackupName, err)
 	}
 
 	switch backup.Status.Phase {