libpod: switch to golang native error wrapping

We now use the golang error wrapping format specifier `%w` instead of
the deprecated github.com/pkg/errors package.

[NO NEW TESTS NEEDED]

Signed-off-by: Sascha Grunert <sgrunert@redhat.com>

1 files changed, 90 insertions, 90 deletions

diff --git a/libpod/boltdb_state_internal.go b/libpod/boltdb_state_internal.go
index 11b4aa049..f28fadfa9 100644
--- a/libpod/boltdb_state_internal.go
+++ b/libpod/boltdb_state_internal.go
@@ -2,6 +2,7 @@ package libpod
 
 import (
 	"bytes"
+	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -10,7 +11,6 @@ import (
 	"github.com/containers/podman/v4/libpod/define"
 	"github.com/containers/podman/v4/pkg/rootless"
 	"github.com/containers/storage"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	bolt "go.etcd.io/bbolt"
 )
@@ -195,7 +195,7 @@ func checkRuntimeConfig(db *bolt.DB, rt *Runtime) error {
 			}
 
 			if err := configBkt.Put(missing.key, dbValue); err != nil {
-				return errors.Wrapf(err, "error updating %s in DB runtime config", missing.name)
+				return fmt.Errorf("error updating %s in DB runtime config: %w", missing.name, err)
 			}
 		}
 
@@ -236,8 +236,8 @@ func readOnlyValidateConfig(bucket *bolt.Bucket, toCheck dbConfigValidation) (bo
 			return true, nil
 		}
 
-		return true, errors.Wrapf(define.ErrDBBadConfig, "database %s %q does not match our %s %q",
-			toCheck.name, dbValue, toCheck.name, toCheck.runtimeValue)
+		return true, fmt.Errorf("database %s %q does not match our %s %q: %w",
+			toCheck.name, dbValue, toCheck.name, toCheck.runtimeValue, define.ErrDBBadConfig)
 	}
 
 	return true, nil
@@ -254,7 +254,7 @@ func (s *BoltState) getDBCon() (*bolt.DB, error) {
 
 	db, err := bolt.Open(s.dbPath, 0600, nil)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error opening database %s", s.dbPath)
+		return nil, fmt.Errorf("error opening database %s: %w", s.dbPath, err)
 	}
 
 	return db, nil
