remove uses of pkg/errors

While pkg/errors is a great package, it's probably not needed for
how it's used in this project, so let's replace with Go's native
error wrapping.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

go.mod

@@ -5,6 +5,5 @@ go 1.18
 require (
 	github.com/danieljoos/wincred v1.1.2
 	github.com/jsipprell/keyctl v1.0.0
-	github.com/pkg/errors v0.9.1
 	golang.org/x/sys v0.0.0-20210819135213-f52c844e1c1c
 )

go.sum

@@ -4,8 +4,6 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/jsipprell/keyctl v1.0.0 h1:eMMJGk3UEsCXQegACLlfIjnfPlYHV61qfGXZ9/axBn4=
 github.com/jsipprell/keyctl v1.0.0/go.mod h1:64s6WpBtruURX3w8W/vhWj1/uh+nOm7vUXSJlK5+KMs=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=

keyctl/keyctl.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/docker/docker-credential-helpers/credentials"
 	"github.com/jsipprell/keyctl"
-	"github.com/pkg/errors"
 )
 
 // Keyctl based credential helper looks for a default keyring inside
@@ -36,11 +35,11 @@ func (k Keyctl) createDefaultPersistentKeyring() (string, error) {
 	cmd.Stdout = &out
 	err := cmd.Run()
 	if err != nil {
-		return "", errors.Wrapf(err, "cannot run keyctl command to create persistent keyring %+v: %s", err, errout.String())
+		return "", fmt.Errorf("cannot run keyctl command to create persistent keyring: %s: %w", errout.String(), err)
 	}
 	persistentKeyringID := out.String()
 	if err != nil {
-		return "", errors.Wrapf(err, "cannot create or read persistent keyring %+v", err)
+		return "", fmt.Errorf("cannot create or read persistent keyring: %w", err)
 	}
 	return persistentKeyringID, nil
 }
@@ -49,12 +48,12 @@ func (k Keyctl) getDefaultCredsStoreFromPersistent() (keyctl.NamedKeyring, error
 	var out, errout bytes.Buffer
 	persistentKeyringID, err := k.createDefaultPersistentKeyring()
 	if err != nil {
-		return nil, errors.Wrap(err, "default persistent keyring cannot be created")
+		return nil, fmt.Errorf("default persistent keyring cannot be created: %w", err)
 	}
 
 	defaultSessionKeyring, err := keyctl.SessionKeyring()
 	if err != nil {
-		return nil, errors.New("errors getting session keyring")
+		return nil, fmt.Errorf("errors getting session keyring: %w", err)
 	}
 
 	defaultKeyring, err := keyctl.OpenKeyring(defaultSessionKeyring, defaultKeyringName)
@@ -65,13 +64,13 @@ func (k Keyctl) getDefaultCredsStoreFromPersistent() (keyctl.NamedKeyring, error
 		cmd.Stderr = &errout
 		err := cmd.Run()
 		if err != nil {
-			return nil, errors.Wrapf(err, "cannot run keyctl command to created credstore keyring %s %s %s", cmd.String(), errout.String(), out.String())
+			return nil, fmt.Errorf("cannot run keyctl command to created credstore keyring (%s): %s %s: %w", cmd.String(), errout.String(), out.String(), err)
 		}
 	}
 	/* Search for it again and return the default keyring*/
 	defaultKeyring, err = keyctl.OpenKeyring(defaultSessionKeyring, defaultKeyringName)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to lookup default session keyring")
+		return nil, fmt.Errorf("failed to lookup default session keyring: %w", err)
 	}
 
 	return defaultKeyring, nil
