chore: remove pkg/errors dependency

Signed-off-by: Austin Vazquez <macedonv@amazon.com>

Author: austinvazquez

agent/drive_handler.go

@@ -27,7 +27,6 @@ import (
 	"github.com/firecracker-microvm/firecracker-containerd/internal"
 	drivemount "github.com/firecracker-microvm/firecracker-containerd/proto/service/drivemount/ttrpc"
 	"github.com/gogo/protobuf/types"
-	"github.com/pkg/errors"
 )
 
 const (
@@ -183,7 +182,7 @@ func (dh driveHandler) MountDrive(ctx context.Context, req *drivemount.MountDriv
 
 	err := os.MkdirAll(req.DestinationPath, 0700)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to create drive mount destination %q", req.DestinationPath)
+		return nil, fmt.Errorf("failed to create drive mount destination %q: %w", req.DestinationPath, err)
 	}
 
 	// Retry the mount in the case of failure a fixed number of times. This works around a rare issue
@@ -210,12 +209,10 @@ func (dh driveHandler) MountDrive(ctx context.Context, req *drivemount.MountDriv
 			continue
 		}
 
-		return nil, errors.Wrapf(err, "non-retryable failure mounting drive from %q to %q",
-			drive.Path(), req.DestinationPath)
+		return nil, fmt.Errorf("non-retryable failure mounting drive from %q to %q: %w", drive.Path(), req.DestinationPath, err)
 	}
 
-	return nil, errors.Errorf("exhausted retries mounting drive from %q to %q",
-		drive.Path(), req.DestinationPath)
+	return nil, fmt.Errorf("exhausted retries mounting drive from %q to %q", drive.Path(), req.DestinationPath)
 }
 
 func (dh driveHandler) UnmountDrive(ctx context.Context, req *drivemount.UnmountDriveRequest) (*types.Empty, error) {
@@ -229,23 +226,18 @@ func (dh driveHandler) UnmountDrive(ctx context.Context, req *drivemount.Unmount
 		return &types.Empty{}, nil
 	}
 
-	return nil, errors.Errorf("failed to unmount the drive %q",
-		drive.Path())
+	return nil, fmt.Errorf("failed to unmount the drive %q", drive.Path())
 }
 
 func isSystemDir(path string) error {
 	resolvedDest, err := evalAnySymlinks(path)
 	if err != nil {
-		return errors.Wrapf(err,
-			"failed to evaluate any symlinks in drive ummount destination %q", path)
+		return fmt.Errorf("failed to evaluate any symlinks in drive unmount destination %q: %w", path, err)
 	}
 
 	for _, systemDir := range bannedSystemDirs {
 		if isOrUnderDir(resolvedDest, systemDir) {
-			return errors.Errorf(
-				"drive mount destination %q resolves to path %q under banned system directory %q",
-				path, resolvedDest, systemDir,
-			)
+			return fmt.Errorf("drive mount destination %q resolves to path %q under banned system directory %q", path, resolvedDest, systemDir)
 		}
 	}
 

agent/service.go

@@ -30,7 +30,6 @@ import (
 	taskAPI "github.com/containerd/containerd/runtime/v2/task"
 	"github.com/gogo/protobuf/types"
 	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/sys/unix"
 
@@ -157,7 +156,7 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 	// this is technically validated earlier by containerd, but is added here too for extra safety
 	taskExecID, err := TaskExecID(taskID, execID)
 	if err != nil {
-		return nil, errors.Wrap(err, "invalid task and/or exec ID")
+		return nil, fmt.Errorf("invalid task and/or exec ID: %w", err)
 	}
 
 	logger := log.G(requestCtx).WithField("TaskID", taskID).WithField("ExecID", execID)
@@ -174,7 +173,7 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 
 	extraData, err := unmarshalExtraData(req.Options)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to unmarshal extra data")
+		return nil, fmt.Errorf("failed to unmarshal extra data: %w", err)
 	}
 
 	// Just provide runc the options it knows about, not our wrapper
@@ -184,7 +183,7 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 	ts.addCleanup(taskExecID, func() error {
 		err := os.RemoveAll(bundleDir.RootPath())
 		if err != nil {
-			return errors.Wrapf(err, "failed to remove bundle path %q", bundleDir.RootPath())
+			return fmt.Errorf("failed to remove bundle path %q: %w", bundleDir.RootPath(), err)
 		}
 		return nil
 	})
@@ -195,22 +194,22 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 	// the bundledir was not created. Create it here.
 	if isVMLocalRootFs {
 		if err := os.MkdirAll(bundleDir.RootfsPath(), 0700); err != nil {
-			return nil, errors.Wrapf(err, "Failed to create bundle's rootfs path from inside the vm %q", bundleDir.RootfsPath())
+			return nil, fmt.Errorf("Failed to create bundle's rootfs path from inside the vm %q: %w", bundleDir.RootfsPath(), err)
 		}
 	}
 
 	// check the rootfs dir has been created (presumed to be by a previous MountDrive call)
 	rootfsStat, err := os.Stat(bundleDir.RootfsPath())
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to stat bundle's rootfs path %q", bundleDir.RootfsPath())
+		return nil, fmt.Errorf("failed to stat bundle's rootfs path %q: %w", bundleDir.RootfsPath(), err)
 	}
 	if !rootfsStat.IsDir() {
-		return nil, errors.Errorf("bundle's rootfs path %q is not a dir", bundleDir.RootfsPath())
+		return nil, fmt.Errorf("bundle's rootfs path %q is not a dir", bundleDir.RootfsPath())
 	}
 	ts.addCleanup(taskExecID, func() error {
 		err := mount.UnmountAll(bundleDir.RootfsPath(), unix.MNT_DETACH)
 		if err != nil {
-			return errors.Wrapf(err, "failed to unmount bundle rootfs %q", bundleDir.RootfsPath())
+			return fmt.Errorf("failed to unmount bundle rootfs %q: %w", bundleDir.RootfsPath(), err)
 		}
 		return nil
 	})
