diff --git a/cmd/convertor/builder/builder.go b/cmd/convertor/builder/builder.go index 5ed922f7..1991ee49 100644 --- a/cmd/convertor/builder/builder.go +++ b/cmd/convertor/builder/builder.go @@ -21,6 +21,7 @@ import ( "crypto/tls" "crypto/x509" "encoding/json" + "errors" "fmt" "io" "net" @@ -42,7 +43,6 @@ import ( "github.com/containerd/platforms" "github.com/opencontainers/go-digest" v1 "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "golang.org/x/sync/errgroup" ) @@ -468,7 +468,7 @@ func (b *overlaybdBuilder) Build(ctx context.Context) (v1.Descriptor, error) { targetDesc, err := b.engine.UploadImage(ctx) if err != nil { - return v1.Descriptor{}, errors.Wrap(err, "failed to upload manifest or config") + return v1.Descriptor{}, fmt.Errorf("failed to upload manifest or config: %w", err) } b.engine.StoreConvertedManifestDetails(ctx) logrus.Info("convert finished") diff --git a/cmd/convertor/builder/builder_engine.go b/cmd/convertor/builder/builder_engine.go index d690561c..d7d3bbda 100644 --- a/cmd/convertor/builder/builder_engine.go +++ b/cmd/convertor/builder/builder_engine.go @@ -30,7 +30,6 @@ import ( "github.com/containerd/log" "github.com/opencontainers/go-digest" specs "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/pkg/errors" ) type BuilderEngineType int @@ -121,11 +120,11 @@ type builderEngineBase struct { func (e *builderEngineBase) isGzipLayer(ctx context.Context, idx int) (bool, error) { rc, err := e.fetcher.Fetch(ctx, e.manifest.Layers[idx]) if err != nil { - return false, errors.Wrapf(err, "isGzipLayer: failed to open layer %d", idx) + return false, fmt.Errorf("isGzipLayer: failed to open layer %d: %w", idx, err) } drc, err := compression.DecompressStream(rc) if err != nil { - return false, errors.Wrapf(err, "isGzipLayer: failed to open decompress stream for layer %d", idx) + return false, fmt.Errorf("isGzipLayer: failed to open decompress stream for layer %d: %w", idx, err) } compress := drc.GetCompression() switch compress { @@ -182,7 +181,7 @@ func (e *builderEngineBase) uploadManifestAndConfig(ctx context.Context) (specs. } if !e.noUpload { if err = uploadBytes(ctx, e.pusher, e.manifest.Config, cbuf); err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to upload config") + return specs.Descriptor{}, fmt.Errorf("failed to upload config: %w", err) } log.G(ctx).Infof("config uploaded") } @@ -206,7 +205,7 @@ func (e *builderEngineBase) uploadManifestAndConfig(ctx context.Context) (specs. } if !e.noUpload { if err = uploadBytes(ctx, e.pusher, manifestDesc, cbuf); err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to upload manifest") + return specs.Descriptor{}, fmt.Errorf("failed to upload manifest: %w", err) } e.outputDesc = manifestDesc log.G(ctx).Infof("manifest uploaded, %s", manifestDesc.Digest) @@ -224,19 +223,19 @@ func (e *builderEngineBase) uploadManifestAndConfig(ctx context.Context) (specs. func getBuilderEngineBase(ctx context.Context, resolver remotes.Resolver, ref, targetRef string) (*builderEngineBase, error) { _, desc, err := resolver.Resolve(ctx, ref) if err != nil { - return nil, errors.Wrapf(err, "failed to resolve reference %q", ref) + return nil, fmt.Errorf("failed to resolve reference %q: %w", ref, err) } fetcher, err := resolver.Fetcher(ctx, ref) if err != nil { - return nil, errors.Wrapf(err, "failed to get fetcher for %q", ref) + return nil, fmt.Errorf("failed to get fetcher for %q: %w", ref, err) } pusher, err := resolver.Pusher(ctx, targetRef) if err != nil { - return nil, errors.Wrapf(err, "failed to get pusher for %q", targetRef) + return nil, fmt.Errorf("failed to get pusher for %q: %w", targetRef, err) } manifest, config, err := fetchManifestAndConfig(ctx, fetcher, desc) if err != nil { - return nil, errors.Wrap(err, "failed to fetch manifest and config") + return nil, fmt.Errorf("failed to fetch manifest and config: %w", err) } return &builderEngineBase{ resolver: resolver, diff --git a/cmd/convertor/builder/builder_utils.go b/cmd/convertor/builder/builder_utils.go index 6fad2c40..39da0c9e 100644 --- a/cmd/convertor/builder/builder_utils.go +++ b/cmd/convertor/builder/builder_utils.go @@ -22,6 +22,7 @@ import ( "context" "crypto/sha256" "encoding/json" + "errors" "fmt" "io" "os" @@ -37,7 +38,6 @@ import ( "github.com/containerd/platforms" "github.com/opencontainers/go-digest" specs "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/pkg/errors" "github.com/sirupsen/logrus" t "github.com/containerd/accelerated-container-image/pkg/types" @@ -252,19 +252,19 @@ func tagPreviouslyConvertedManifest(ctx context.Context, pusher remotes.Pusher, func buildArchiveFromFiles(ctx context.Context, target string, compress compression.Compression, files ...string) error { archive, err := os.Create(target) if err != nil { - return errors.Wrapf(err, "failed to create tgz file: %q", target) + return fmt.Errorf("failed to create tgz file: %q: %w", target, err) } defer archive.Close() fzip, err := compression.CompressStream(archive, compress) if err != nil { - return errors.Wrapf(err, "failed to create compression %v", compress) + return fmt.Errorf("failed to create compression %v: %w", compress, err) } defer fzip.Close() ftar := tar.NewWriter(fzip) defer ftar.Close() for _, file := range files { if err := addFileToArchive(ctx, ftar, file); err != nil { - return errors.Wrapf(err, "failed to add file %q to archive %q", file, target) + return fmt.Errorf("failed to add file %q to archive %q: %w", file, target, err) } } return nil @@ -276,7 +276,7 @@ func addFileToArchive(ctx context.Context, ftar *tar.Writer, filepath string) er if errors.Is(err, os.ErrNotExist) { return nil } - return errors.Wrapf(err, "failed to open file: %q", filepath) + return fmt.Errorf("failed to open file: %q: %w", filepath, err) } defer file.Close() info, err := file.Stat() diff --git a/cmd/convertor/builder/overlaybd_builder.go b/cmd/convertor/builder/overlaybd_builder.go index b1fb135a..089f031d 100644 --- a/cmd/convertor/builder/overlaybd_builder.go +++ b/cmd/convertor/builder/overlaybd_builder.go @@ -21,6 +21,7 @@ import ( "bufio" "context" "encoding/json" + "errors" "fmt" "io" "os" @@ -34,7 +35,6 @@ import ( "github.com/opencontainers/go-digest" "github.com/opencontainers/image-spec/identity" specs "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/pkg/errors" "github.com/sirupsen/logrus" ) @@ -162,7 +162,7 @@ func (e *overlaybdBuilderEngine) UploadLayer(ctx context.Context, idx int) error layerDir := e.getLayerDir(idx) desc, err := getFileDesc(path.Join(layerDir, commitFile), false) if err != nil { - return errors.Wrapf(err, "failed to get descriptor for layer %d", idx) + return fmt.Errorf("failed to get descriptor for layer %d: %w", idx, err) } if e.overlaybdLayers[idx].fromDedup { // validate that the layer digests match if the layer is from dedup @@ -178,7 +178,7 @@ func (e *overlaybdBuilderEngine) UploadLayer(ctx context.Context, idx int) error } if !e.noUpload { if err := uploadBlob(ctx, e.pusher, path.Join(layerDir, commitFile), desc); err != nil { - return errors.Wrapf(err, "failed to upload layer %d", idx) + return fmt.Errorf("failed to upload layer %d: %w", idx, err) } } e.overlaybdLayers[idx].desc = desc @@ -406,7 +406,7 @@ func (e *overlaybdBuilderEngine) DownloadConvertedLayer(ctx context.Context, idx if err != nil { // We should remove the commit file if the download failed to allow for fallback conversion os.Remove(targetFile) // Remove any file that may have failed to download - return errors.Wrapf(err, "failed to download layer %d", idx) + return fmt.Errorf("failed to download layer %d: %w", idx, err) } // Mark that this layer is from dedup e.overlaybdLayers[idx].fromDedup = true @@ -425,7 +425,7 @@ func (e *overlaybdBuilderEngine) uploadBaseLayer(ctx context.Context) (specs.Des tarFile := path.Join(e.workDir, "ext4_64.tar") fdes, err := os.Create(tarFile) if err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to create file %s", tarFile) + return specs.Descriptor{}, fmt.Errorf("failed to create file %s: %w", tarFile, err) } digester := digest.Canonical.Digester() countWriter := &writeCountWrapper{w: io.MultiWriter(fdes, digester.Hash())} @@ -433,11 +433,11 @@ func (e *overlaybdBuilderEngine) uploadBaseLayer(ctx context.Context) (specs.Des fsrc, err := os.Open(overlaybdBaseLayer) if err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to open %s", overlaybdBaseLayer) + return specs.Descriptor{}, fmt.Errorf("failed to open %s: %w", overlaybdBaseLayer, err) } fstat, err := os.Stat(overlaybdBaseLayer) if err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to get info of %s", overlaybdBaseLayer) + return specs.Descriptor{}, fmt.Errorf("failed to get info of %s: %w", overlaybdBaseLayer, err) } if err := tarWriter.WriteHeader(&tar.Header{ @@ -446,13 +446,13 @@ func (e *overlaybdBuilderEngine) uploadBaseLayer(ctx context.Context) (specs.Des Size: fstat.Size(), Typeflag: tar.TypeReg, }); err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to write tar header") + return specs.Descriptor{}, fmt.Errorf("failed to write tar header: %w", err) } if _, err := io.Copy(tarWriter, bufio.NewReader(fsrc)); err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to copy IO") + return specs.Descriptor{}, fmt.Errorf("failed to copy IO: %w", err) } if err = tarWriter.Close(); err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to close tar file") + return specs.Descriptor{}, fmt.Errorf("failed to close tar file: %w", err) } baseDesc := specs.Descriptor{ @@ -467,7 +467,7 @@ func (e *overlaybdBuilderEngine) uploadBaseLayer(ctx context.Context) (specs.Des } if !e.noUpload { if err = uploadBlob(ctx, e.pusher, tarFile, baseDesc); err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to upload baselayer") + return specs.Descriptor{}, fmt.Errorf("failed to upload baselayer: %w", err) } logrus.Infof("baselayer uploaded") } diff --git a/cmd/convertor/builder/turboOCI_builder.go b/cmd/convertor/builder/turboOCI_builder.go index a7a67e92..101e290e 100644 --- a/cmd/convertor/builder/turboOCI_builder.go +++ b/cmd/convertor/builder/turboOCI_builder.go @@ -32,7 +32,6 @@ import ( "github.com/opencontainers/go-digest" specs "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/pkg/errors" "github.com/sirupsen/logrus" ) @@ -115,7 +114,7 @@ func (e *turboOCIBuilderEngine) BuildLayer(ctx context.Context, idx int) error { return err } if err := e.createIdentifier(idx); err != nil { - return errors.Wrapf(err, "failed to create identifier %q", tociIdentifier) + return fmt.Errorf("failed to create identifier %q: %w", tociIdentifier, err) } files := []string{ path.Join(layerDir, fsMetaFile), @@ -127,7 +126,7 @@ func (e *turboOCIBuilderEngine) BuildLayer(ctx context.Context, idx int) error { files = append(files, gzipIndexPath) } if err := buildArchiveFromFiles(ctx, path.Join(layerDir, tociLayerTar), compression.Gzip, files...); err != nil { - return errors.Wrapf(err, "failed to create turboOCIv1 archive for layer %d", idx) + return fmt.Errorf("failed to create turboOCIv1 archive for layer %d: %w", idx, err) } e.overlaybdConfig.Lowers = append(e.overlaybdConfig.Lowers, sn.OverlayBDBSConfigLower{ TargetFile: path.Join(layerDir, "layer.tar"), @@ -144,7 +143,7 @@ func (e *turboOCIBuilderEngine) UploadLayer(ctx context.Context, idx int) error layerDir := e.getLayerDir(idx) desc, err := getFileDesc(path.Join(layerDir, tociLayerTar), false) if err != nil { - return errors.Wrapf(err, "failed to get descriptor for layer %d", idx) + return fmt.Errorf("failed to get descriptor for layer %d: %w", idx, err) } desc.MediaType = e.mediaTypeImageLayerGzip() desc.Annotations = map[string]string{ @@ -169,7 +168,7 @@ func (e *turboOCIBuilderEngine) UploadLayer(ctx context.Context, idx int) error } desc.Annotations[label.TurboOCIMediaType] = targetMediaType if err := uploadBlob(ctx, e.pusher, path.Join(layerDir, tociLayerTar), desc); err != nil { - return errors.Wrapf(err, "failed to upload layer %d", idx) + return fmt.Errorf("failed to upload layer %d: %w", idx, err) } e.tociLayers[idx] = desc return nil @@ -180,7 +179,7 @@ func (e *turboOCIBuilderEngine) UploadImage(ctx context.Context) (specs.Descript layerDir := e.getLayerDir(idx) uncompress, err := getFileDesc(path.Join(layerDir, tociLayerTar), true) if err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to get uncompressed descriptor for layer %d", idx) + return specs.Descriptor{}, fmt.Errorf("failed to get uncompressed descriptor for layer %d: %w", idx, err) } e.manifest.Layers[idx] = e.tociLayers[idx] e.config.RootFS.DiffIDs[idx] = uncompress.Digest @@ -197,7 +196,7 @@ func (e *turboOCIBuilderEngine) UploadImage(ctx context.Context) (specs.Descript } if !e.mkfs { if err := uploadBlob(ctx, e.pusher, overlaybdBaseLayer, baseDesc); err != nil { - return specs.Descriptor{}, errors.Wrapf(err, "failed to upload baselayer %q", overlaybdBaseLayer) + return specs.Descriptor{}, fmt.Errorf("failed to upload baselayer %q: %w", overlaybdBaseLayer, err) } e.manifest.Layers = append([]specs.Descriptor{baseDesc}, e.manifest.Layers...) e.config.RootFS.DiffIDs = append([]digest.Digest{baseDesc.Digest}, e.config.RootFS.DiffIDs...) @@ -260,7 +259,7 @@ func (e *turboOCIBuilderEngine) createIdentifier(idx int) error { targetFile := path.Join(e.getLayerDir(idx), tociIdentifier) file, err := os.Create(targetFile) if err != nil { - return errors.Wrapf(err, "failed to create identifier file %q", tociIdentifier) + return fmt.Errorf("failed to create identifier file %q: %w", tociIdentifier, err) } defer file.Close() return nil diff --git a/cmd/ctr/overlaybd_conv.go b/cmd/ctr/overlaybd_conv.go index 31bbeedc..fe342b10 100644 --- a/cmd/ctr/overlaybd_conv.go +++ b/cmd/ctr/overlaybd_conv.go @@ -17,6 +17,7 @@ package main import ( + "errors" "fmt" "time" @@ -26,7 +27,6 @@ import ( "github.com/containerd/containerd/v2/core/images/converter" "github.com/containerd/containerd/v2/core/leases" _ "github.com/go-sql-driver/mysql" - "github.com/pkg/errors" "github.com/urfave/cli/v2" ) @@ -83,7 +83,7 @@ var convertCommand = &cli.Command{ leases.WithExpiration(1*time.Hour), ) if err != nil { - return errors.Wrap(err, "failed to create lease") + return fmt.Errorf("failed to create lease: %w", err) } defer done(ctx) diff --git a/cmd/ctr/record_trace.go b/cmd/ctr/record_trace.go index 64211787..730807c5 100644 --- a/cmd/ctr/record_trace.go +++ b/cmd/ctr/record_trace.go @@ -22,6 +22,7 @@ import ( "crypto/rand" "encoding/hex" "encoding/json" + "errors" "fmt" "io" "os" @@ -52,7 +53,6 @@ import ( "github.com/opencontainers/image-spec/identity" ocispec "github.com/opencontainers/image-spec/specs-go/v1" "github.com/opencontainers/runtime-spec/specs-go" - "github.com/pkg/errors" "github.com/urfave/cli/v2" "golang.org/x/sys/unix" ) @@ -179,15 +179,15 @@ var recordTraceCommand = &cli.Command{ return errors.New("new image ref must be provided") } if _, err = client.ImageService().Get(ctx, newRef); err == nil { - return errors.Errorf("few image %s exists", newRef) + return fmt.Errorf("few image %s exists", newRef) } else if !errdefs.IsNotFound(err) { - return errors.Errorf("fail to lookup image %s", newRef) + return fmt.Errorf("fail to lookup image %s", newRef) } // Get image instance imgModel, err := client.ImageService().Get(ctx, ref) if err != nil { - return errors.Errorf("fail to get image %s", ref) + return fmt.Errorf("fail to get image %s", ref) } image := containerd.NewImage(client, imgModel) imageManifest, err := images.Manifest(ctx, cs, image.Target(), platforms.Default()) @@ -210,7 +210,7 @@ var recordTraceCommand = &cli.Command{ // Create trace file if err := os.Mkdir(cliCtx.String("working-dir"), 0644); err != nil && !os.IsExist(err) { - return errors.Wrapf(err, "failed to create working dir") + return fmt.Errorf("failed to create working dir: %w", err) } traceFile := filepath.Join(cliCtx.String("working-dir"), uniqueObjectString()) var traceFd *os.File @@ -227,7 +227,7 @@ var recordTraceCommand = &cli.Command{ leases.WithExpiration(maxLeaseTime), ) if err != nil { - return errors.Wrap(err, "failed to create lease") + return fmt.Errorf("failed to create lease: %w", err) } defer deleteLease(ctx) @@ -236,11 +236,11 @@ var recordTraceCommand = &cli.Command{ networkNamespace = uniqueObjectString() namespacePath = "/var/run/netns/" + networkNamespace if err = exec.Command("ip", "netns", "add", networkNamespace).Run(); err != nil { - return errors.Wrapf(err, "failed to add netns") + return fmt.Errorf("failed to add netns: %w", err) } defer func() { if nextErr := exec.Command("ip", "netns", "delete", networkNamespace).Run(); err == nil && nextErr != nil { - err = errors.Wrapf(err, "failed to delete netns") + err = fmt.Errorf("failed to delete netns: %w", nextErr) } }() cniObj, err := createIsolatedNetwork(cliCtx) @@ -249,11 +249,11 @@ var recordTraceCommand = &cli.Command{ } defer func() { if nextErr := cniObj.Remove(ctx, networkNamespace, namespacePath); err == nil && nextErr != nil { - err = errors.Wrapf(nextErr, "failed to teardown network") + err = fmt.Errorf("failed to teardown network: %w", nextErr) } }() if _, err = cniObj.Setup(ctx, networkNamespace, namespacePath); err != nil { - return errors.Wrapf(err, "failed to setup network for namespace") + return fmt.Errorf("failed to setup network for namespace: %w", err) } } @@ -290,7 +290,7 @@ var recordTraceCommand = &cli.Command{ // Wait task stopped status := <-statusC if _, _, err := status.Result(); err != nil { - return errors.Wrapf(err, "failed to get exit status") + return fmt.Errorf("failed to get exit status: %w", err) } if timer.Stop() { @@ -464,7 +464,7 @@ func createImageWithAccelLayer(ctx context.Context, cs content.Store, oldManifes newConfigData, err := json.MarshalIndent(oldConfig, "", " ") if err != nil { - return emptyDesc, errors.Wrap(err, "failed to marshal image") + return emptyDesc, fmt.Errorf("failed to marshal image: %w", err) } newConfigDesc := ocispec.Descriptor{ @@ -474,7 +474,7 @@ func createImageWithAccelLayer(ctx context.Context, cs content.Store, oldManifes } ref := remotes.MakeRefKey(ctx, newConfigDesc) if err := content.WriteBlob(ctx, cs, ref, bytes.NewReader(newConfigData), newConfigDesc); err != nil { - return emptyDesc, errors.Wrap(err, "failed to write image config") + return emptyDesc, fmt.Errorf("failed to write image config: %w", err) } newManifest := ocispec.Manifest{} @@ -490,7 +490,7 @@ func createImageWithAccelLayer(ctx context.Context, cs content.Store, oldManifes MediaType string `json:"mediaType"` }{ Manifest: newManifest, - MediaType: imageMediaType, //images.MediaTypeDockerSchema2Manifest, + MediaType: imageMediaType, // images.MediaTypeDockerSchema2Manifest, } newManifestData, err := json.MarshalIndent(newManifestV2, "", " ") @@ -511,7 +511,7 @@ func createImageWithAccelLayer(ctx context.Context, cs content.Store, oldManifes ref = remotes.MakeRefKey(ctx, newManifestDesc) if err := content.WriteBlob(ctx, cs, ref, bytes.NewReader(newManifestData), newManifestDesc, content.WithLabels(labels)); err != nil { - return emptyDesc, errors.Wrap(err, "failed to write image manifest") + return emptyDesc, fmt.Errorf("failed to write image manifest: %w", err) } return newManifestDesc, nil } @@ -581,10 +581,10 @@ func createIsolatedNetwork(cliCtx *cli.Context) (cni.CNI, error) { cni.WithPluginDir([]string{cliCtx.String("cni-plugin-dir")}), ) if err != nil { - return nil, errors.Wrapf(err, "failed to initialize cni library") + return nil, fmt.Errorf("failed to initialize cni library: %w", err) } if err = cniObj.Load(cni.WithConfListBytes([]byte(cniConf)), cni.WithLoNetwork); err != nil { - return nil, errors.Wrapf(err, "failed to load cni conf") + return nil, fmt.Errorf("failed to load cni conf: %w", err) } return cniObj, nil } @@ -599,7 +599,7 @@ func withNewSnapshot(key string, img containerd.Image, snapshotter, traceFile st s := client.SnapshotService(snapshotter) if s == nil { - return errors.Wrapf(errdefs.ErrNotFound, "snapshotter %s was not found", snapshotter) + return fmt.Errorf("snapshotter %s was not found: %w", snapshotter, errdefs.ErrNotFound) } opt := snapshots.WithLabels(map[string]string{ label.RecordTrace: "yes", diff --git a/cmd/overlaybd-snapshotter/main.go b/cmd/overlaybd-snapshotter/main.go index 9c4ac4f0..4c5ef96f 100644 --- a/cmd/overlaybd-snapshotter/main.go +++ b/cmd/overlaybd-snapshotter/main.go @@ -19,6 +19,7 @@ package main import ( "context" "encoding/json" + "fmt" "net" "os" "os/signal" @@ -31,7 +32,6 @@ import ( snapshotsapi "github.com/containerd/containerd/api/services/snapshots/v1" "github.com/containerd/containerd/v2/contrib/snapshotservice" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "golang.org/x/sys/unix" "google.golang.org/grpc" @@ -46,10 +46,10 @@ func parseConfig(fpath string) error { logrus.Info("parse config file: ", fpath) data, err := os.ReadFile(fpath) if err != nil { - return errors.Wrapf(err, "failed to read plugin config from %s", fpath) + return fmt.Errorf("failed to read plugin config from %s: %w", fpath, err) } if err := json.Unmarshal(data, pconfig); err != nil { - return errors.Wrapf(err, "failed to parse plugin config from %s", string(data)) + return fmt.Errorf("failed to parse plugin config from %s: %w", string(data), err) } logrus.Infof("snapshotter commitID: %s, rwMode: %s, autoRemove: %v, writableLayerType: %s, asyncRemoveSnapshot: %v", commitID, pconfig.RwMode, pconfig.AutoRemoveDev, pconfig.WritableLayerType, pconfig.AsyncRemove) diff --git a/go.mod b/go.mod index bce20376..07fd3ecc 100644 --- a/go.mod +++ b/go.mod @@ -13,13 +13,11 @@ require ( github.com/data-accelerator/zdfs v0.1.5 github.com/docker/go-units v0.5.0 github.com/go-sql-driver/mysql v1.8.1 - github.com/jessevdk/go-flags v1.6.1 github.com/moby/locker v1.0.1 github.com/moby/sys/mountinfo v0.7.1 github.com/opencontainers/go-digest v1.0.0 github.com/opencontainers/image-spec v1.1.0 github.com/opencontainers/runtime-spec v1.2.0 - github.com/pkg/errors v0.9.1 github.com/prometheus/client_golang v1.19.1 github.com/sirupsen/logrus v1.9.3 github.com/spf13/cobra v1.8.1 @@ -73,6 +71,7 @@ require ( github.com/opencontainers/runtime-tools v0.9.1-0.20221107090550-2e043c6bd626 // indirect github.com/opencontainers/selinux v1.11.0 // indirect github.com/pelletier/go-toml/v2 v2.2.2 // indirect + github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/prometheus/client_model v0.5.0 // indirect github.com/prometheus/common v0.48.0 // indirect diff --git a/go.sum b/go.sum index bd145091..64120ae5 100644 --- a/go.sum +++ b/go.sum @@ -132,8 +132,6 @@ github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/intel/goresctrl v0.7.0 h1:x6RclP6LiJc24t9mf47BRbjf06B8oVisZMBv31x3rKc= github.com/intel/goresctrl v0.7.0/go.mod h1:T3ZZnuHSNouwELB5wvOoUJaB7l/4Rm23rJy/wuWJlr0= -github.com/jessevdk/go-flags v1.6.1 h1:Cvu5U8UGrLay1rZfv/zP7iLpSHGUZ/Ou68T0iX1bBK4= -github.com/jessevdk/go-flags v1.6.1/go.mod h1:Mk8T1hIAWpOiJiHa9rJASDK2UGWji0EuPGBnNLMooyc= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU= diff --git a/pkg/convertor/convertor.go b/pkg/convertor/convertor.go index 9533c107..47c95a90 100644 --- a/pkg/convertor/convertor.go +++ b/pkg/convertor/convertor.go @@ -51,7 +51,6 @@ import ( "github.com/opencontainers/go-digest" "github.com/opencontainers/image-spec/identity" ocispec "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/pkg/errors" "golang.org/x/sync/errgroup" ) @@ -111,7 +110,7 @@ func (loader *contentLoader) Load(ctx context.Context, cs content.Store) (l Laye refName := fmt.Sprintf(ConvContentNameFormat, UniquePart()) contentWriter, err := content.OpenWriter(ctx, cs, content.WithRef(refName)) if err != nil { - return emptyLayer, errors.Wrapf(err, "failed to open content writer") + return emptyLayer, fmt.Errorf("failed to open content writer: %w", err) } defer contentWriter.Close() @@ -135,12 +134,12 @@ func (loader *contentLoader) Load(ctx context.Context, cs content.Store) (l Laye err := utils.Commit(ctx, commitPath, commitPath, true, "-z", "-t") if err != nil { - return emptyLayer, errors.Wrapf(err, "failed to overlaybd-commit for sealed file") + return emptyLayer, fmt.Errorf("failed to overlaybd-commit for sealed file: %w", err) } srcFile, err := os.Open(commitFile) if err != nil { - return emptyLayer, errors.Wrapf(err, "failed to open src file of %s", loader.SrcFilePath) + return emptyLayer, fmt.Errorf("failed to open src file of %s: %w", loader.SrcFilePath, err) } openedSrcFile = append(openedSrcFile, srcFile) _, err = io.Copy(countWriter, bufio.NewReader(srcFile)) @@ -153,13 +152,13 @@ func (loader *contentLoader) Load(ctx context.Context, cs content.Store) (l Laye srcPathList = append(srcPathList, loader.SrcFilePath) srcFile, err := os.Open(loader.SrcFilePath) if err != nil { - return emptyLayer, errors.Wrapf(err, "failed to open src file of %s", loader.SrcFilePath) + return emptyLayer, fmt.Errorf("failed to open src file of %s: %w", loader.SrcFilePath, err) } openedSrcFile = append(openedSrcFile, srcFile) fi, err := srcFile.Stat() if err != nil { - return emptyLayer, errors.Wrapf(err, "failed to get info of %s", loader.SrcFilePath) + return emptyLayer, fmt.Errorf("failed to get info of %s: %w", loader.SrcFilePath, err) } if err := tarWriter.WriteHeader(&tar.Header{ @@ -168,17 +167,17 @@ func (loader *contentLoader) Load(ctx context.Context, cs content.Store) (l Laye Size: fi.Size(), Typeflag: tar.TypeReg, }); err != nil { - return emptyLayer, errors.Wrapf(err, "failed to write tar header") + return emptyLayer, fmt.Errorf("failed to write tar header: %w", err) } if _, err := io.Copy(tarWriter, bufio.NewReader(srcFile)); err != nil { - return emptyLayer, errors.Wrapf(err, "failed to copy IO") + return emptyLayer, fmt.Errorf("failed to copy IO: %w", err) } } } if err = tarWriter.Close(); err != nil { - return emptyLayer, errors.Wrapf(err, "failed to close tar file") + return emptyLayer, fmt.Errorf("failed to close tar file: %w", err) } labels := map[string]string{ @@ -187,7 +186,7 @@ func (loader *contentLoader) Load(ctx context.Context, cs content.Store) (l Laye if err := contentWriter.Commit(ctx, countWriter.c, digester.Digest(), content.WithLabels(labels)); err != nil { if !errdefs.IsAlreadyExists(err) { - return emptyLayer, errors.Wrapf(err, "failed to commit content") + return emptyLayer, fmt.Errorf("failed to commit content: %w", err) } } @@ -299,7 +298,7 @@ func (c *overlaybdConvertor) commitImage(ctx context.Context, srcManifest ocispe configData, err := json.MarshalIndent(imgCfg, "", " ") if err != nil { - return emptyDesc, errors.Wrap(err, "failed to marshal image") + return emptyDesc, fmt.Errorf("failed to marshal image: %w", err) } config := ocispec.Descriptor{ @@ -310,11 +309,11 @@ func (c *overlaybdConvertor) commitImage(ctx context.Context, srcManifest ocispe ref := remotes.MakeRefKey(ctx, config) if err := content.WriteBlob(ctx, c.cs, ref, bytes.NewReader(configData), config); err != nil { - return ocispec.Descriptor{}, errors.Wrap(err, "failed to write image config") + return ocispec.Descriptor{}, fmt.Errorf("failed to write image config: %w", err) } if c.remote { if err := c.pushObject(ctx, config); err != nil { - return ocispec.Descriptor{}, errors.Wrap(err, "failed to push image config") + return ocispec.Descriptor{}, fmt.Errorf("failed to push image config: %w", err) } log.G(ctx).Infof("config pushed") } @@ -339,11 +338,11 @@ func (c *overlaybdConvertor) commitImage(ctx context.Context, srcManifest ocispe ref = remotes.MakeRefKey(ctx, desc) if err := content.WriteBlob(ctx, c.cs, ref, bytes.NewReader(mb), desc, content.WithLabels(labels)); err != nil { - return emptyDesc, errors.Wrap(err, "failed to write image manifest") + return emptyDesc, fmt.Errorf("failed to write image manifest: %w", err) } if c.remote { if err := c.pushObject(ctx, desc); err != nil { - return ocispec.Descriptor{}, errors.Wrap(err, "failed to push image manifest") + return ocispec.Descriptor{}, fmt.Errorf("failed to push image manifest: %w", err) } log.G(ctx).Infof("image pushed") } @@ -378,7 +377,7 @@ func (c *overlaybdConvertor) findRemote(ctx context.Context, chainID string) (oc // invalid record in db, which is not found in registry, remove it _, err := c.db.Exec("delete from overlaybd_layers where host=? and repo=? and chain_id=?", c.host, c.repo, chainID) if err != nil { - return emptyDesc, errors.Wrapf(err, "failed to remove invalid record in db") + return emptyDesc, fmt.Errorf("failed to remove invalid record in db: %w", err) } } } @@ -510,10 +509,10 @@ func (c *overlaybdConvertor) convertLayers(ctx context.Context, srcDescs []ocisp if !errdefs.IsAlreadyExists(err) { // failed to prepare remote snapshot if err == nil { - //rollback + // rollback c.sn.Remove(ctx, "prepare-"+key) } - return nil, errors.Wrapf(err, "failed to prepare remote snapshot") + return nil, fmt.Errorf("failed to prepare remote snapshot: %w", err) } lastParentID = key commitLayers[idx] = Layer{ @@ -588,7 +587,7 @@ func (c *overlaybdConvertor) applyOCIV1LayerInObd( ra, err := c.cs.ReaderAt(ctx, desc) if err != nil { - return emptyString, errors.Wrapf(err, "failed to get reader %s from content store", desc.Digest) + return emptyString, fmt.Errorf("failed to get reader %s from content store: %w", desc.Digest, err) } defer ra.Close() @@ -605,7 +604,7 @@ func (c *overlaybdConvertor) applyOCIV1LayerInObd( if errdefs.IsAlreadyExists(err) { continue } - return emptyString, errors.Wrapf(err, "failed to preprare snapshot %q", key) + return emptyString, fmt.Errorf("failed to preprare snapshot %q: %w", key, err) } break @@ -627,7 +626,7 @@ func (c *overlaybdConvertor) applyOCIV1LayerInObd( rc, err = compression.DecompressStream(rc) if err != nil { - return emptyString, errors.Wrap(err, "failed to detect layer mediatype") + return emptyString, fmt.Errorf("failed to detect layer mediatype: %w", err) } if err = mount.WithTempMount(ctx, mounts, func(root string) error { @@ -637,7 +636,7 @@ func (c *overlaybdConvertor) applyOCIV1LayerInObd( } return err }); err != nil { - return emptyString, errors.Wrapf(err, "failed to apply layer in snapshot %s", key) + return emptyString, fmt.Errorf("failed to apply layer in snapshot %s: %w", key, err) } // Read any trailing data @@ -765,7 +764,7 @@ func IndexConvertFunc(opts ...Option) converter.ConvertFunc { srcManifest, err := images.Manifest(ctx, cs, srcImg.Target(), platforms.Default()) if err != nil { - return nil, errors.Wrapf(err, "failed to read manifest") + return nil, fmt.Errorf("failed to read manifest: %w", err) } zfileCfg := ZFileConfig{ Algorithm: copts.algorithm, diff --git a/pkg/snapshot/diskquota/prjquota.go b/pkg/snapshot/diskquota/prjquota.go index bfaa3a19..004a1571 100644 --- a/pkg/snapshot/diskquota/prjquota.go +++ b/pkg/snapshot/diskquota/prjquota.go @@ -27,7 +27,6 @@ import ( "strings" "sync" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/containerd/containerd/v2/core/mount" @@ -70,12 +69,12 @@ func SetDiskQuotaBytes(dir string, limit int64, quotaID uint32) error { } if err := checkDevLimit(mountPoint, uint64(limit)); err != nil { - return errors.Wrapf(err, "failed to check device limit, dir: (%s), limit: (%d)kb", dir, limit) + return fmt.Errorf("failed to check device limit, dir: (%s), limit: (%d)kb: %w", dir, limit, err) } err = driver.SetFileAttr(dir, quotaID) if err != nil { - return errors.Wrapf(err, "failed to set subtree, dir: (%s), quota id: (%d)", dir, quotaID) + return fmt.Errorf("failed to set subtree, dir: (%s), quota id: (%d): %w", dir, quotaID, err) } return driver.setQuota(quotaID, uint64(limit/1024), mountPoint) @@ -110,16 +109,16 @@ func (quota *PrjQuotaDriver) SetDiskQuota(dir string, size string, quotaID uint3 limit, err := units.RAMInBytes(size) if err != nil { - return errors.Wrapf(err, "failed to change size: (%s) to kilobytes", size) + return fmt.Errorf("failed to change size: (%s) to kilobytes: %w", size, err) } if err := checkDevLimit(mountPoint, uint64(limit)); err != nil { - return errors.Wrapf(err, "failed to check device limit, dir: (%s), limit: (%d)kb", dir, limit) + return fmt.Errorf("failed to check device limit, dir: (%s), limit: (%d)kb: %w", dir, limit, err) } err = quota.SetFileAttr(dir, quotaID) if err != nil { - return errors.Wrapf(err, "failed to set subtree, dir: (%s), quota id: (%d)", dir, quotaID) + return fmt.Errorf("failed to set subtree, dir: (%s), quota id: (%d): %w", dir, quotaID, err) } return quota.setQuota(quotaID, uint64(limit/1024), mountPoint) @@ -128,7 +127,7 @@ func (quota *PrjQuotaDriver) SetDiskQuota(dir string, size string, quotaID uint3 func (quota *PrjQuotaDriver) CheckMountpoint(dir string) (string, bool, error) { mountInfo, err := mount.Lookup(dir) if err != nil { - return "", false, errors.Wrapf(err, "failed to get mount info, dir(%s)", dir) + return "", false, fmt.Errorf("failed to get mount info, dir(%s): %w", dir, err) } if strings.Contains(mountInfo.VFSOptions, "prjquota") { return mountInfo.Mountpoint, true, nil @@ -149,8 +148,8 @@ func (quota *PrjQuotaDriver) setQuota(quotaID uint32, blockLimit uint64, mountPo // logrus.Infof("setquota -P %s 0 %s 0 0 %s", quotaIDStr, blockLimitStr, mountPoint) stdout, stderr, err := ExecSync("setquota", "-P", quotaIDStr, "0", blockLimitStr, "0", "0", mountPoint) if err != nil { - return errors.Wrapf(err, "failed to set quota, mountpoint: (%s), quota id: (%d), quota: (%d kbytes), stdout: (%s), stderr: (%s)", - mountPoint, quotaID, blockLimit, stdout, stderr) + return fmt.Errorf("failed to set quota, mountpoint: (%s), quota id: (%d), quota: (%d kbytes), stdout: (%s), stderr: (%s): %w", + mountPoint, quotaID, blockLimit, stdout, stderr, err) } return nil } @@ -191,7 +190,7 @@ func (quota *PrjQuotaDriver) GetNextQuotaID() (quotaID uint32, err error) { if quota.LastID == 0 { quota.QuotaIDs, quota.LastID, err = loadQuotaIDs("-Pan") if err != nil { - return 0, errors.Wrap(err, "failed to load quota list") + return 0, fmt.Errorf("failed to load quota list: %w", err) } } id := quota.LastID @@ -207,7 +206,7 @@ func (quota *PrjQuotaDriver) GetNextQuotaID() (quotaID uint32, err error) { logrus.Infof("reach the maximum, try to reuse quotaID") quota.QuotaIDs, quota.LastID, err = loadQuotaIDs("-Pan") if err != nil { - return 0, errors.Wrap(err, "failed to load quota list") + return 0, fmt.Errorf("failed to load quota list: %w", err) } id = quota.LastID } @@ -226,8 +225,7 @@ func (quota *PrjQuotaDriver) SetFileAttr(dir string, quotaID uint32) error { // ext4 use chattr to change project id stdout, stderr, err := ExecSync("chattr", "-p", strID, "+P", dir) if err != nil { - return errors.Wrapf(err, "failed to set file(%s) quota id(%s), stdout: (%s), stderr: (%s)", - dir, strID, stdout, stderr) + return fmt.Errorf("failed to set file(%s) quota id(%s), stdout: (%s), stderr: (%s): %w", dir, strID, stdout, stderr, err) } logrus.Debugf("set quota id (%s) to file (%s) attr", strID, dir) diff --git a/pkg/snapshot/diskquota/quota_utils.go b/pkg/snapshot/diskquota/quota_utils.go index 4b6da1fa..c959fe65 100644 --- a/pkg/snapshot/diskquota/quota_utils.go +++ b/pkg/snapshot/diskquota/quota_utils.go @@ -26,8 +26,6 @@ import ( "os/exec" "strings" "syscall" - - "github.com/pkg/errors" ) // CheckRegularFile is used to check the file is regular file or directory. @@ -60,8 +58,8 @@ func loadQuotaIDs(repquotaOpt string) (map[uint32]struct{}, uint32, error) { minID := QuotaMinID output, stderr, err := ExecSync("repquota", repquotaOpt) if err != nil { - return nil, 0, errors.Wrapf(err, "failed to execute [repquota %s], stdout: (%s), stderr: (%s)", - repquotaOpt, output, stderr) + return nil, 0, fmt.Errorf("failed to execute [repquota %s], stdout: (%s), stderr: (%s): %w", + repquotaOpt, output, stderr, err) } lines := strings.Split(output, "\n") @@ -92,7 +90,7 @@ func getDevLimit(mountPoint string) (uint64, error) { // get storage upper limit of the device which the dir is on. var stfs syscall.Statfs_t if err := syscall.Statfs(mountPoint, &stfs); err != nil { - return 0, errors.Wrapf(err, "failed to get path(%s) limit", mountPoint) + return 0, fmt.Errorf("failed to get path(%s) limit: %w", mountPoint, err) } return stfs.Blocks * uint64(stfs.Bsize), nil } @@ -101,7 +99,7 @@ func getDevLimit(mountPoint string) (uint64, error) { func checkDevLimit(mountPoint string, size uint64) error { limit, err := getDevLimit(mountPoint) if err != nil { - return errors.Wrapf(err, "failed to get device(%s) limit", mountPoint) + return fmt.Errorf("failed to get device(%s) limit: %w", mountPoint, err) } if limit < size { diff --git a/pkg/snapshot/overlay.go b/pkg/snapshot/overlay.go index a06d6e41..057fc398 100644 --- a/pkg/snapshot/overlay.go +++ b/pkg/snapshot/overlay.go @@ -20,6 +20,7 @@ import ( "bytes" "context" "encoding/binary" + "errors" "fmt" "os" "os/exec" @@ -44,7 +45,6 @@ import ( "github.com/containerd/errdefs" "github.com/containerd/log" "github.com/moby/locker" - "github.com/pkg/errors" ) // storageType is used to indicate that what kind of the snapshot it is. @@ -462,7 +462,7 @@ func (o *snapshotter) createMountPoint(ctx context.Context, kind snapshots.Kind, if parent != "" { parentID, parentInfo, _, err = storage.GetInfo(ctx, parent) if err != nil { - return nil, errors.Wrapf(err, "failed to get info of parent snapshot %s", parent) + return nil, fmt.Errorf("failed to get info of parent snapshot %s: %w", parent, err) } } @@ -477,7 +477,7 @@ func (o *snapshotter) createMountPoint(ctx context.Context, kind snapshots.Kind, log.G(ctx).Debugf("Prepare (targetRefLabel: %s, accelLayerLabel: %s)", targetRef, isAccelLayer) if isAccelLayer == "yes" { if err := o.constructSpecForAccelLayer(id, parentID); err != nil { - return nil, errors.Wrapf(err, "constructSpecForAccelLayer failed: id %s", id) + return nil, fmt.Errorf("constructSpecForAccelLayer failed: id %s: %w", id, err) } rollback = false if err := t.Commit(); err != nil { @@ -540,7 +540,7 @@ func (o *snapshotter) createMountPoint(ctx context.Context, kind snapshots.Kind, if err := t.Commit(); err != nil { return nil, err } - return nil, errors.Wrapf(errdefs.ErrAlreadyExists, "target snapshot %q", targetRef) + return nil, fmt.Errorf("target snapshot %q: %w", targetRef, errdefs.ErrAlreadyExists) } } @@ -590,7 +590,7 @@ func (o *snapshotter) createMountPoint(ctx context.Context, kind snapshots.Kind, err = o.updateSpec(parentID, false, "") } if err != nil { - return nil, errors.Wrapf(err, "updateSpec failed for snapshot %s", parentID) + return nil, fmt.Errorf("updateSpec failed for snapshot %s: %w", parentID, err) } } @@ -616,7 +616,7 @@ func (o *snapshotter) createMountPoint(ctx context.Context, kind snapshots.Kind, obdID, writeType, fsType, o.overlaybdTargetPath(obdID)) if err = o.attachAndMountBlockDevice(ctx, obdID, writeType, fsType, parent == ""); err != nil { log.G(ctx).Errorf("%v", err) - return nil, errors.Wrapf(err, "failed to attach and mount for snapshot %v", obdID) + return nil, fmt.Errorf("failed to attach and mount for snapshot %v: %w", obdID, err) } defer func() { @@ -661,7 +661,7 @@ func (o *snapshotter) createMountPoint(ctx context.Context, kind snapshots.Kind, case storageTypeLocalBlock, storageTypeRemoteBlock: m, err = o.basedOnBlockDeviceMount(ctx, s, writeType) if err != nil { - return nil, errors.Wrapf(err, "%s", err.Error()) + return nil, err } default: panic("unreachable") @@ -732,7 +732,7 @@ func (o *snapshotter) Mounts(ctx context.Context, key string) (_ []mount.Mount, s, err := storage.GetSnapshot(ctx, key) if err != nil { - return nil, errors.Wrap(err, "failed to get active mount") + return nil, fmt.Errorf("failed to get active mount: %w", err) } log.G(ctx).Debugf("Mounts (key: %s, id: %s, parentID: %s, kind: %d)", key, s.ID, s.ParentIDs, s.Kind) @@ -747,7 +747,7 @@ func (o *snapshotter) Mounts(ctx context.Context, key string) (_ []mount.Mount, _, info, _, err := storage.GetInfo(ctx, key) if err != nil { - return nil, errors.Wrap(err, "failed to get info") + return nil, fmt.Errorf("failed to get info: %w", err) } writeType := o.getWritableType(ctx, s.ID, info) @@ -757,12 +757,12 @@ func (o *snapshotter) Mounts(ctx context.Context, key string) (_ []mount.Mount, parentID, parentInfo, _, err := storage.GetInfo(ctx, info.Parent) if err != nil { - return nil, errors.Wrapf(err, "failed to get info of parent snapshot %s", info.Parent) + return nil, fmt.Errorf("failed to get info of parent snapshot %s: %w", info.Parent, err) } parentStype, err := o.identifySnapshotStorageType(ctx, parentID, parentInfo) if err != nil { - return nil, errors.Wrapf(err, "failed to identify storage of parent snapshot %s", parentInfo.Name) + return nil, fmt.Errorf("failed to identify storage of parent snapshot %s: %w", parentInfo.Name, err) } if parentStype == storageTypeRemoteBlock || parentStype == storageTypeLocalBlock { @@ -775,7 +775,7 @@ func (o *snapshotter) Mounts(ctx context.Context, key string) (_ []mount.Mount, } } if err := o.attachAndMountBlockDevice(ctx, parentID, RoDir, fsType, false); err != nil { - return nil, errors.Wrapf(err, "failed to attach and mount for snapshot %v", key) + return nil, fmt.Errorf("failed to attach and mount for snapshot %v: %w", key, err) } return o.basedOnBlockDeviceMount(ctx, s, RoDir) } @@ -818,7 +818,7 @@ func (o *snapshotter) Commit(ctx context.Context, name, key string, opts ...snap id, oinfo, _, err := storage.GetInfo(ctx, key) if err != nil { - return errors.Wrapf(err, "failed to get info of snapshot %s", key) + return fmt.Errorf("failed to get info of snapshot %s: %w", key, err) } // if writable, should commit the data and make it immutable. @@ -830,7 +830,7 @@ func (o *snapshotter) Commit(ctx context.Context, name, key string, opts ...snap log.G(ctx).Info("not an overlaybd writable layer") } else { if err := o.unmountAndDetachBlockDevice(ctx, id, key); err != nil { - return errors.Wrapf(err, "failed to destroy target device for snapshot %s", key) + return fmt.Errorf("failed to destroy target device for snapshot %s: %w", key, err) } if err := o.sealWritableOverlaybd(ctx, id); err != nil { @@ -865,7 +865,7 @@ func (o *snapshotter) Commit(ctx context.Context, name, key string, opts ...snap if isTurboOCI, digest, _ := o.checkTurboOCI(info.Labels); isTurboOCI { log.G(ctx).Infof("commit turboOCI.v1 layer: (%s, %s)", id, digest) if err := o.constructOverlayBDSpec(ctx, name, false); err != nil { - return errors.Wrapf(err, "failed to construct overlaybd config") + return fmt.Errorf("failed to construct overlaybd config: %w", err) } stype = storageTypeNormal } @@ -875,14 +875,14 @@ func (o *snapshotter) Commit(ctx context.Context, name, key string, opts ...snap if stype == storageTypeLocalLayer { log.G(ctx).Infof("convet a local blob to turboOCI layer (sn: %s)", id) if err := o.constructOverlayBDSpec(ctx, name, false); err != nil { - return errors.Wrapf(err, "failed to construct overlaybd config") + return fmt.Errorf("failed to construct overlaybd config: %w", err) } stype = storageTypeLocalBlock } if stype == storageTypeLocalBlock { if err := o.constructOverlayBDSpec(ctx, name, false); err != nil { - return errors.Wrapf(err, "failed to construct overlaybd config") + return fmt.Errorf("failed to construct overlaybd config: %w", err) } if info.Labels == nil { @@ -915,7 +915,7 @@ func (o *snapshotter) commit(ctx context.Context, name, key string, opts ...snap } if _, err := storage.CommitActive(ctx, key, name, snapshots.Usage(usage), opts...); err != nil { - return "", snapshots.Info{}, errors.Wrap(err, "failed to commit snapshot") + return "", snapshots.Info{}, fmt.Errorf("failed to commit snapshot: %w", err) } id, info, _, err := storage.GetInfo(ctx, name) @@ -1058,13 +1058,13 @@ func (o *snapshotter) Remove(ctx context.Context, key string) (err error) { _, _, err = storage.Remove(ctx, key) if err != nil { - return errors.Wrap(err, "failed to remove") + return fmt.Errorf("failed to remove: %w", err) } if !o.asyncRemove { var removals []string removals, err = o.getCleanupDirectories(ctx, t) if err != nil { - return errors.Wrap(err, "unable to get directories for removal") + return fmt.Errorf("unable to get directories for removal: %w", err) } defer func() { if err == nil { @@ -1105,7 +1105,7 @@ func (o *snapshotter) Walk(ctx context.Context, fn snapshots.WalkFunc, fs ...str func (o *snapshotter) prepareDirectory(ctx context.Context, snapshotDir string, kind snapshots.Kind) (string, error) { td, err := os.MkdirTemp(snapshotDir, "new-") if err != nil { - return "", errors.Wrap(err, "failed to create temp dir") + return "", fmt.Errorf("failed to create temp dir: %w", err) } if err := os.Mkdir(filepath.Join(td, "fs"), 0755); err != nil { @@ -1301,7 +1301,7 @@ func (o *snapshotter) createSnapshot(ctx context.Context, kind snapshots.Kind, k if path != "" { if err1 := os.RemoveAll(path); err1 != nil { log.G(ctx).WithError(err1).WithField("path", path).Error("failed to reclaim snapshot directory, directory may need removal") - err = errors.Wrapf(err, "failed to remove path: %v", err1) + err = fmt.Errorf("failed to remove path: %v: %w", err1, err) } } } @@ -1311,23 +1311,23 @@ func (o *snapshotter) createSnapshot(ctx context.Context, kind snapshots.Kind, k td, err = o.prepareDirectory(ctx, snapshotDir, kind) if err != nil { - return "", snapshots.Info{}, errors.Wrap(err, "failed to create prepare snapshot dir") + return "", snapshots.Info{}, fmt.Errorf("failed to create prepare snapshot dir: %w", err) } s, err := storage.CreateSnapshot(ctx, kind, key, parent, opts...) if err != nil { - return "", snapshots.Info{}, errors.Wrap(err, "failed to create snapshot") + return "", snapshots.Info{}, fmt.Errorf("failed to create snapshot: %w", err) } if len(s.ParentIDs) > 0 { st, err := os.Stat(o.upperPath(s.ParentIDs[0])) if err != nil { - return "", snapshots.Info{}, errors.Wrap(err, "failed to stat parent") + return "", snapshots.Info{}, fmt.Errorf("failed to stat parent: %w", err) } stat := st.Sys().(*syscall.Stat_t) if err := os.Lchown(filepath.Join(td, "fs"), int(stat.Uid), int(stat.Gid)); err != nil { - return "", snapshots.Info{}, errors.Wrap(err, "failed to chown") + return "", snapshots.Info{}, fmt.Errorf("failed to chown: %w", err) } } // _, tmpinfo, _, err := storage.GetInfo(ctx, key) @@ -1337,26 +1337,26 @@ func (o *snapshotter) createSnapshot(ctx context.Context, kind snapshots.Kind, k log.G(ctx).Infof("set usage quota %s for rootfs(sn: %s)", diskQuotaSize, s.ID) upperPath := filepath.Join(td, "fs") if err := o.setDiskQuota(ctx, upperPath, diskQuotaSize, diskquota.QuotaMinID); err != nil { - return "", snapshots.Info{}, errors.Wrapf(err, "failed to set diskquota on upperpath, snapshot id: %s", s.ID) + return "", snapshots.Info{}, fmt.Errorf("failed to set diskquota on upperpath, snapshot id: %s: %w", s.ID, err) } // if there's no parent, we just return a bind mount, so no need to set quota on workerpath if len(s.ParentIDs) > 0 { workpath := filepath.Join(td, "work") if err := o.setDiskQuota(ctx, workpath, diskQuotaSize, diskquota.QuotaMinID); err != nil { - return "", snapshots.Info{}, errors.Wrapf(err, "failed to set diskquota on workpath, snapshot id: %s", s.ID) + return "", snapshots.Info{}, fmt.Errorf("failed to set diskquota on workpath, snapshot id: %s: %w", s.ID, err) } } } } path = filepath.Join(snapshotDir, s.ID) if err = os.Rename(td, path); err != nil { - return "", snapshots.Info{}, errors.Wrap(err, "failed to rename") + return "", snapshots.Info{}, fmt.Errorf("failed to rename: %w", err) } td = "" // id, info, _, err := storage.GetInfo(ctx, key) if err != nil { - return "", snapshots.Info{}, errors.Wrap(err, "failed to get snapshot info") + return "", snapshots.Info{}, fmt.Errorf("failed to get snapshot info: %w", err) } img, ok := info.Labels[label.CRIImageRef] if !ok { @@ -1448,7 +1448,7 @@ func (o *snapshotter) setDiskQuota(ctx context.Context, dir string, size string, log.G(ctx).Infof("try to set disk quota, dir(%s), size(%s), quotaID(%d)", dir, size, quotaID) if err := o.quotaDriver.SetDiskQuota(dir, size, quotaID); err != nil { - return errors.Wrapf(err, "failed to set dir(%s) disk quota", dir) + return fmt.Errorf("failed to set dir(%s) disk quota: %w", dir, err) } return nil } @@ -1575,7 +1575,7 @@ func (o *snapshotter) identifyLocalStorageType(filePath string) (storageType, er _, err = f.Read(data) f.Close() if err != nil { - return storageTypeUnknown, errors.Wrapf(err, "failed to read %s", filePath) + return storageTypeUnknown, fmt.Errorf("failed to read %s: %w", filePath, err) } if isOverlaybdFileHeader(data) { diff --git a/pkg/snapshot/storage.go b/pkg/snapshot/storage.go index c1471f45..0b9c2328 100644 --- a/pkg/snapshot/storage.go +++ b/pkg/snapshot/storage.go @@ -46,7 +46,6 @@ import ( "github.com/containerd/log" "github.com/moby/sys/mountinfo" specs "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "golang.org/x/sys/unix" ) @@ -193,7 +192,7 @@ func (o *snapshotter) unmountAndDetachBlockDevice(ctx context.Context, snID stri } log.G(ctx).Infof("umount device, mountpoint: %s", mountPoint) if err := mount.UnmountAll(mountPoint, 0); err != nil { - return errors.Wrapf(err, "failed to umount %s", mountPoint) + return fmt.Errorf("failed to umount %s: %w", mountPoint, err) } loopDevID := o.overlaybdLoopbackDeviceID(snID) @@ -202,12 +201,12 @@ func (o *snapshotter) unmountAndDetachBlockDevice(ctx context.Context, snID stri err = os.RemoveAll(linkPath) if err != nil { - return errors.Wrapf(err, "failed to remove loopback link %s", linkPath) + return fmt.Errorf("failed to remove loopback link %s: %w", linkPath, err) } err = os.RemoveAll(lunPath) if err != nil { - return errors.Wrapf(err, "failed to remove loopback lun %s", lunPath) + return fmt.Errorf("failed to remove loopback lun %s: %w", lunPath, err) } loopDevPath := o.overlaybdLoopbackDevicePath(loopDevID) @@ -215,19 +214,19 @@ func (o *snapshotter) unmountAndDetachBlockDevice(ctx context.Context, snID stri err = os.RemoveAll(tpgtPath) if err != nil { - return errors.Wrapf(err, "failed to remove loopback tgpt %s", tpgtPath) + return fmt.Errorf("failed to remove loopback tgpt %s: %w", tpgtPath, err) } err = os.RemoveAll(loopDevPath) if err != nil { - return errors.Wrapf(err, "failed to remove loopback dir %s", loopDevPath) + return fmt.Errorf("failed to remove loopback dir %s: %w", loopDevPath, err) } targetPath := o.overlaybdTargetPath(snID) err = os.RemoveAll(targetPath) if err != nil { - return errors.Wrapf(err, "failed to remove target dir %s", targetPath) + return fmt.Errorf("failed to remove target dir %s: %w", targetPath, err) } log.G(ctx).Infof("destroy overlaybd device success(sn: %s): %s", snID, devName) return nil @@ -265,7 +264,7 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string targetPath := o.overlaybdTargetPath(snID) err := os.MkdirAll(targetPath, 0700) if err != nil { - return errors.Wrapf(err, "failed to create target dir for %s", targetPath) + return fmt.Errorf("failed to create target dir for %s: %w", targetPath, err) } defer func() { @@ -279,14 +278,12 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string }() if err = os.WriteFile(path.Join(targetPath, "control"), ([]byte)(fmt.Sprintf("dev_config=overlaybd/%s", o.overlaybdConfPath(snID))), 0666); err != nil { - return errors.Wrapf(err, "failed to write target dev_config for %s: %s", - targetPath, fmt.Sprintf("dev_config=overlaybd/%s", o.overlaybdConfPath(snID))) + return fmt.Errorf("failed to write target dev_config for %s: dev_config=overlaybd/%s: %w", targetPath, o.overlaybdConfPath(snID), err) } err = os.WriteFile(path.Join(targetPath, "control"), ([]byte)(fmt.Sprintf("max_data_area_mb=%d", obdMaxDataAreaMB)), 0666) if err != nil { - return errors.Wrapf(err, "failed to write target max_data_area_mb for %s: %s", - targetPath, fmt.Sprintf("max_data_area_mb=%d", obdMaxDataAreaMB)) + return fmt.Errorf("failed to write target max_data_area_mb for %s: max_data_area_mb=%d: %w", targetPath, obdMaxDataAreaMB, err) } err = os.WriteFile(path.Join(targetPath, "enable"), ([]byte)("1"), 0666) @@ -294,9 +291,9 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string // read the init-debug.log for readable debugLogPath := o.overlaybdInitDebuglogPath(snID) if data, derr := os.ReadFile(debugLogPath); derr == nil { - return errors.Errorf("failed to enable target for %s, %s", targetPath, data) + return fmt.Errorf("failed to enable target for %s, %s", targetPath, data) } - return errors.Wrapf(err, "failed to enable target for %s", targetPath) + return fmt.Errorf("failed to enable target for %s: %w", targetPath, err) } // fixed by fuweid @@ -304,7 +301,7 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string path.Join(targetPath, "attrib", "cmd_time_out"), ([]byte)(fmt.Sprintf("%v", math.MaxInt32/1000)), 0666) if err != nil { - return errors.Wrapf(err, "failed to update cmd_time_out") + return fmt.Errorf("failed to update cmd_time_out: %w", err) } loopDevID := o.overlaybdLoopbackDeviceID(snID) @@ -312,14 +309,14 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string err = os.MkdirAll(loopDevPath, 0700) if err != nil { - return errors.Wrapf(err, "failed to create loopback dir %s", loopDevPath) + return fmt.Errorf("failed to create loopback dir %s: %w", loopDevPath, err) } tpgtPath := path.Join(loopDevPath, "tpgt_1") lunPath := o.overlaybdLoopbackDeviceLunPath(loopDevID) err = os.MkdirAll(lunPath, 0700) if err != nil { - return errors.Wrapf(err, "failed to create loopback lun dir %s", lunPath) + return fmt.Errorf("failed to create loopback lun dir %s: %w", lunPath, err) } defer func() { @@ -344,13 +341,13 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string nexusPath := path.Join(tpgtPath, "nexus") err = os.WriteFile(nexusPath, ([]byte)(loopDevID), 0666) if err != nil { - return errors.Wrapf(err, "failed to write loopback nexus %s", nexusPath) + return fmt.Errorf("failed to write loopback nexus %s: %w", nexusPath, err) } linkPath := path.Join(lunPath, "dev_"+snID) err = os.Symlink(targetPath, linkPath) if err != nil { - return errors.Wrapf(err, "failed to create loopback link %s", linkPath) + return fmt.Errorf("failed to create loopback link %s: %w", linkPath, err) } defer func() { @@ -365,7 +362,7 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string devAddressPath := path.Join(tpgtPath, "address") bytes, err := os.ReadFile(devAddressPath) if err != nil { - return errors.Wrapf(err, "failed to read loopback address for %s", devAddressPath) + return fmt.Errorf("failed to read loopback address for %s: %w", devAddressPath, err) } deviceNumber := strings.TrimSuffix(string(bytes), "\n") @@ -379,7 +376,7 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string continue } if len(devDirs) == 0 { - lastErr = errors.Errorf("empty device found") + lastErr = fmt.Errorf("empty device found") time.Sleep(10 * time.Millisecond) continue } @@ -389,13 +386,13 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string if err := os.WriteFile(path.Join("/sys/block", dev.Name(), "device", "timeout"), ([]byte)(fmt.Sprintf("%v", math.MaxInt32/1000)), 0666); err != nil { - lastErr = errors.Wrapf(err, "failed to set timeout for %s", device) + lastErr = fmt.Errorf("failed to set timeout for %s: %w", device, err) time.Sleep(10 * time.Millisecond) break // retry } devSavedPath := o.overlaybdBackstoreMarkFile(snID) if err := os.WriteFile(devSavedPath, []byte(device), 0644); err != nil { - return errors.Wrapf(err, "failed to create backstore mark file of snapshot %s", snID) + return fmt.Errorf("failed to create backstore mark file of snapshot %s: %w", snID, err) } log.G(ctx).Debugf("write device name: %s into file: %s", device, devSavedPath) @@ -430,7 +427,7 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string log.G(ctx).Infof("fs type: %s, mkfs options: %v", fstype, args) out, err := exec.CommandContext(ctx, "mkfs", args...).CombinedOutput() if err != nil { - return errors.Wrapf(err, "failed to mkfs for dev %s: %s", device, out) + return fmt.Errorf("failed to mkfs for dev %s: %s: %w", device, out, err) } } @@ -457,7 +454,7 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string log.G(ctx).Infof("fs type: %s, mount options: %s, rw: %s, mountpoint: %s", fstype, mountOpts, writable, mountPoint) if err := unix.Mount(device, mountPoint, fstype, mountFlag, mountOpts); err != nil { - lastErr = errors.Wrapf(err, "failed to mount %s to %s", device, mountPoint) + lastErr = fmt.Errorf("failed to mount %s to %s: %w", device, mountPoint, err) time.Sleep(10 * time.Millisecond) break // retry } @@ -473,7 +470,7 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string log.G(ctx).Infof("fs type: %s, mount options: %v", fstype, args) out, err := exec.CommandContext(ctx, "mount", args...).CombinedOutput() if err != nil { - lastErr = errors.Wrapf(err, "failed to mount for dev %s: %s", device, out) + lastErr = fmt.Errorf("failed to mount for dev %s: %s: %w", device, out, err) time.Sleep(10 * time.Millisecond) break // retry } @@ -489,12 +486,12 @@ func (o *snapshotter) attachAndMountBlockDevice(ctx context.Context, snID string func (o *snapshotter) constructOverlayBDSpec(ctx context.Context, key string, writable bool) error { id, info, _, err := storage.GetInfo(ctx, key) if err != nil { - return errors.Wrapf(err, "failed to get info for snapshot %s", key) + return fmt.Errorf("failed to get info for snapshot %s: %w", key, err) } stype, err := o.identifySnapshotStorageType(ctx, id, info) if err != nil { - return errors.Wrapf(err, "failed to identify storage of snapshot %s", key) + return fmt.Errorf("failed to identify storage of snapshot %s: %w", key, err) } configJSON := sn.OverlayBDBSConfig{ @@ -506,7 +503,7 @@ func (o *snapshotter) constructOverlayBDSpec(ctx context.Context, key string, wr if info.Parent != "" { parentID, _, _, err := storage.GetInfo(ctx, info.Parent) if err != nil { - return errors.Wrapf(err, "failed to get info for parent snapshot %s", info.Parent) + return fmt.Errorf("failed to get info for parent snapshot %s: %w", info.Parent, err) } parentConfJSON, err := o.loadBackingStoreConfig(parentID) @@ -520,12 +517,12 @@ func (o *snapshotter) constructOverlayBDSpec(ctx context.Context, key string, wr switch stype { case storageTypeRemoteBlock: if writable { - return errors.Errorf("remote block device is readonly, not support writable") + return fmt.Errorf("remote block device is readonly, not support writable") } blobSize, err := strconv.Atoi(info.Labels[label.OverlayBDBlobSize]) if err != nil { - return errors.Wrapf(err, "failed to parse value of label %s of snapshot %s", label.OverlayBDBlobSize, key) + return fmt.Errorf("failed to parse value of label %s of snapshot %s: %w", label.OverlayBDBlobSize, key, err) } blobDigest := info.Labels[label.OverlayBDBlobDigest] @@ -533,14 +530,14 @@ func (o *snapshotter) constructOverlayBDSpec(ctx context.Context, key string, wr if !hasRef { criRef, hasCriRef := info.Labels[label.CRIImageRef] if !hasCriRef { - return errors.Errorf("no image-ref label") + return fmt.Errorf("no image-ref label") } ref = criRef } blobPrefixURL, err := o.constructImageBlobURL(ref) if err != nil { - return errors.Wrapf(err, "failed to construct image blob prefix url for snapshot %s", key) + return fmt.Errorf("failed to construct image blob prefix url for snapshot %s: %w", key, err) } configJSON.RepoBlobURL = blobPrefixURL @@ -574,7 +571,7 @@ func (o *snapshotter) constructOverlayBDSpec(ctx context.Context, key string, wr case storageTypeLocalBlock: if writable { - return errors.Errorf("local block device is readonly, not support writable") + return fmt.Errorf("local block device is readonly, not support writable") } ociBlob := o.overlaybdOCILayerPath(id) if _, err := os.Stat(ociBlob); err == nil { @@ -639,7 +636,7 @@ func (o *snapshotter) constructOverlayBDSpec(ctx context.Context, key string, wr log.G(ctx).Debugf("generate config.json for %s:\n %+v", id, configJSON) default: if !writable { - return errors.Errorf("unexpect storage %v of snapshot %v during construct overlaybd spec(writable=%v, parent=%s)", stype, key, writable, info.Parent) + return fmt.Errorf("unexpect storage %v of snapshot %v during construct overlaybd spec(writable=%v, parent=%s)", stype, key, writable, info.Parent) } vsizeGB := 0 if info.Parent == "" { @@ -716,12 +713,12 @@ func (o *snapshotter) loadBackingStoreConfig(snID string) (*sn.OverlayBDBSConfig confPath := o.overlaybdConfPath(snID) data, err := os.ReadFile(confPath) if err != nil { - return nil, errors.Wrapf(err, "failed to read config(path=%s) of snapshot %s", confPath, snID) + return nil, fmt.Errorf("failed to read config(path=%s) of snapshot %s: %w", confPath, snID, err) } var configJSON sn.OverlayBDBSConfig if err := json.Unmarshal(data, &configJSON); err != nil { - return nil, errors.Wrapf(err, "failed to unmarshal data(%s)", string(data)) + return nil, fmt.Errorf("failed to unmarshal data(%s): %w", string(data), err) } return &configJSON, nil @@ -733,7 +730,7 @@ func (o *snapshotter) loadBackingStoreConfig(snID string) (*sn.OverlayBDBSConfig func (o *snapshotter) constructImageBlobURL(ref string) (string, error) { refspec, err := reference.Parse(ref) if err != nil { - return "", errors.Wrapf(err, "invalid repo url %s", ref) + return "", fmt.Errorf("invalid repo url %s: %w", ref, err) } host := refspec.Hostname() @@ -754,12 +751,12 @@ func (o *snapshotter) constructImageBlobURL(ref string) (string, error) { func (o *snapshotter) atomicWriteOverlaybdTargetConfig(snID string, configJSON *sn.OverlayBDBSConfig) error { data, err := json.Marshal(configJSON) if err != nil { - return errors.Wrapf(err, "failed to marshal %+v configJSON into JSON", configJSON) + return fmt.Errorf("failed to marshal %+v configJSON into JSON: %w", configJSON, err) } confPath := o.overlaybdConfPath(snID) if err := continuity.AtomicWriteFile(confPath, data, 0600); err != nil { - return errors.Wrapf(err, "failed to commit the overlaybd config on %s", confPath) + return fmt.Errorf("failed to commit the overlaybd config on %s: %w", confPath, err) } return nil } @@ -818,11 +815,11 @@ func lookup(dir string) error { m, err := mountinfo.GetMounts(mountinfo.SingleEntryFilter(dir)) if err != nil { - return errors.Wrapf(err, "failed to get mount info for %q", dir) + return fmt.Errorf("failed to get mount info for %q: %w", dir, err) } if len(m) == 0 { - return errors.Errorf("failed to find the mount point for %q", dir) + return fmt.Errorf("failed to find the mount point for %q", dir) } return nil } diff --git a/pkg/utils/cmd.go b/pkg/utils/cmd.go index a08965e0..66c3bae1 100644 --- a/pkg/utils/cmd.go +++ b/pkg/utils/cmd.go @@ -28,7 +28,6 @@ import ( sn "github.com/containerd/accelerated-container-image/pkg/types" "github.com/containerd/log" - "github.com/pkg/errors" ) const ( @@ -91,7 +90,7 @@ func Create(ctx context.Context, dir string, opts ...string) error { log.G(ctx).Debugf("%s %s", obdBinCreate, strings.Join(args, " ")) out, err := exec.CommandContext(ctx, obdBinCreate, args...).CombinedOutput() if err != nil { - return errors.Wrapf(err, "failed to overlaybd-create: %s", out) + return fmt.Errorf("failed to overlaybd-create: %s: %w", out, err) } return nil } @@ -105,10 +104,10 @@ func Seal(ctx context.Context, dir, toDir string, opts ...string) error { log.G(ctx).Debugf("%s %s", obdBinCommit, strings.Join(args, " ")) out, err := exec.CommandContext(ctx, obdBinCommit, args...).CombinedOutput() if err != nil { - return errors.Wrapf(err, "failed to seal writable overlaybd: %s", out) + return fmt.Errorf("failed to seal writable overlaybd: %s: %w", out, err) } if err := os.Rename(path.Join(dir, dataFile), path.Join(toDir, sealedFile)); err != nil { - return errors.Wrapf(err, "failed to rename sealed overlaybd file") + return fmt.Errorf("failed to rename sealed overlaybd file: %w", err) } os.RemoveAll(path.Join(dir, idxFile)) return nil @@ -132,7 +131,7 @@ func Commit(ctx context.Context, dir, toDir string, sealed bool, opts ...string) log.G(ctx).Debugf("%s %s", obdBinCommit, strings.Join(args, " ")) out, err := exec.CommandContext(ctx, obdBinCommit, args...).CombinedOutput() if err != nil { - return errors.Wrapf(err, "failed to overlaybd-commit: %s", out) + return fmt.Errorf("failed to overlaybd-commit: %s: %w", out, err) } if sealed { return os.Rename(path.Join(toDir, commitTempFile), path.Join(toDir, commitFile)) @@ -148,7 +147,7 @@ func ApplyOverlaybd(ctx context.Context, dir string, opts ...string) error { log.G(ctx).Debugf("%s %s", obdBinApply, strings.Join(args, " ")) out, err := exec.CommandContext(ctx, obdBinApply, args...).CombinedOutput() if err != nil { - return errors.Wrapf(err, "failed to overlaybd-apply[native]: %s", out) + return fmt.Errorf("failed to overlaybd-apply[native]: %s: %w", out, err) } return nil } @@ -162,7 +161,7 @@ func ApplyTurboOCI(ctx context.Context, dir, gzipMetaFile string, opts ...string log.G(ctx).Debugf("%s %s", obdBinApply, strings.Join(args, " ")) out, err := exec.CommandContext(ctx, obdBinTurboOCIApply, args...).CombinedOutput() if err != nil { - return errors.Wrapf(err, "failed to overlaybd-apply[turboOCI]: %s", out) + return fmt.Errorf("failed to overlaybd-apply[turboOCI]: %s: %w", out, err) } return nil }