@@ -80,25 +79,32 @@ func (k Keyctl) getDefaultCredsStoreFromPersistent() (keyctl.NamedKeyring, error
 // getDefaultCredsStore is a helper function to get the default credsStore keyring
 func (k Keyctl) getDefaultCredsStore() (keyctl.NamedKeyring, error) {
 	if persistent == 1 {
-		return k.getDefaultCredsStoreFromPersistent()
+		cs, err := k.getDefaultCredsStoreFromPersistent()
+		if err != nil {
+			return nil, err
+		}
+		if cs == nil {
+			return nil, fmt.Errorf("nil credstore")
+		}
+		return cs, err
 	}
 	defaultSessionKeyring, err := keyctl.SessionKeyring()
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting session keyring")
+		return nil, fmt.Errorf("error getting session keyring: %w", err)
 	}
 
 	defaultKeyring, err := keyctl.OpenKeyring(defaultSessionKeyring, defaultKeyringName)
 	if err != nil || defaultKeyring == nil {
 		if defaultKeyring == nil {
 			defaultKeyring, err = keyctl.CreateKeyring(defaultSessionKeyring, defaultKeyringName)
 			if err != nil {
-				return nil, errors.Wrap(err, "failed to create default credsStore keyring")
+				return nil, fmt.Errorf("failed to create default credsStore keyring: %w", err)
 			}
 		}
 	}
 
 	if defaultKeyring == nil {
-		return nil, errors.Wrap(errors.New(""), " nil credstore")
+		return nil, fmt.Errorf("nil credstore")
 	}
 
 	return defaultKeyring, nil
@@ -107,29 +113,29 @@ func (k Keyctl) getDefaultCredsStore() (keyctl.NamedKeyring, error) {
 // Add adds new credentials to the keychain.
 func (k Keyctl) Add(creds *credentials.Credentials) error {
 	defaultKeyring, err := k.getDefaultCredsStore()
-	if err != nil || defaultKeyring == nil {
-		return errors.Wrapf(err, "failed to create credsStore entry for %s", creds.ServerURL)
+	if err != nil {
+		return fmt.Errorf("failed to create credsStore entry for %s: %w", creds.ServerURL, err)
 	}
 
 	// create a child keyring under default for given url
 	encoded := base64.URLEncoding.EncodeToString([]byte(strings.TrimSuffix(creds.ServerURL, "\n")))
 	urlKeyring, err := keyctl.CreateKeyring(defaultKeyring, encoded)
 	if err != nil {
-		return errors.Wrapf(err, "failed to create keyring for %s", creds.ServerURL)
+		return fmt.Errorf("failed to create keyring for %s: %w", creds.ServerURL, err)
 	}
 
 	_, err = urlKeyring.Add(creds.Username, []byte(creds.Secret))
 	if err != nil {
-		return errors.Wrapf(err, "failed to add creds to keryring for %s with error: %+v", creds.ServerURL, err)
+		return fmt.Errorf("failed to add creds to keryring for %s: %w", creds.ServerURL, err)
 	}
 	return err
 }
 
 // searchHelper function searches for an url inside the default keyring.
 func (k Keyctl) searchHelper(serverURL string) (keyctl.NamedKeyring, string, error) {
 	defaultKeyring, err := k.getDefaultCredsStore()
-	if err != nil || defaultKeyring == nil {
-		return nil, "", fmt.Errorf("searchHelper failed: cannot read defaultCredsStore")
+	if err != nil {
+		return nil, "", fmt.Errorf("searchHelper failed: cannot read defaultCredsStore: %w", err)
 	}
 
 	encoded := base64.URLEncoding.EncodeToString([]byte(strings.TrimSuffix(serverURL, "\n")))
@@ -166,21 +172,21 @@ func (k Keyctl) searchHelper(serverURL string) (keyctl.NamedKeyring, string, err
 // Get returns the username and secret to use for a given registry server URL.
 func (k Keyctl) Get(serverURL string) (string, string, error) {
 	if serverURL == "" {
-		return "", "", errors.New("missing server url")
+		return "", "", fmt.Errorf("missing server url")
 	}
 
 	serverURL = strings.TrimSuffix(serverURL, "\n")
 	urlKeyring, searchData, err := k.searchHelper(serverURL)
 	if err != nil {
-		return "", "", errors.Wrapf(err, "url not found by searchHelper:  %s err: %v", serverURL, err)
+		return "", "", fmt.Errorf("url (%s) not found by searchHelper: %w", serverURL, err)
 	}
 	key, err := urlKeyring.Search(searchData)
 	if err != nil {
-		return "", "", errors.Wrapf(err, "url not found in %+v", urlKeyring)
+		return "", "", fmt.Errorf("url (%s) not found in %+v: %w", serverURL, urlKeyring, err)
 	}
 	secret, err := key.Get()
 	if err != nil {
-		return "", "", errors.Wrapf(err, "failed to read credentials for %s:%s", serverURL, searchData)
+		return "", "", fmt.Errorf("failed to read credentials for url (%s): %s: %w", serverURL, searchData, err)
 	}
 
 	return searchData, string(secret), nil
@@ -191,7 +197,7 @@ func (k Keyctl) Delete(serverURL string) error {
 	serverURL = strings.TrimSuffix(serverURL, "\n")
 	urlKeyring, searchData, err := k.searchHelper(serverURL)
 	if err != nil {
-		return errors.Wrapf(err, "cannot find server url %s", serverURL)
+		return fmt.Errorf("cannot find server url (%s): %w", serverURL, err)
 	}
 
 	key, err := urlKeyring.Search(searchData)
@@ -209,9 +215,9 @@ func (k Keyctl) Delete(serverURL string) error {
 		fmt.Printf("cannot list keyring %s", urlKeyring.Name())
 	}
 	if len(refs) == 0 {
-		keyctl.UnlinkKeyring(urlKeyring)
+		_ = keyctl.UnlinkKeyring(urlKeyring)
 	} else {
-		return errors.Wrapf(err, "Canot remove keyring as its not empty %s", urlKeyring.Name())
+		return fmt.Errorf("canot remove keyring as its not empty %s", urlKeyring.Name())
 	}
 
 	return err
@@ -220,8 +226,8 @@ func (k Keyctl) Delete(serverURL string) error {
 // List returns the stored URLs and corresponding usernames for a given credentials label
 func (k Keyctl) List() (map[string]string, error) {
 	defaultKeyring, err := k.getDefaultCredsStore()
-	if err != nil || defaultKeyring == nil {
-		return nil, errors.Wrap(err, "List() failed: cannot read default credStore")
+	if err != nil {
+		return nil, fmt.Errorf("failed to list credentials: cannot read default credStore: %w", err)
 	}
 
 	resp := map[string]string{}

keyctl/keyctl_test.go

@@ -1,11 +1,11 @@
 package keyctl
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
 	"github.com/docker/docker-credential-helpers/credentials"
-	"github.com/pkg/errors"
 )
 
 func TestKeyctlHelper(t *testing.T) {
@@ -59,7 +59,7 @@ func TestKeyctlHelper(t *testing.T) {
 		}
 		err = helper.Delete(s)
 		if err != nil {
-			errors.Wrapf(err, "error in deleting %s", s)
+			t.Error(fmt.Errorf("error in deleting %s: %w", s, err))
 		}
 	}