@@ -283,7 +283,7 @@ func (s *BoltState) closeDBCon(db *bolt.DB) error {
 func getIDBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(idRegistryBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "id registry bucket not found in DB")
+		return nil, fmt.Errorf("id registry bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -291,7 +291,7 @@ func getIDBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(nameRegistryBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "name registry bucket not found in DB")
+		return nil, fmt.Errorf("name registry bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -299,7 +299,7 @@ func getNamesBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(nsRegistryBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "namespace registry bucket not found in DB")
+		return nil, fmt.Errorf("namespace registry bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -307,7 +307,7 @@ func getNSBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(ctrBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "containers bucket not found in DB")
+		return nil, fmt.Errorf("containers bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -315,7 +315,7 @@ func getCtrBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getAllCtrsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(allCtrsBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "all containers bucket not found in DB")
+		return nil, fmt.Errorf("all containers bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -323,7 +323,7 @@ func getAllCtrsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(podBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "pods bucket not found in DB")
+		return nil, fmt.Errorf("pods bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -331,7 +331,7 @@ func getPodBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getAllPodsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(allPodsBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "all pods bucket not found in DB")
+		return nil, fmt.Errorf("all pods bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -339,7 +339,7 @@ func getAllPodsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getVolBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(volBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "volumes bucket not found in DB")
+		return nil, fmt.Errorf("volumes bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -347,7 +347,7 @@ func getVolBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getAllVolsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(allVolsBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "all volumes bucket not found in DB")
+		return nil, fmt.Errorf("all volumes bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -355,7 +355,7 @@ func getAllVolsBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getExecBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(execBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "exec bucket not found in DB")
+		return nil, fmt.Errorf("exec bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -363,7 +363,7 @@ func getExecBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getRuntimeConfigBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(runtimeConfigBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "runtime configuration bucket not found in DB")
+		return nil, fmt.Errorf("runtime configuration bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -371,7 +371,7 @@ func getRuntimeConfigBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getExitCodeBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(exitCodeBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "exit-code container bucket not found in DB")
+		return nil, fmt.Errorf("exit-code container bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -379,7 +379,7 @@ func getExitCodeBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func getExitCodeTimeStampBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 	bkt := tx.Bucket(exitCodeTimeStampBkt)
 	if bkt == nil {
-		return nil, errors.Wrapf(define.ErrDBBadConfig, "exit-code time stamp bucket not found in DB")
+		return nil, fmt.Errorf("exit-code time stamp bucket not found in DB: %w", define.ErrDBBadConfig)
 	}
 	return bkt, nil
 }
@@ -387,23 +387,23 @@ func getExitCodeTimeStampBucket(tx *bolt.Tx) (*bolt.Bucket, error) {
 func (s *BoltState) getContainerConfigFromDB(id []byte, config *ContainerConfig, ctrsBkt *bolt.Bucket) error {
 	ctrBkt := ctrsBkt.Bucket(id)
 	if ctrBkt == nil {
-		return errors.Wrapf(define.ErrNoSuchCtr, "container %s not found in DB", string(id))
+		return fmt.Errorf("container %s not found in DB: %w", string(id), define.ErrNoSuchCtr)
 	}
 
 	if s.namespaceBytes != nil {
 		ctrNamespaceBytes := ctrBkt.Get(namespaceKey)
 		if !bytes.Equal(s.namespaceBytes, ctrNamespaceBytes) {
-			return errors.Wrapf(define.ErrNSMismatch, "cannot retrieve container %s as it is part of namespace %q and we are in namespace %q", string(id), string(ctrNamespaceBytes), s.namespace)
+			return fmt.Errorf("cannot retrieve container %s as it is part of namespace %q and we are in namespace %q: %w", string(id), string(ctrNamespaceBytes), s.namespace, define.ErrNSMismatch)
 		}
 	}
 
 	configBytes := ctrBkt.Get(configKey)
 	if configBytes == nil {
-		return errors.Wrapf(define.ErrInternal, "container %s missing config key in DB", string(id))
+		return fmt.Errorf("container %s missing config key in DB: %w", string(id), define.ErrInternal)
 	}
 
 	if err := json.Unmarshal(configBytes, config); err != nil {
-		return errors.Wrapf(err, "error unmarshalling container %s config", string(id))
+		return fmt.Errorf("error unmarshalling container %s config: %w", string(id), err)
 	}
 
 	// convert ports to the new format if needed
@@ -426,7 +426,7 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
 	// Get the lock
 	lock, err := s.runtime.lockManager.RetrieveLock(ctr.config.LockID)
 	if err != nil {
-		return errors.Wrapf(err, "error retrieving lock for container %s", string(id))
+		return fmt.Errorf("error retrieving lock for container %s: %w", string(id), err)
 	}
 	ctr.lock = lock
 
@@ -473,29 +473,29 @@ func (s *BoltState) getContainerFromDB(id []byte, ctr *Container, ctrsBkt *bolt.
 func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error {
 	podDB := podBkt.Bucket(id)
 	if podDB == nil {
-		return errors.Wrapf(define.ErrNoSuchPod, "pod with ID %s not found", string(id))
+		return fmt.Errorf("pod with ID %s not found: %w", string(id), define.ErrNoSuchPod)
 	}
 
 	if s.namespaceBytes != nil {
 		podNamespaceBytes := podDB.Get(namespaceKey)
 		if !bytes.Equal(s.namespaceBytes, podNamespaceBytes) {
-			return errors.Wrapf(define.ErrNSMismatch, "cannot retrieve pod %s as it is part of namespace %q and we are in namespace %q", string(id), string(podNamespaceBytes), s.namespace)
+			return fmt.Errorf("cannot retrieve pod %s as it is part of namespace %q and we are in namespace %q: %w", string(id), string(podNamespaceBytes), s.namespace, define.ErrNSMismatch)
 		}
 	}
 
 	podConfigBytes := podDB.Get(configKey)
 	if podConfigBytes == nil {
-		return errors.Wrapf(define.ErrInternal, "pod %s is missing configuration key in DB", string(id))
+		return fmt.Errorf("pod %s is missing configuration key in DB: %w", string(id), define.ErrInternal)
 	}
 
 	if err := json.Unmarshal(podConfigBytes, pod.config); err != nil {
-		return errors.Wrapf(err, "error unmarshalling pod %s config from DB", string(id))
+		return fmt.Errorf("error unmarshalling pod %s config from DB: %w", string(id), err)
 	}
 
 	// Get the lock
 	lock, err := s.runtime.lockManager.RetrieveLock(pod.config.LockID)
 	if err != nil {
-		return errors.Wrapf(err, "error retrieving lock for pod %s", string(id))
+		return fmt.Errorf("error retrieving lock for pod %s: %w", string(id), err)
 	}
 	pod.lock = lock
 
@@ -508,23 +508,23 @@ func (s *BoltState) getPodFromDB(id []byte, pod *Pod, podBkt *bolt.Bucket) error
 func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bucket) error {
 	volDB := volBkt.Bucket(name)
 	if volDB == nil {
-		return errors.Wrapf(define.ErrNoSuchVolume, "volume with name %s not found", string(name))
+		return fmt.Errorf("volume with name %s not found: %w", string(name), define.ErrNoSuchVolume)
 	}
 
 	volConfigBytes := volDB.Get(configKey)
 	if volConfigBytes == nil {
-		return errors.Wrapf(define.ErrInternal, "volume %s is missing configuration key in DB", string(name))
+		return fmt.Errorf("volume %s is missing configuration key in DB: %w", string(name), define.ErrInternal)
 	}
 
 	if err := json.Unmarshal(volConfigBytes, volume.config); err != nil {
-		return errors.Wrapf(err, "error unmarshalling volume %s config from DB", string(name))
+		return fmt.Errorf("error unmarshalling volume %s config from DB: %w", string(name), err)
 	}
 
 	// Volume state is allowed to be nil for legacy compatibility
 	volStateBytes := volDB.Get(stateKey)
 	if volStateBytes != nil {
 		if err := json.Unmarshal(volStateBytes, volume.state); err != nil {
-			return errors.Wrapf(err, "error unmarshalling volume %s state from DB", string(name))
+			return fmt.Errorf("error unmarshalling volume %s state from DB: %w", string(name), err)
 		}
 	}
 
@@ -546,7 +546,7 @@ func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bu
 	// Get the lock
 	lock, err := s.runtime.lockManager.RetrieveLock(volume.config.LockID)
 	if err != nil {
-		return errors.Wrapf(err, "error retrieving lock for volume %q", string(name))
+		return fmt.Errorf("error retrieving lock for volume %q: %w", string(name), err)
 	}
 	volume.lock = lock
 
@@ -560,8 +560,8 @@ func (s *BoltState) getVolumeFromDB(name []byte, volume *Volume, volBkt *bolt.Bu
 // If pod is not nil, the container is added to the pod as well
 func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 	if s.namespace != "" && s.namespace != ctr.config.Namespace {
-		return errors.Wrapf(define.ErrNSMismatch, "cannot add container %s as it is in namespace %q and we are in namespace %q",
-			ctr.ID(), s.namespace, ctr.config.Namespace)
+		return fmt.Errorf("cannot add container %s as it is in namespace %q and we are in namespace %q: %w",
+			ctr.ID(), s.namespace, ctr.config.Namespace, define.ErrNSMismatch)
 	}
 
 	// Set the original networks to nil. We can save some space by not storing it in the config
@@ -572,11 +572,11 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 	// JSON container structs to insert into DB
 	configJSON, err := json.Marshal(ctr.config)
 	if err != nil {
-		return errors.Wrapf(err, "error marshalling container %s config to JSON", ctr.ID())
+		return fmt.Errorf("error marshalling container %s config to JSON: %w", ctr.ID(), err)
 	}
 	stateJSON, err := json.Marshal(ctr.state)
 	if err != nil {
-		return errors.Wrapf(err, "error marshalling container %s state to JSON", ctr.ID())
+		return fmt.Errorf("error marshalling container %s state to JSON: %w", ctr.ID(), err)
 	}
 	netNSPath := getNetNSPath(ctr)
 	dependsCtrs := ctr.Dependencies()
@@ -594,16 +594,16 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 	for net, opts := range configNetworks {
 		// Check that we don't have any empty network names
 		if net == "" {
-			return errors.Wrapf(define.ErrInvalidArg, "network names cannot be an empty string")
+			return fmt.Errorf("network names cannot be an empty string: %w", define.ErrInvalidArg)
 		}
 		if opts.InterfaceName == "" {
-			return errors.Wrapf(define.ErrInvalidArg, "network interface name cannot be an empty string")
+			return fmt.Errorf("network interface name cannot be an empty string: %w", define.ErrInvalidArg)
 		}
 		// always add the short id as alias for docker compat
 		opts.Aliases = append(opts.Aliases, ctr.config.ID[:12])
 		optBytes, err := json.Marshal(opts)
 		if err != nil {
-			return errors.Wrapf(err, "error marshalling network options JSON for container %s", ctr.ID())
+			return fmt.Errorf("error marshalling network options JSON for container %s: %w", ctr.ID(), err)
 		}
 		networks[net] = optBytes
 	}
@@ -659,17 +659,17 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 			podDB = podBucket.Bucket(podID)
 			if podDB == nil {
 				pod.valid = false
-				return errors.Wrapf(define.ErrNoSuchPod, "pod %s does not exist in database", pod.ID())
+				return fmt.Errorf("pod %s does not exist in database: %w", pod.ID(), define.ErrNoSuchPod)
 			}
 			podCtrs = podDB.Bucket(containersBkt)
 			if podCtrs == nil {
-				return errors.Wrapf(define.ErrInternal, "pod %s does not have a containers bucket", pod.ID())
+				return fmt.Errorf("pod %s does not have a containers bucket: %w", pod.ID(), define.ErrInternal)
 			}
 
 			podNS := podDB.Get(namespaceKey)
 			if !bytes.Equal(podNS, ctrNamespace) {
-				return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %s and pod %s is in namespace %s",
-					ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace)
+				return fmt.Errorf("container %s is in namespace %s and pod %s is in namespace %s: %w",
+					ctr.ID(), ctr.config.Namespace, pod.ID(), pod.config.Namespace, define.ErrNSMismatch)
 			}
 		}
 
@@ -680,7 +680,7 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 			if allCtrsBucket.Get(idExist) == nil {
 				err = define.ErrPodExists
 			}
-			return errors.Wrapf(err, "ID \"%s\" is in use", ctr.ID())
+			return fmt.Errorf("ID \"%s\" is in use: %w", ctr.ID(), err)
 		}
 		nameExist := namesBucket.Get(ctrName)
 		if nameExist != nil {
@@ -688,66 +688,66 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 			if allCtrsBucket.Get(nameExist) == nil {
 				err = define.ErrPodExists
 			}
-			return errors.Wrapf(err, "name \"%s\" is in use", ctr.Name())
+			return fmt.Errorf("name \"%s\" is in use: %w", ctr.Name(), err)
 		}
 
 		// No overlapping containers
 		// Add the new container to the DB
 		if err := idsBucket.Put(ctrID, ctrName); err != nil {
-			return errors.Wrapf(err, "error adding container %s ID to DB", ctr.ID())
+			return fmt.Errorf("error adding container %s ID to DB: %w", ctr.ID(), err)
 		}
 		if err := namesBucket.Put(ctrName, ctrID); err != nil {
-			return errors.Wrapf(err, "error adding container %s name (%s) to DB", ctr.ID(), ctr.Name())
+			return fmt.Errorf("error adding container %s name (%s) to DB: %w", ctr.ID(), ctr.Name(), err)
 		}
 		if ctrNamespace != nil {
 			if err := nsBucket.Put(ctrID, ctrNamespace); err != nil {
-				return errors.Wrapf(err, "error adding container %s namespace (%q) to DB", ctr.ID(), ctr.Namespace())
+				return fmt.Errorf("error adding container %s namespace (%q) to DB: %w", ctr.ID(), ctr.Namespace(), err)
 			}
 		}
 		if err := allCtrsBucket.Put(ctrID, ctrName); err != nil {
-			return errors.Wrapf(err, "error adding container %s to all containers bucket in DB", ctr.ID())
+			return fmt.Errorf("error adding container %s to all containers bucket in DB: %w", ctr.ID(), err)
 		}
 
 		newCtrBkt, err := ctrBucket.CreateBucket(ctrID)
 		if err != nil {
-			return errors.Wrapf(err, "error adding container %s bucket to DB", ctr.ID())
+			return fmt.Errorf("error adding container %s bucket to DB: %w", ctr.ID(), err)
 		}
 
 		if err := newCtrBkt.Put(configKey, configJSON); err != nil {
-			return errors.Wrapf(err, "error adding container %s config to DB", ctr.ID())
+			return fmt.Errorf("error adding container %s config to DB: %w", ctr.ID(), err)
 		}
 		if err := newCtrBkt.Put(stateKey, stateJSON); err != nil {
-			return errors.Wrapf(err, "error adding container %s state to DB", ctr.ID())
+			return fmt.Errorf("error adding container %s state to DB: %w", ctr.ID(), err)
 		}
 		if ctrNamespace != nil {
 			if err := newCtrBkt.Put(namespaceKey, ctrNamespace); err != nil {
-				return errors.Wrapf(err, "error adding container %s namespace to DB", ctr.ID())
+				return fmt.Errorf("error adding container %s namespace to DB: %w", ctr.ID(), err)
 			}
 		}
 		if pod != nil {
 			if err := newCtrBkt.Put(podIDKey, []byte(pod.ID())); err != nil {
-				return errors.Wrapf(err, "error adding container %s pod to DB", ctr.ID())
+				return fmt.Errorf("error adding container %s pod to DB: %w", ctr.ID(), err)
 			}
 		}
 		if netNSPath != "" {
 			if err := newCtrBkt.Put(netNSKey, []byte(netNSPath)); err != nil {
-				return errors.Wrapf(err, "error adding container %s netns path to DB", ctr.ID())
+				return fmt.Errorf("error adding container %s netns path to DB: %w", ctr.ID(), err)
 			}
 		}
 		if len(networks) > 0 {
 			ctrNetworksBkt, err := newCtrBkt.CreateBucket(networksBkt)
 			if err != nil {
-				return errors.Wrapf(err, "error creating networks bucket for container %s", ctr.ID())
+				return fmt.Errorf("error creating networks bucket for container %s: %w", ctr.ID(), err)
 			}
 			for network, opts := range networks {
 				if err := ctrNetworksBkt.Put([]byte(network), opts); err != nil {
-					return errors.Wrapf(err, "error adding network %q to networks bucket for container %s", network, ctr.ID())
+					return fmt.Errorf("error adding network %q to networks bucket for container %s: %w", network, ctr.ID(), err)
 				}
 			}
 		}
 
 		if _, err := newCtrBkt.CreateBucket(dependenciesBkt); err != nil {
-			return errors.Wrapf(err, "error creating dependencies bucket for container %s", ctr.ID())
+			return fmt.Errorf("error creating dependencies bucket for container %s: %w", ctr.ID(), err)
 		}
 
 		// Add dependencies for the container
@@ -756,42 +756,42 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 
 			depCtrBkt := ctrBucket.Bucket(depCtrID)
 			if depCtrBkt == nil {
-				return errors.Wrapf(define.ErrNoSuchCtr, "container %s depends on container %s, but it does not exist in the DB", ctr.ID(), dependsCtr)
+				return fmt.Errorf("container %s depends on container %s, but it does not exist in the DB: %w", ctr.ID(), dependsCtr, define.ErrNoSuchCtr)
 			}
 
 			depCtrPod := depCtrBkt.Get(podIDKey)
 			if pod != nil {
 				// If we're part of a pod, make sure the dependency is part of the same pod
 				if depCtrPod == nil {
-					return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is not in pod %s", ctr.ID(), dependsCtr, pod.ID())
+					return fmt.Errorf("container %s depends on container %s which is not in pod %s: %w", ctr.ID(), dependsCtr, pod.ID(), define.ErrInvalidArg)
 				}
 
 				if string(depCtrPod) != pod.ID() {
-					return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is in a different pod (%s)", ctr.ID(), dependsCtr, string(depCtrPod))
+					return fmt.Errorf("container %s depends on container %s which is in a different pod (%s): %w", ctr.ID(), dependsCtr, string(depCtrPod), define.ErrInvalidArg)
 				}
 			} else if depCtrPod != nil {
 				// If we're not part of a pod, we cannot depend on containers in a pod
-				return errors.Wrapf(define.ErrInvalidArg, "container %s depends on container %s which is in a pod - containers not in pods cannot depend on containers in pods", ctr.ID(), dependsCtr)
+				return fmt.Errorf("container %s depends on container %s which is in a pod - containers not in pods cannot depend on containers in pods: %w", ctr.ID(), dependsCtr, define.ErrInvalidArg)
 			}
 
 			depNamespace := depCtrBkt.Get(namespaceKey)
 			if !bytes.Equal(ctrNamespace, depNamespace) {
-				return errors.Wrapf(define.ErrNSMismatch, "container %s in namespace %q depends on container %s in namespace %q - namespaces must match", ctr.ID(), ctr.config.Namespace, dependsCtr, string(depNamespace))
+				return fmt.Errorf("container %s in namespace %q depends on container %s in namespace %q - namespaces must match: %w", ctr.ID(), ctr.config.Namespace, dependsCtr, string(depNamespace), define.ErrNSMismatch)
 			}
 
 			depCtrDependsBkt := depCtrBkt.Bucket(dependenciesBkt)
 			if depCtrDependsBkt == nil {
-				return errors.Wrapf(define.ErrInternal, "container %s does not have a dependencies bucket", dependsCtr)
+				return fmt.Errorf("container %s does not have a dependencies bucket: %w", dependsCtr, define.ErrInternal)
 			}
 			if err := depCtrDependsBkt.Put(ctrID, ctrName); err != nil {
-				return errors.Wrapf(err, "error adding ctr %s as dependency of container %s", ctr.ID(), dependsCtr)
+				return fmt.Errorf("error adding ctr %s as dependency of container %s: %w", ctr.ID(), dependsCtr, err)
 			}
 		}
 
 		// Add ctr to pod
 		if pod != nil && podCtrs != nil {
 			if err := podCtrs.Put(ctrID, ctrName); err != nil {
-				return errors.Wrapf(err, "error adding container %s to pod %s", ctr.ID(), pod.ID())
+				return fmt.Errorf("error adding container %s to pod %s: %w", ctr.ID(), pod.ID(), err)
 			}
 		}
 
@@ -799,16 +799,16 @@ func (s *BoltState) addContainer(ctr *Container, pod *Pod) error {
 		for _, vol := range ctr.config.NamedVolumes {
 			volDB := volBkt.Bucket([]byte(vol.Name))
 			if volDB == nil {
-				return errors.Wrapf(define.ErrNoSuchVolume, "no volume with name %s found in database when adding container %s", vol.Name, ctr.ID())
+				return fmt.Errorf("no volume with name %s found in database when adding container %s: %w", vol.Name, ctr.ID(), define.ErrNoSuchVolume)
 			}
 
 			ctrDepsBkt, err := volDB.CreateBucketIfNotExists(volDependenciesBkt)
 			if err != nil {
-				return errors.Wrapf(err, "error creating volume %s dependencies bucket to add container %s", vol.Name, ctr.ID())
+				return fmt.Errorf("error creating volume %s dependencies bucket to add container %s: %w", vol.Name, ctr.ID(), err)
 			}
 			if depExists := ctrDepsBkt.Get(ctrID); depExists == nil {
 				if err := ctrDepsBkt.Put(ctrID, ctrID); err != nil {
-					return errors.Wrapf(err, "error adding container %s to volume %s dependencies", ctr.ID(), vol.Name)
+					return fmt.Errorf("error adding container %s to volume %s dependencies: %w", ctr.ID(), vol.Name, err)
 				}
 			}
 		}
@@ -868,7 +868,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 		podDB = podBucket.Bucket(podID)
 		if podDB == nil {
 			pod.valid = false
-			return errors.Wrapf(define.ErrNoSuchPod, "no pod with ID %s found in DB", pod.ID())
+			return fmt.Errorf("no pod with ID %s found in DB: %w", pod.ID(), define.ErrNoSuchPod)
 		}
 	}
 
@@ -876,17 +876,17 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 	ctrExists := ctrBucket.Bucket(ctrID)
 	if ctrExists == nil {
 		ctr.valid = false
-		return errors.Wrapf(define.ErrNoSuchCtr, "no container with ID %s found in DB", ctr.ID())
+		return fmt.Errorf("no container with ID %s found in DB: %w", ctr.ID(), define.ErrNoSuchCtr)
 	}
 
 	// Compare namespace
 	// We can't remove containers not in our namespace
 	if s.namespace != "" {
 		if s.namespace != ctr.config.Namespace {
-			return errors.Wrapf(define.ErrNSMismatch, "container %s is in namespace %q, does not match our namespace %q", ctr.ID(), ctr.config.Namespace, s.namespace)
+			return fmt.Errorf("container %s is in namespace %q, does not match our namespace %q: %w", ctr.ID(), ctr.config.Namespace, s.namespace, define.ErrNSMismatch)
 		}
 		if pod != nil && s.namespace != pod.config.Namespace {
-			return errors.Wrapf(define.ErrNSMismatch, "pod %s is in namespace %q, does not match out namespace %q", pod.ID(), pod.config.Namespace, s.namespace)
+			return fmt.Errorf("pod %s is in namespace %q, does not match out namespace %q: %w", pod.ID(), pod.config.Namespace, s.namespace, define.ErrNSMismatch)
 		}
 	}
 
@@ -899,10 +899,10 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 		} else {
 			ctrInPod := podCtrs.Get(ctrID)
 			if ctrInPod == nil {
-				return errors.Wrapf(define.ErrNoSuchCtr, "container %s is not in pod %s", ctr.ID(), pod.ID())
+				return fmt.Errorf("container %s is not in pod %s: %w", ctr.ID(), pod.ID(), define.ErrNoSuchCtr)
 			}
 			if err := podCtrs.Delete(ctrID); err != nil {
-				return errors.Wrapf(err, "error removing container %s from pod %s", ctr.ID(), pod.ID())
+				return fmt.Errorf("error removing container %s from pod %s: %w", ctr.ID(), pod.ID(), err)
 			}
 		}
 	}
@@ -920,14 +920,14 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 			return err
 		}
 		if len(sessions) > 0 {
-			return errors.Wrapf(define.ErrExecSessionExists, "container %s has active exec sessions: %s", ctr.ID(), strings.Join(sessions, ", "))
+			return fmt.Errorf("container %s has active exec sessions: %s: %w", ctr.ID(), strings.Join(sessions, ", "), define.ErrExecSessionExists)
 		}
 	}
 
 	// Does the container have dependencies?
 	ctrDepsBkt := ctrExists.Bucket(dependenciesBkt)
 	if ctrDepsBkt == nil {
-		return errors.Wrapf(define.ErrInternal, "container %s does not have a dependencies bucket", ctr.ID())
+		return fmt.Errorf("container %s does not have a dependencies bucket: %w", ctr.ID(), define.ErrInternal)
 	}
 	deps := []string{}
 	err = ctrDepsBkt.ForEach(func(id, value []byte) error {
@@ -939,25 +939,25 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 		return err
 	}
 	if len(deps) != 0 {
-		return errors.Wrapf(define.ErrDepExists, "container %s is a dependency of the following containers: %s", ctr.ID(), strings.Join(deps, ", "))
+		return fmt.Errorf("container %s is a dependency of the following containers: %s: %w", ctr.ID(), strings.Join(deps, ", "), define.ErrDepExists)
 	}
 
 	if err := ctrBucket.DeleteBucket(ctrID); err != nil {
-		return errors.Wrapf(define.ErrInternal, "error deleting container %s from DB", ctr.ID())
+		return fmt.Errorf("error deleting container %s from DB: %w", ctr.ID(), define.ErrInternal)
 	}
 
 	if err := idsBucket.Delete(ctrID); err != nil {
-		return errors.Wrapf(err, "error deleting container %s ID in DB", ctr.ID())
+		return fmt.Errorf("error deleting container %s ID in DB: %w", ctr.ID(), err)
 	}
 
 	if err := namesBucket.Delete(ctrName); err != nil {
-		return errors.Wrapf(err, "error deleting container %s name in DB", ctr.ID())
+		return fmt.Errorf("error deleting container %s name in DB: %w", ctr.ID(), err)
 	}
 	if err := nsBucket.Delete(ctrID); err != nil {
-		return errors.Wrapf(err, "error deleting container %s namespace in DB", ctr.ID())
+		return fmt.Errorf("error deleting container %s namespace in DB: %w", ctr.ID(), err)
 	}
 	if err := allCtrsBucket.Delete(ctrID); err != nil {
-		return errors.Wrapf(err, "error deleting container %s from all containers bucket in DB", ctr.ID())
+		return fmt.Errorf("error deleting container %s from all containers bucket in DB: %w", ctr.ID(), err)
 	}
 
 	depCtrs := ctr.Dependencies()
@@ -986,7 +986,7 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 		}
 
 		if err := depCtrDependsBkt.Delete(ctrID); err != nil {
-			return errors.Wrapf(err, "error removing container %s as a dependency of container %s", ctr.ID(), depCtr)
+			return fmt.Errorf("error removing container %s as a dependency of container %s: %w", ctr.ID(), depCtr, err)
 		}
 	}
 
@@ -1001,11 +1001,11 @@ func (s *BoltState) removeContainer(ctr *Container, pod *Pod, tx *bolt.Tx) error
 
 		ctrDepsBkt := volDB.Bucket(volDependenciesBkt)
 		if ctrDepsBkt == nil {
-			return errors.Wrapf(define.ErrInternal, "volume %s is missing container dependencies bucket, cannot remove container %s from dependencies", vol.Name, ctr.ID())
+			return fmt.Errorf("volume %s is missing container dependencies bucket, cannot remove container %s from dependencies: %w", vol.Name, ctr.ID(), define.ErrInternal)
 		}
 		if depExists := ctrDepsBkt.Get(ctrID); depExists == nil {
 			if err := ctrDepsBkt.Delete(ctrID); err != nil {
-				return errors.Wrapf(err, "error deleting container %s dependency on volume %s", ctr.ID(), vol.Name)
+				return fmt.Errorf("error deleting container %s dependency on volume %s: %w", ctr.ID(), vol.Name, err)
 			}
 		}
 	}
@@ -1062,7 +1062,7 @@ func (s *BoltState) lookupContainerID(idOrName string, ctrBucket, namesBucket, n
 		}
 		if strings.HasPrefix(string(checkID), idOrName) {
 			if exists {
-				return errors.Wrapf(define.ErrCtrExists, "more than one result for container ID %s", idOrName)
+				return fmt.Errorf("more than one result for container ID %s: %w", idOrName, define.ErrCtrExists)
 			}
 			id = checkID
 			exists = true
@@ -1075,9 +1075,9 @@ func (s *BoltState) lookupContainerID(idOrName string, ctrBucket, namesBucket, n
 		return nil, err
 	} else if !exists {
 		if isPod {
-			return nil, errors.Wrapf(define.ErrNoSuchCtr, "%q is a pod, not a container", idOrName)
+			return nil, fmt.Errorf("%q is a pod, not a container: %w", idOrName, define.ErrNoSuchCtr)
 		}
-		return nil, errors.Wrapf(define.ErrNoSuchCtr, "no container with name or ID %q found", idOrName)
+		return nil, fmt.Errorf("no container with name or ID %q found: %w", idOrName, define.ErrNoSuchCtr)
 	}
 	return id, nil
 }