@@ -228,12 +227,12 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 		}
 		specData, err = vm.UpdateUserInSpec(requestCtx, specData, rootfsMount)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to update spec")
+			return nil, fmt.Errorf("failed to update spec: %w", err)
 		}
 	}
 	err = bundleDir.OCIConfig().Write(specData)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to write oci config file")
+		return nil, fmt.Errorf("failed to write oci config file: %w", err)
 	}
 
 	var ioConnectorSet vm.IOProxy
@@ -244,7 +243,7 @@ func (ts *TaskService) Create(requestCtx context.Context, req *taskAPI.CreateTas
 		// Override the incoming stdio FIFOs, which have paths from the host that we can't use
 		fifoSet, err := cio.NewFIFOSetInDir(bundleDir.RootPath(), taskExecID, req.Terminal)
 		if err != nil {
-			err = errors.Wrap(err, "failed to open stdio FIFOs")
+			err = fmt.Errorf("failed to open stdio FIFOs: %w", err)
 			logger.WithError(err).Error()
 			return nil, err
 		}
@@ -331,7 +330,7 @@ func (ts *TaskService) Delete(requestCtx context.Context, req *taskAPI.DeleteReq
 	// this is technically validated earlier by containerd, but is added here too for extra safety
 	taskExecID, err := TaskExecID(taskID, execID)
 	if err != nil {
-		return nil, errors.Wrap(err, "invalid task and/or exec ID")
+		return nil, fmt.Errorf("invalid task and/or exec ID: %w", err)
 	}
 
 	log.G(requestCtx).WithFields(logrus.Fields{"id": taskID, "exec_id": execID}).Debug("delete")
@@ -343,7 +342,7 @@ func (ts *TaskService) Delete(requestCtx context.Context, req *taskAPI.DeleteReq
 
 	err = ts.doCleanup(taskExecID)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to cleanup task %q exec %q", taskID, execID)
+		return nil, fmt.Errorf("failed to cleanup task %q exec %q: %w", taskID, execID, err)
 	}
 
 	log.G(requestCtx).WithFields(logrus.Fields{
@@ -437,7 +436,7 @@ func (ts *TaskService) Exec(requestCtx context.Context, req *taskAPI.ExecProcess
 	// this is technically validated earlier by containerd, but is added here too for extra safety
 	taskExecID, err := TaskExecID(taskID, execID)
 	if err != nil {
-		return nil, errors.Wrap(err, "invalid task and/or exec ID")
+		return nil, fmt.Errorf("invalid task and/or exec ID: %w", err)
 	}
 
 	logger := log.G(requestCtx).WithField("TaskID", taskID).WithField("ExecID", execID)
@@ -454,7 +453,7 @@ func (ts *TaskService) Exec(requestCtx context.Context, req *taskAPI.ExecProcess
 
 	extraData, err := unmarshalExtraData(req.Spec)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to unmarshal extra data")
+		return nil, fmt.Errorf("failed to unmarshal extra data: %w", err)
 	}
 
 	// Just provide runc the options it knows about, not our wrapper
@@ -470,7 +469,7 @@ func (ts *TaskService) Exec(requestCtx context.Context, req *taskAPI.ExecProcess
 		// Override the incoming stdio FIFOs, which have paths from the host that we can't use
 		fifoSet, err := cio.NewFIFOSetInDir(bundleDir.RootPath(), taskExecID, req.Terminal)
 		if err != nil {
-			err = errors.Wrap(err, "failed to open stdio FIFOs")
+			err = fmt.Errorf("failed to open stdio FIFOs: %w", err)
 			logger.WithError(err).Error()
 			return nil, err
 		}

config/config.go

@@ -15,11 +15,10 @@ package config
 
 import (
 	"encoding/json"
+	"fmt"
 	"io/ioutil"
 	"os"
 
-	"github.com/pkg/errors"
-
 	"github.com/firecracker-microvm/firecracker-containerd/internal"
 	"github.com/firecracker-microvm/firecracker-containerd/internal/debug"
 	"github.com/firecracker-microvm/firecracker-containerd/proto"
@@ -81,7 +80,7 @@ func LoadConfig(path string) (*Config, error) {
 
 	data, err := ioutil.ReadFile(path)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to read config from %q", path)
+		return nil, fmt.Errorf("failed to read config from %q: %w", path, err)
 	}
 
 	cfg := &Config{
@@ -103,7 +102,7 @@ func LoadConfig(path string) (*Config, error) {
 	}
 
 	if err := json.Unmarshal(data, cfg); err != nil {
-		return nil, errors.Wrapf(err, "failed to unmarshal config from %q", path)
+		return nil, fmt.Errorf("failed to unmarshal config from %q: %w", path, err)
 	}
 
 	cfg.DebugHelper, err = debug.New(cfg.LogLevels...)

examples/taskworkflow.go

@@ -28,7 +28,6 @@ import (
 	"github.com/containerd/containerd/cio"
 	"github.com/containerd/containerd/namespaces"
 	"github.com/containerd/containerd/oci"
-	"github.com/pkg/errors"
 
 	fcclient "github.com/firecracker-microvm/firecracker-containerd/firecracker-control/client"
 	"github.com/firecracker-microvm/firecracker-containerd/proto"
@@ -63,7 +62,7 @@ func taskWorkflow(containerCIDR, gateway, snapshotter string) (err error) {
 	log.Println("Creating containerd client")
 	client, err := containerd.New(containerdAddress)
 	if err != nil {
-		return errors.Wrapf(err, "creating client")
+		return fmt.Errorf("creating client: %w", err)
 	}
 
 	defer client.Close()
@@ -75,7 +74,7 @@ func taskWorkflow(containerCIDR, gateway, snapshotter string) (err error) {
 		containerd.WithPullSnapshotter(snapshotter),
 	)
 	if err != nil {
-		return errors.Wrapf(err, "creating container")
+		return fmt.Errorf("creating container: %w", err)
 	}
 
 	fcClient, err := fcclient.New(containerdTTRPCAddress)
@@ -110,7 +109,7 @@ func taskWorkflow(containerCIDR, gateway, snapshotter string) (err error) {
 
 	_, err = fcClient.CreateVM(ctx, createVMRequest)
 	if err != nil {
-		return errors.Wrap(err, "failed to create VM")
+		return fmt.Errorf("failed to create VM: %w", err)
 	}
 
 	defer func() {
@@ -143,22 +142,20 @@ func taskWorkflow(containerCIDR, gateway, snapshotter string) (err error) {
 
 	task, err := container.NewTask(ctx, cio.NewCreator(cio.WithStdio))
 	if err != nil {
-		return errors.Wrapf(err, "creating task")
+		return fmt.Errorf("creating task: %w", err)
 
 	}
 	defer task.Delete(ctx)
 
 	log.Printf("Successfully created task: %s for the container\n", task.ID())
 	exitStatusC, err := task.Wait(ctx)
 	if err != nil {
-		return errors.Wrapf(err, "waiting for task")
-
+		return fmt.Errorf("waiting for task: %w", err)
 	}
 
 	log.Println("Completed waiting for the container task")
 	if err := task.Start(ctx); err != nil {
-		return errors.Wrapf(err, "starting task")
-
+		return fmt.Errorf("starting task: %w", err)
 	}
 
 	log.Println("Successfully started the container task")
@@ -169,7 +166,7 @@ func taskWorkflow(containerCIDR, gateway, snapshotter string) (err error) {
 		ip, _, err := net.ParseCIDR(containerCIDR)
 		if err != nil {
 			// this is validated as part of the CreateVM call, should never happen
-			return errors.Wrapf(err, "failed parsing CIDR %q", containerCIDR)
+			return fmt.Errorf("failed parsing CIDR %q: %w", containerCIDR, err)
 		}
 
 		log.Println("Executing http GET on " + ip.String())
@@ -180,13 +177,13 @@ func taskWorkflow(containerCIDR, gateway, snapshotter string) (err error) {
 	}
 
 	if err := task.Kill(ctx, syscall.SIGTERM); err != nil {
-		return errors.Wrapf(err, "killing task")
+		return fmt.Errorf("killing task: %w", err)
 	}
 
 	status := <-exitStatusC
 	code, _, err := status.Result()
 	if err != nil {
-		return errors.Wrapf(err, "getting task's exit code")
+		return fmt.Errorf("getting task's exit code: %w", err)
 	}
 	log.Printf("task exited with status: %d\n", code)
 
@@ -196,13 +193,13 @@ func taskWorkflow(containerCIDR, gateway, snapshotter string) (err error) {
 func getResponse(containerIP string) error {
 	response, err := http.Get(fmt.Sprintf("http://%s/", containerIP))
 	if err != nil {
-		return errors.Wrapf(err, "Unable to get response from %s", containerIP)
+		return fmt.Errorf("Unable to get response from %s: %w", containerIP, err)
 	}
 	defer response.Body.Close()
 
 	contents, err := ioutil.ReadAll(response.Body)
 	if err != nil {
-		return errors.Wrapf(err, "Unable to read response body from %s", containerIP)
+		return fmt.Errorf("Unable to read response body from %s: %w", containerIP, err)
 	}
 
 	log.Printf("Response from [%s]: \n[%s]\n", containerIP, contents)

firecracker-control/client/client.go

@@ -14,8 +14,9 @@
 package client
 
 import (
+	"fmt"
+
 	"github.com/containerd/containerd/pkg/ttrpcutil"
-	"github.com/pkg/errors"
 
 	fccontrol "github.com/firecracker-microvm/firecracker-containerd/proto/service/fccontrol/ttrpc"
 )
@@ -31,7 +32,7 @@ type Client struct {
 func New(ttrpcAddress string) (*Client, error) {
 	ttrpcClient, err := ttrpcutil.NewClient(ttrpcAddress)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create ttrpc client")
+		return nil, fmt.Errorf("failed to create ttrpc client: %w", err)
 	}
 
 	client, err := ttrpcClient.Client()