potyarkin/frostfs-node
1
0
Fork 0
forked from TrueCloudLab/frostfs-node
Code Pull requests Activity

[#521] *: use stdlib errors package

Browse source 
Signed-off-by: Evgenii Stratonikov <evgeniy@nspcc.ru>
This commit is contained in:
Evgenii Stratonikov 2021-05-18 11:12:51 +03:00 committed by Alex Vanin
parent 43e575cec2
commit 71b87155ef
171 changed files with 825 additions and 674 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
cmd/neofs-cli/modules/container.go
View file

@ -4,6 +4,7 @@ import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"math"
@ -22,7 +23,6 @@ import (
"github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-api-go/pkg/owner"
"github.com/nspcc-dev/neofs-node/pkg/policy"
"github.com/pkg/errors"
"github.com/spf13/cobra"
)
@ -307,7 +307,7 @@ var getContainerInfoCmd = &cobra.Command{
cnr = container.New()
if err := cnr.Unmarshal(data); err != nil {
return errors.Wrap(err, "can't unmarshal container")
return fmt.Errorf("can't unmarshal container: %w", err)
}
} else {
key, err := getKey()

7
cmd/neofs-cli/modules/control.go
View file

@ -7,7 +7,6 @@ import (
"github.com/nspcc-dev/neofs-api-go/util/signature"
"github.com/nspcc-dev/neofs-node/pkg/services/control"
controlSvc "github.com/nspcc-dev/neofs-node/pkg/services/control/server"
"github.com/pkg/errors"
"github.com/spf13/cobra"
)
@ -112,7 +111,7 @@ func setNetmapStatus(cmd *cobra.Command, _ []string) error {
switch netmapStatus {
default:
return errors.Errorf("unsupported status %s", netmapStatus)
return fmt.Errorf("unsupported status %s", netmapStatus)
case netmapStatusOnline:
status = control.NetmapStatus_ONLINE
case netmapStatusOffline:
@ -174,12 +173,12 @@ var dropObjectsCmd = &cobra.Command{
err := a.Parse(dropObjectsList[i])
if err != nil {
return errors.Wrapf(err, "could not parse address #%d", i)
return fmt.Errorf("could not parse address #%d: %w", i, err)
}
binAddr, err := a.Marshal()
if err != nil {
return errors.Wrap(err, "could not marshal the address")
return fmt.Errorf("could not marshal the address: %w", err)
}
binAddrList = append(binAddrList, binAddr)

2
cmd/neofs-cli/modules/storagegroup.go
View file

@ -2,6 +2,7 @@ package cmd
import (
"context"
"errors"
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/client"
@ -10,7 +11,6 @@ import (
"github.com/nspcc-dev/neofs-api-go/pkg/token"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/services/object_manager/storagegroup"
"github.com/pkg/errors"
"github.com/spf13/cobra"
)

4
cmd/neofs-node/attributes.go
View file

@ -1,11 +1,11 @@
package main
import (
"fmt"
"strconv"
"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
"github.com/nspcc-dev/neofs-node/pkg/util/attributes"
"github.com/pkg/errors"
"github.com/spf13/viper"
)
@ -65,7 +65,7 @@ func addWellKnownAttributes(attrs []*netmap.NodeAttribute) []*netmap.NodeAttribu
for key, desc := range mWellKnown {
// check if required attribute is set
if desc.explicit {
fatalOnErr(errors.Errorf("missing explicit value of required node attribute %s", key))
fatalOnErr(fmt.Errorf("missing explicit value of required node attribute %s", key))
}
// set default value of the attribute

2
cmd/neofs-node/config.go
View file

@ -3,6 +3,7 @@ package main
import (
"context"
"crypto/ecdsa"
"errors"
"net"
"os"
"path"
@ -40,7 +41,6 @@ import (
util2 "github.com/nspcc-dev/neofs-node/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"github.com/spf13/viper"
"go.etcd.io/bbolt"
"go.uber.org/atomic"

21
cmd/neofs-node/container.go
View file

@ -4,6 +4,8 @@ import (
"bytes"
"context"
"crypto/ecdsa"
"errors"
"fmt"
"strconv"
apiClient "github.com/nspcc-dev/neofs-api-go/pkg/client"
@ -30,7 +32,6 @@ import (
loadstorage "github.com/nspcc-dev/neofs-node/pkg/services/container/announcement/load/storage"
containerMorph "github.com/nspcc-dev/neofs-node/pkg/services/container/morph"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -230,12 +231,12 @@ func (r *remoteLoadAnnounceProvider) InitRemote(srv loadroute.ServerInfo) (loadc
hostAddr, err := network.HostAddrFromMultiaddr(addr)
if err != nil {
return nil, errors.Wrap(err, "could not convert address to IP format")
return nil, fmt.Errorf("could not convert address to IP format: %w", err)
}
c, err := r.clientCache.Get(hostAddr)
if err != nil {
return nil, errors.Wrap(err, "could not initialize API client")
return nil, fmt.Errorf("could not initialize API client: %w", err)
}
return &remoteLoadAnnounceWriterProvider{
@ -298,7 +299,7 @@ func (l *loadPlacementBuilder) BuildPlacement(epoch uint64, cid *containerSDK.ID
placement, err := nm.GetPlacementVectors(cnrNodes, pivot)
if err != nil {
return nil, errors.Wrap(err, "could not build placement vectors")
return nil, fmt.Errorf("could not build placement vectors: %w", err)
}
return placement, nil
@ -312,12 +313,12 @@ func (l *loadPlacementBuilder) buildPlacement(epoch uint64, cid *containerSDK.ID
nm, err := l.nmSrc.GetNetMapByEpoch(epoch)
if err != nil {
return nil, nil, errors.Wrap(err, "could not get network map")
return nil, nil, fmt.Errorf("could not get network map: %w", err)
}
cnrNodes, err := nm.GetContainerNodes(cnr.PlacementPolicy(), cid.ToV2().GetValue())
if err != nil {
return nil, nil, errors.Wrap(err, "could not build container nodes")
return nil, nil, fmt.Errorf("could not build container nodes: %w", err)
}
return cnrNodes, nm, nil
@ -407,7 +408,7 @@ func (c *usedSpaceService) AnnounceUsedSpace(ctx context.Context, req *container
w, err := c.loadWriterProvider.InitWriter(loadroute.NewRouteContext(ctx, passedRoute))
if err != nil {
return nil, errors.Wrap(err, "could not initialize container's used space writer")
return nil, fmt.Errorf("could not initialize container's used space writer: %w", err)
}
for _, aV2 := range req.GetBody().GetAnnouncements() {
@ -459,19 +460,19 @@ func (c *usedSpaceService) processLoadValue(ctx context.Context, a containerSDK.
route []loadroute.ServerInfo, w loadcontroller.Writer) error {
fromCnr, err := c.loadPlacementBuilder.isNodeFromContainerKey(a.Epoch(), a.ContainerID(), route[0].PublicKey())
if err != nil {
return errors.Wrap(err, "could not verify that the sender belongs to the container")
return fmt.Errorf("could not verify that the sender belongs to the container: %w", err)
} else if !fromCnr {
return errNodeOutsideContainer
}
err = loadroute.CheckRoute(c.routeBuilder, a, route)
if err != nil {
return errors.Wrap(err, "wrong route of container's used space value")
return fmt.Errorf("wrong route of container's used space value: %w", err)
}
err = w.Put(a)
if err != nil {
return errors.Wrap(err, "could not write container's used space value")
return fmt.Errorf("could not write container's used space value: %w", err)
}
return nil

4
cmd/neofs-node/control.go
View file

@ -3,6 +3,7 @@ package main
import (
"context"
"encoding/hex"
"fmt"
"net"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
@ -10,7 +11,6 @@ import (
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/engine"
"github.com/nspcc-dev/neofs-node/pkg/services/control"
controlSvc "github.com/nspcc-dev/neofs-node/pkg/services/control/server"
"github.com/pkg/errors"
"google.golang.org/grpc"
)
@ -34,7 +34,7 @@ func initControlService(c *cfg) {
fatalOnErr(err)
if crypto.UnmarshalPublicKey(key) == nil {
fatalOnErr(errors.Errorf("invalid permitted key for Control service %s", strKeys[i]))
fatalOnErr(fmt.Errorf("invalid permitted key for Control service %s", strKeys[i]))
}
keys = append(keys, key)

8
cmd/neofs-node/netmap.go
View file

@ -2,6 +2,7 @@ package main
import (
"bytes"
"fmt"
netmapSDK "github.com/nspcc-dev/neofs-api-go/pkg/netmap"
netmapV2 "github.com/nspcc-dev/neofs-api-go/v2/netmap"
@ -13,7 +14,6 @@ import (
netmapTransportGRPC "github.com/nspcc-dev/neofs-node/pkg/network/transport/netmap/grpc"
"github.com/nspcc-dev/neofs-node/pkg/services/control"
netmapService "github.com/nspcc-dev/neofs-node/pkg/services/netmap"
"github.com/pkg/errors"
"go.uber.org/atomic"
"go.uber.org/zap"
)
@ -111,7 +111,7 @@ func bootstrapNode(c *cfg) {
initState(c)
err := c.cfgNetmap.wrapper.AddPeer(c.toOnlineLocalNodeInfo())
fatalOnErr(errors.Wrap(err, "bootstrap error"))
fatalOnErr(fmt.Errorf("bootstrap error: %w", err))
}
func addNetmapNotificationHandler(c *cfg, sTyp string, h event.Handler) {
@ -136,10 +136,10 @@ func setNetmapNotificationParser(c *cfg, sTyp string, p event.Parser) {
func initState(c *cfg) {
epoch, err := c.cfgNetmap.wrapper.Epoch()
fatalOnErr(errors.Wrap(err, "could not initialize current epoch number"))
fatalOnErr(fmt.Errorf("could not initialize current epoch number: %w", err))
ni, err := c.netmapLocalNodeState(epoch)
fatalOnErr(errors.Wrap(err, "could not init network state"))
fatalOnErr(fmt.Errorf("could not init network state: %w", err))
c.handleNodeInfoStatus(ni)

6
cmd/neofs-node/object.go
View file

@ -3,6 +3,7 @@ package main
import (
"context"
"crypto/sha256"
"fmt"
eaclSDK "github.com/nspcc-dev/neofs-api-go/pkg/acl/eacl"
"github.com/nspcc-dev/neofs-api-go/pkg/client"
@ -40,7 +41,6 @@ import (
"github.com/nspcc-dev/neofs-node/pkg/services/reputation"
truststorage "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/storage"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -131,7 +131,7 @@ type innerRingFetcher struct {
func (n *innerRingFetcher) InnerRingKeys() ([][]byte, error) {
keys, err := n.sidechain.NeoFSAlphabetList()
if err != nil {
return nil, errors.Wrap(err, "can't get inner ring keys")
return nil, fmt.Errorf("can't get inner ring keys: %w", err)
}
result := make([][]byte, 0, len(keys))
@ -383,7 +383,7 @@ func (s *morphEACLStorage) GetEACL(cid *container.ID) (*eaclSDK.Table, error) {
},
signature.SignWithRFC6979(),
); err != nil {
return nil, errors.Wrap(err, "incorrect signature")
return nil, fmt.Errorf("incorrect signature: %w", err)
}
return table, nil

12
cmd/neofs-node/reputation.go
View file

@ -2,6 +2,7 @@ package main
import (
"context"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/encoding/fixedn"
v2reputation "github.com/nspcc-dev/neofs-api-go/v2/reputation"
@ -33,7 +34,6 @@ import (
truststorage "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/storage"
reputationrpc "github.com/nspcc-dev/neofs-node/pkg/services/reputation/rpc"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -272,13 +272,13 @@ func (s *reputationServer) AnnounceLocalTrust(ctx context.Context, req *v2reputa
w, err := s.localRouter.InitWriter(reputationrouter.NewRouteContext(eCtx, passedRoute))
if err != nil {
return nil, errors.Wrap(err, "could not initialize local trust writer")
return nil, fmt.Errorf("could not initialize local trust writer: %w", err)
}
for _, trust := range body.GetTrusts() {
err = s.processLocalTrust(body.GetEpoch(), apiToLocalTrust(trust, passedRoute[0].PublicKey()), passedRoute, w)
if err != nil {
return nil, errors.Wrap(err, "could not write one of local trusts")
return nil, fmt.Errorf("could not write one of local trusts: %w", err)
}
}
@ -298,7 +298,7 @@ func (s *reputationServer) AnnounceIntermediateResult(ctx context.Context, req *
w, err := s.intermediateRouter.InitWriter(reputationrouter.NewRouteContext(eiCtx, passedRoute))
if err != nil {
return nil, errors.Wrap(err, "could not initialize intermediate trust writer")
return nil, fmt.Errorf("could not initialize intermediate trust writer: %w", err)
}
v2Trust := body.GetTrust()
@ -307,7 +307,7 @@ func (s *reputationServer) AnnounceIntermediateResult(ctx context.Context, req *
err = w.Write(trust)
if err != nil {
return nil, errors.Wrap(err, "could not write intermediate trust")
return nil, fmt.Errorf("could not write intermediate trust: %w", err)
}
resp := new(v2reputation.AnnounceIntermediateResultResponse)
@ -320,7 +320,7 @@ func (s *reputationServer) processLocalTrust(epoch uint64, t reputation.Trust,
passedRoute []reputationcommon.ServerInfo, w reputationcommon.Writer) error {
err := reputationrouter.CheckRoute(s.routeBuilder, epoch, t, passedRoute)
if err != nil {
return errors.Wrap(err, "wrong route of reputation trust value")
return fmt.Errorf("wrong route of reputation trust value: %w", err)
}
return w.Write(t)

7
cmd/neofs-node/reputation/common/remote.go
View file

@ -1,12 +1,13 @@
package common
import (
"fmt"
apiClient "github.com/nspcc-dev/neofs-api-go/pkg/client"
"github.com/nspcc-dev/neofs-node/pkg/network"
reputationcommon "github.com/nspcc-dev/neofs-node/pkg/services/reputation/common"
reputationrouter "github.com/nspcc-dev/neofs-node/pkg/services/reputation/common/router"
trustcontroller "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/controller"
"github.com/pkg/errors"
)
type clientCache interface {
@ -78,12 +79,12 @@ func (rtp *remoteTrustProvider) InitRemote(srv reputationcommon.ServerInfo) (rep
hostAddr, err := network.HostAddrFromMultiaddr(addr)
if err != nil {
return nil, errors.Wrap(err, "could not convert address to IP format")
return nil, fmt.Errorf("could not convert address to IP format: %w", err)
}
c, err := rtp.clientCache.Get(hostAddr)
if err != nil {
return nil, errors.Wrap(err, "could not initialize API client")
return nil, fmt.Errorf("could not initialize API client: %w", err)
}
return rtp.remoteProvider.WithClient(c), nil

2
cmd/neofs-node/reputation/local/storage.go
View file

@ -2,6 +2,7 @@ package local
import (
"bytes"
"errors"
netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
"github.com/nspcc-dev/neofs-node/pkg/services/reputation"
@ -9,7 +10,6 @@ import (
trustcontroller "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/controller"
truststorage "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/storage"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/pkg/errors"
)
type TrustStorage struct {

1
go.mod
View file

@ -19,7 +19,6 @@ require (
github.com/nspcc-dev/tzhash v1.4.0
github.com/panjf2000/ants/v2 v2.3.0
github.com/paulmach/orb v0.2.1
github.com/pkg/errors v0.9.1
github.com/prometheus/client_golang v1.6.0
github.com/spf13/cobra v1.0.0
github.com/spf13/pflag v1.0.5 // indirect

10
pkg/core/container/fmt.go
View file

@ -1,10 +1,12 @@
package container
import (
"errors"
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/nspcc-dev/neofs-api-go/pkg/owner"
"github.com/pkg/errors"
)
var errNilPolicy = errors.New("placement policy is nil")
@ -19,15 +21,15 @@ func CheckFormat(c *container.Container) error {
}
if err := pkg.IsSupportedVersion(c.Version()); err != nil {
return errors.Wrap(err, "incorrect version")
return fmt.Errorf("incorrect version: %w", err)
}
if ln := len(c.OwnerID().ToV2().GetValue()); ln != owner.NEO3WalletSize {
return errors.Errorf("incorrect owner identifier: expected length %d != %d", owner.NEO3WalletSize, ln)
return fmt.Errorf("incorrect owner identifier: expected length %d != %d", owner.NEO3WalletSize, ln)
}
if _, err := c.NonceUUID(); err != nil {
return errors.Wrap(err, "incorrect nonce")
return fmt.Errorf("incorrect nonce: %w", err)
}
return nil

2
pkg/core/object/errors.go
View file

@ -1,6 +1,6 @@
package object
import "github.com/pkg/errors"
import "errors"
// ErrNotFound is a basic "not found" error returned by
// object read functions.

23
pkg/core/object/fmt.go
View file

@ -2,6 +2,8 @@ package object
import (
"bytes"
"errors"
"fmt"
"strconv"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
@ -10,7 +12,6 @@ import (
objectV2 "github.com/nspcc-dev/neofs-api-go/v2/object"
crypto "github.com/nspcc-dev/neofs-crypto"
"github.com/nspcc-dev/neofs-node/pkg/core/netmap"
"github.com/pkg/errors"
)
// FormatValidator represents object format validator.
@ -75,16 +76,16 @@ func (v *FormatValidator) Validate(obj *Object) error {
for ; obj != nil; obj = obj.GetParent() {
if err := v.validateSignatureKey(obj); err != nil {
return errors.Wrapf(err, "(%T) could not validate signature key", v)
return fmt.Errorf("(%T) could not validate signature key: %w", v, err)
}
// TODO: combine small checks
if err := v.checkExpiration(obj); err != nil {
return errors.Wrapf(err, "object did not pass expiration check")
return fmt.Errorf("object did not pass expiration ch: %weck", err)
}
if err := object.CheckHeaderVerificationFields(obj.SDK()); err != nil {
return errors.Wrapf(err, "(%T) could not validate header fields", v)
return fmt.Errorf("(%T) could not validate header fields: %w", v, err)
}
}
@ -116,7 +117,7 @@ func (v *FormatValidator) checkOwnerKey(id *owner.ID, key []byte) error {
// FIXME: implement Equal method
if s1, s2 := id.String(), id2.String(); s1 != s2 {
return errors.Errorf("(%T) different owner identifiers %s/%s", v, s1, s2)
return fmt.Errorf("(%T) different owner identifiers %s/%s", v, s1, s2)
}
return nil
@ -127,13 +128,13 @@ func (v *FormatValidator) ValidateContent(o *Object) error {
switch o.Type() {
case object.TypeTombstone:
if len(o.Payload()) == 0 {
return errors.Errorf("(%T) empty payload in tombstone", v)
return fmt.Errorf("(%T) empty payload in tombstone", v)
}
tombstone := object.NewTombstone()
if err := tombstone.Unmarshal(o.Payload()); err != nil {
return errors.Wrapf(err, "(%T) could not unmarshal tombstone content", v)
return fmt.Errorf("(%T) could not unmarshal tombstone content: %w", v, err)
}
// check if tombstone has the same expiration in body and header
@ -153,7 +154,7 @@ func (v *FormatValidator) ValidateContent(o *Object) error {
for _, id := range idList {
if id == nil {
return errors.Errorf("(%T) empty member in tombstone", v)
return fmt.Errorf("(%T) empty member in tombstone", v)
}
a := object.NewAddress()
@ -168,18 +169,18 @@ func (v *FormatValidator) ValidateContent(o *Object) error {
}
case object.TypeStorageGroup:
if len(o.Payload()) == 0 {
return errors.Errorf("(%T) empty payload in SG", v)
return fmt.Errorf("(%T) empty payload in SG", v)
}
sg := storagegroup.New()
if err := sg.Unmarshal(o.Payload()); err != nil {
return errors.Wrapf(err, "(%T) could not unmarshal SG content", v)
return fmt.Errorf("(%T) could not unmarshal SG content: %w", v, err)
}
for _, id := range sg.Members() {
if id == nil {
return errors.Errorf("(%T) empty member in SG", v)
return fmt.Errorf("(%T) empty member in SG", v)
}
}
default:

2
pkg/core/object/fmt_test.go
View file

@ -4,6 +4,7 @@ import (
"crypto/ecdsa"
"crypto/rand"
"crypto/sha256"
"errors"
"strconv"
"testing"
@ -15,7 +16,6 @@ import (
objectV2 "github.com/nspcc-dev/neofs-api-go/v2/object"
crypto "github.com/nspcc-dev/neofs-crypto"
"github.com/nspcc-dev/neofs-node/pkg/util/test"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
)

8
pkg/innerring/indexer.go
View file

@ -2,12 +2,12 @@ package innerring
import (
"crypto/ecdsa"
"fmt"
"sync"
"time"
"github.com/nspcc-dev/neofs-node/pkg/innerring/invoke"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
type (
@ -72,7 +72,7 @@ func (s *innerRingIndexer) update() (ind indexes, err error) {
func (s *innerRingIndexer) InnerRingIndex() (int32, error) {
ind, err := s.update()
if err != nil {
return 0, errors.Wrap(err, "can't update index state")
return 0, fmt.Errorf("can't update index state: %w", err)
}
return ind.innerRingIndex, nil
@ -81,7 +81,7 @@ func (s *innerRingIndexer) InnerRingIndex() (int32, error) {
func (s *innerRingIndexer) InnerRingSize() (int32, error) {
ind, err := s.update()
if err != nil {
return 0, errors.Wrap(err, "can't update index state")
return 0, fmt.Errorf("can't update index state: %w", err)
}
return ind.innerRingSize, nil
@ -90,7 +90,7 @@ func (s *innerRingIndexer) InnerRingSize() (int32, error) {
func (s *innerRingIndexer) AlphabetIndex() (int32, error) {
ind, err := s.update()
if err != nil {
return 0, errors.Wrap(err, "can't update index state")
return 0, fmt.Errorf("can't update index state: %w", err)
}
return ind.alphabetIndex, nil

39
pkg/innerring/innerring.go
View file

@ -3,6 +3,8 @@ package innerring
import (
"context"
"crypto/ecdsa"
"errors"
"fmt"
"io"
"github.com/nspcc-dev/neo-go/pkg/core/block"
@ -31,7 +33,6 @@ import (
util2 "github.com/nspcc-dev/neofs-node/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/util/precision"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"github.com/spf13/viper"
"go.uber.org/atomic"
"go.uber.org/zap"
@ -179,9 +180,9 @@ func (s *Server) Start(ctx context.Context, intError chan<- error) error {
case <-ctx.Done():
return
case err := <-morphErr:
intError <- errors.Wrap(err, "sidechain")
intError <- fmt.Errorf("sidechain: %w", err)
case err := <-mainnnetErr:
intError <- errors.Wrap(err, "mainnet")
intError <- fmt.Errorf("mainnet: %w", err)
}
}()
@ -197,7 +198,7 @@ func (s *Server) Start(ctx context.Context, intError chan<- error) error {
go s.mainnetListener.ListenWithError(ctx, mainnnetErr) // listen for neo:mainnet events
if err := s.startBlockTimers(); err != nil {
return errors.Wrap(err, "could not start block timers")
return fmt.Errorf("could not start block timers: %w", err)
}
s.startWorkers(ctx)
@ -249,7 +250,7 @@ func New(ctx context.Context, log *zap.Logger, cfg *viper.Viper) (*Server, error
// prepare inner ring node private key
server.key, err = crypto.LoadPrivateKey(cfg.GetString("key"))
if err != nil {
return nil, errors.Wrap(err, "ir: can't create private key")
return nil, fmt.Errorf("ir: can't create private key: %w", err)
}
// get all script hashes of contracts
@ -261,7 +262,7 @@ func New(ctx context.Context, log *zap.Logger, cfg *viper.Viper) (*Server, error
// parse default validators
server.predefinedValidators, err = parsePredefinedValidators(cfg)
if err != nil {
return nil, errors.Wrap(err, "ir: can't parse predefined validators list")
return nil, fmt.Errorf("ir: can't parse predefined validators list: %w", err)
}
morphChain := &chainParams{
@ -733,42 +734,42 @@ func parseContracts(cfg *viper.Viper) (*contracts, error) {
result.netmap, err = util.Uint160DecodeStringLE(netmapContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read netmap script-hash")
return nil, fmt.Errorf("ir: can't read netmap script-hash: %w", err)
}
result.neofs, err = util.Uint160DecodeStringLE(neofsContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read neofs script-hash")
return nil, fmt.Errorf("ir: can't read neofs script-hash: %w", err)
}
result.balance, err = util.Uint160DecodeStringLE(balanceContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read balance script-hash")
return nil, fmt.Errorf("ir: can't read balance script-hash: %w", err)
}
result.container, err = util.Uint160DecodeStringLE(containerContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read container script-hash")
return nil, fmt.Errorf("ir: can't read container script-hash: %w", err)
}
result.audit, err = util.Uint160DecodeStringLE(auditContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read audit script-hash")
return nil, fmt.Errorf("ir: can't read audit script-hash: %w", err)
}
result.proxy, err = util.Uint160DecodeStringLE(proxyContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read proxy script-hash")
return nil, fmt.Errorf("ir: can't read proxy script-hash: %w", err)
}
result.processing, err = util.Uint160DecodeStringLE(processingContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read processing script-hash")
return nil, fmt.Errorf("ir: can't read processing script-hash: %w", err)
}
result.reputation, err = util.Uint160DecodeStringLE(reputationContractStr)
if err != nil {
return nil, errors.Wrap(err, "ir: can't read reputation script-hash")
return nil, fmt.Errorf("ir: can't read reputation script-hash: %w", err)
}
result.alphabet, err = parseAlphabetContracts(cfg)
@ -793,7 +794,7 @@ func ParsePublicKeysFromStrings(pubKeys []string) (keys.PublicKeys, error) {
for i := range pubKeys {
key, err := keys.NewPublicKeyFromString(pubKeys[i])
if err != nil {
return nil, errors.Wrap(err, "can't decode public key")
return nil, fmt.Errorf("can't decode public key: %w", err)
}
publicKeys = append(publicKeys, key)
@ -807,7 +808,7 @@ func parseAlphabetContracts(cfg *viper.Viper) (alphabetContracts, error) {
alpha := newAlphabetContracts()
if num > lastLetterNum {
return nil, errors.Errorf("amount of alphabet contracts overflows glagolitsa %d > %d", num, lastLetterNum)
return nil, fmt.Errorf("amount of alphabet contracts overflows glagolitsa %d > %d", num, lastLetterNum)
}
for letter := az; letter < num; letter++ {
@ -815,7 +816,7 @@ func parseAlphabetContracts(cfg *viper.Viper) (alphabetContracts, error) {
contractHash, err := util.Uint160DecodeStringLE(contractStr)
if err != nil {
return nil, errors.Wrapf(err, "invalid alphabet %s contract: %s", letter.configString(), contractStr)
return nil, fmt.Errorf("invalid alphabet %s contract: %s: %w", letter.configString(), contractStr, err)
}
alpha.set(letter, contractHash)
@ -828,13 +829,13 @@ func (s *Server) initConfigFromBlockchain() error {
// get current epoch
epoch, err := invoke.Epoch(s.morphClient, s.contracts.netmap)
if err != nil {
return errors.Wrap(err, "can't read epoch")
return fmt.Errorf("can't read epoch: %w", err)
}
// get balance precision
balancePrecision, err := invoke.BalancePrecision(s.morphClient, s.contracts.balance)
if err != nil {
return errors.Wrap(err, "can't read balance contract precision")
return fmt.Errorf("can't read balance contract precision: %w", err)
}
s.epochCounter.Store(uint64(epoch))

9
pkg/innerring/invoke/enhanced.go
View file

@ -15,7 +15,6 @@ import (
wrapNetmap "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap/wrapper"
"github.com/nspcc-dev/neofs-node/pkg/morph/client/reputation"
reputationWrapper "github.com/nspcc-dev/neofs-node/pkg/morph/client/reputation/wrapper"
"github.com/pkg/errors"
)
// NewContainerClient creates wrapper to access data from container contract.
@ -62,12 +61,12 @@ func NewAuditClient(cli *client.Client, contract util.Uint160, fee SideFeeProvid
func NewBalanceClient(cli *client.Client, contract util.Uint160, fee SideFeeProvider) (*balanceWrapper.Wrapper, error) {
staticClient, err := client.NewStatic(cli, contract, fee.SideChainFee())
if err != nil {
return nil, errors.Wrap(err, "could not create static client of Balance contract")
return nil, fmt.Errorf("could not create static client of Balance contract: %w", err)
}
enhancedBalanceClient, err := balance.New(staticClient)
if err != nil {
return nil, errors.Wrap(err, "could not create Balance contract client")
return nil, fmt.Errorf("could not create Balance contract client: %w", err)
}
return balanceWrapper.New(enhancedBalanceClient)
@ -77,12 +76,12 @@ func NewBalanceClient(cli *client.Client, contract util.Uint160, fee SideFeeProv
func NewReputationClient(cli *client.Client, contract util.Uint160, fee SideFeeProvider) (*reputationWrapper.ClientWrapper, error) {
staticClient, err := client.NewStatic(cli, contract, fee.SideChainFee())
if err != nil {
return nil, errors.Wrap(err, "could not create static client of reputation contract")
return nil, fmt.Errorf("could not create static client of reputation contract: %w", err)
}
enhancedRepurationClient, err := reputation.New(staticClient)
if err != nil {
return nil, errors.Wrap(err, "could not create reputation contract client")
return nil, fmt.Errorf("could not create reputation contract client: %w", err)
}
return reputationWrapper.WrapClient(enhancedRepurationClient), nil

6
pkg/innerring/invoke/netmap.go
View file

@ -1,12 +1,14 @@
package invoke
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
type (
@ -157,7 +159,7 @@ func NetmapSnapshot(cli *client.Client, con util.Uint160) (*netmap.Netmap, error
for i := range rawNodeInfos {
nodeInfo, err := peerInfoFromStackItem(rawNodeInfos[i])
if err != nil {
return nil, errors.Wrap(err, "invalid RPC response")
return nil, fmt.Errorf("invalid RPC response: %w", err)
}
result = append(result, *nodeInfo)

6
pkg/innerring/processors/alphabet/processor.go
View file

@ -1,11 +1,13 @@
package alphabet
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -65,7 +67,7 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/neofs: can't create worker pool")
return nil, fmt.Errorf("ir/neofs: can't create worker pool: %w", err)
}
return &Processor{

5
pkg/innerring/processors/audit/processor.go
View file

@ -3,6 +3,8 @@ package audit
import (
"context"
"crypto/ecdsa"
"errors"
"fmt"
"time"
"github.com/nspcc-dev/neo-go/pkg/util"
@ -15,7 +17,6 @@ import (
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
"github.com/nspcc-dev/neofs-node/pkg/services/audit"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -110,7 +111,7 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(ProcessorPoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/audit: can't create worker pool")
return nil, fmt.Errorf("ir/audit: can't create worker pool: %w", err)
}
// creating enhanced client for getting network map

5
pkg/innerring/processors/audit/scheduler.go
View file

@ -1,11 +1,12 @@
package audit
import (
"errors"
"fmt"
"sort"
"strings"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -14,7 +15,7 @@ var ErrInvalidIRNode = errors.New("node is not in the inner ring list")
func (ap *Processor) selectContainersToAudit(epoch uint64) ([]*container.ID, error) {
containers, err := ap.containerClient.List(nil)
if err != nil {
return nil, errors.Wrap(err, "can't get list of containers to start audit")
return nil, fmt.Errorf("can't get list of containers to start audit: %w", err)
}
// consider getting extra information about container complexity from

6
pkg/innerring/processors/balance/processor.go
View file

@ -1,13 +1,15 @@
package balance
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/innerring/config"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
balanceEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/balance"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -70,7 +72,7 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/balance: can't create worker pool")
return nil, fmt.Errorf("ir/balance: can't create worker pool: %w", err)
}
return &Processor{

6
pkg/innerring/processors/container/processor.go
View file

@ -1,13 +1,15 @@
package container
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/innerring/config"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
containerEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/container"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -60,7 +62,7 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/container: can't create worker pool")
return nil, fmt.Errorf("ir/container: can't create worker pool: %w", err)
}
return &Processor{

5
pkg/innerring/processors/governance/list.go
View file

@ -1,10 +1,11 @@
package governance
import (
"errors"
"fmt"
"sort"
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/pkg/errors"
)
var (
@ -25,7 +26,7 @@ func newAlphabetList(sidechain, mainnet keys.PublicKeys) (keys.PublicKeys, error
}
if len(mainnet) < ln {
return nil, errors.Wrapf(errNotEnoughKeys, "expecting %d keys", ln)
return nil, fmt.Errorf("%w: expecting %d keys", errNotEnoughKeys, ln)
}
hmap := make(map[string]bool, ln)

6
pkg/innerring/processors/governance/processor.go
View file

@ -1,13 +1,15 @@
package governance
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/innerring/config"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -89,7 +91,7 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(ProcessorPoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/governance: can't create worker pool")
return nil, fmt.Errorf("ir/governance: can't create worker pool: %w", err)
}
return &Processor{

7
pkg/innerring/processors/neofs/processor.go
View file

@ -1,6 +1,8 @@
package neofs
import (
"errors"
"fmt"
"sync"
lru "github.com/hashicorp/golang-lru"
@ -11,7 +13,6 @@ import (
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
neofsEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/neofs"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -97,12 +98,12 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/neofs: can't create worker pool")
return nil, fmt.Errorf("ir/neofs: can't create worker pool: %w", err)
}
lruCache, err := lru.New(p.MintEmitCacheSize)
if err != nil {
return nil, errors.Wrap(err, "ir/neofs: can't create LRU cache for gas emission")
return nil, fmt.Errorf("ir/neofs: can't create LRU cache for gas emission: %w", err)
}
return &Processor{

8
pkg/innerring/processors/netmap/nodevalidation/locode/calls.go
View file

@ -1,9 +1,11 @@
package locode
import (
"errors"
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
"github.com/nspcc-dev/neofs-node/pkg/util/locode"
"github.com/pkg/errors"
)
var errMissingRequiredAttr = errors.New("missing required attribute in DB record")
@ -36,12 +38,12 @@ func (v *Validator) VerifyAndUpdate(n *netmap.NodeInfo) error {
lc, err := locode.FromString(attrLocode.Value())
if err != nil {
return errors.Wrap(err, "invalid locode value")
return fmt.Errorf("invalid locode value: %w", err)
}
record, err := v.db.Get(lc)
if err != nil {
return errors.Wrap(err, "could not get locode record from DB")
return fmt.Errorf("could not get locode record from DB: %w", err)
}
for attrKey, attrDesc := range v.mAttr {

6
pkg/innerring/processors/netmap/processor.go
View file

@ -1,6 +1,9 @@
package netmap
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
"github.com/nspcc-dev/neofs-node/pkg/innerring/config"
@ -9,7 +12,6 @@ import (
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
netmapEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/netmap"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -131,7 +133,7 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/netmap: can't create worker pool")
return nil, fmt.Errorf("ir/netmap: can't create worker pool: %w", err)
}
return &Processor{

6
pkg/innerring/processors/reputation/processor.go
View file

@ -1,12 +1,14 @@
package reputation
import (
"errors"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/util"
reputationWrapper "github.com/nspcc-dev/neofs-node/pkg/morph/client/reputation/wrapper"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
reputationEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/reputation"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -69,7 +71,7 @@ func New(p *Params) (*Processor, error) {
pool, err := ants.NewPool(p.PoolSize, ants.WithNonblocking(true))
if err != nil {
return nil, errors.Wrap(err, "ir/reputation: can't create worker pool")
return nil, fmt.Errorf("ir/reputation: can't create worker pool: %w", err)
}
return &Processor{

3
pkg/innerring/processors/settlement/processor.go
View file

@ -8,7 +8,6 @@ import (
nodeutil "github.com/nspcc-dev/neofs-node/pkg/util"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/panjf2000/ants/v2"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -61,7 +60,7 @@ func New(prm Prm, opts ...Option) *Processor {
pool, err := ants.NewPool(o.poolSize, ants.WithNonblocking(true))
if err != nil {
panic(errors.Wrap(err, "could not create worker pool"))
panic(fmt.Errorf("could not create worker pool: %w", err))
}
o.log.Debug("worker pool for settlement processor successfully initialized",

14
pkg/innerring/settlement.go
View file

@ -3,6 +3,7 @@ package innerring
import (
"context"
"encoding/hex"
"fmt"
"math/big"
auditAPI "github.com/nspcc-dev/neofs-api-go/pkg/audit"
@ -22,7 +23,6 @@ import (
"github.com/nspcc-dev/neofs-node/pkg/morph/client/container/wrapper"
containerClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/container/wrapper"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -91,7 +91,7 @@ func (c *containerWrapper) Owner() *owner.ID {
func (s settlementDeps) AuditResultsForEpoch(epoch uint64) ([]*auditAPI.Result, error) {
idList, err := s.auditClient.ListAuditResultIDByEpoch(epoch)
if err != nil {
return nil, errors.Wrap(err, "could not list audit results in sidechain")
return nil, fmt.Errorf("could not list audit results in sidechain: %w", err)
}
res := make([]*auditAPI.Result, 0, len(idList))
@ -99,7 +99,7 @@ func (s settlementDeps) AuditResultsForEpoch(epoch uint64) ([]*auditAPI.Result,
for i := range idList {
r, err := s.auditClient.GetAuditResult(idList[i])
if err != nil {
return nil, errors.Wrap(err, "could not get audit result")
return nil, fmt.Errorf("could not get audit result: %w", err)
}
res = append(res, r)
@ -111,7 +111,7 @@ func (s settlementDeps) AuditResultsForEpoch(epoch uint64) ([]*auditAPI.Result,
func (s settlementDeps) ContainerInfo(cid *containerAPI.ID) (common.ContainerInfo, error) {
cnr, err := s.cnrSrc.Get(cid)
if err != nil {
return nil, errors.Wrap(err, "could not get container from storage")
return nil, fmt.Errorf("could not get container from storage: %w", err)
}
return (*containerWrapper)(cnr), nil
@ -130,12 +130,12 @@ func (s settlementDeps) buildContainer(e uint64, cid *containerAPI.ID) (netmapAP
}
if err != nil {
return nil, nil, errors.Wrap(err, "could not get network map from storage")
return nil, nil, fmt.Errorf("could not get network map from storage: %w", err)
}
cnr, err := s.cnrSrc.Get(cid)
if err != nil {
return nil, nil, errors.Wrap(err, "could not get container from sidechain")
return nil, nil, fmt.Errorf("could not get container from sidechain: %w", err)
}
cn, err := nm.GetContainerNodes(
@ -143,7 +143,7 @@ func (s settlementDeps) buildContainer(e uint64, cid *containerAPI.ID) (netmapAP
cid.ToV2().GetValue(), // may be replace pivot calculation to neofs-api-go
)
if err != nil {
return nil, nil, errors.Wrap(err, "could not calculate container nodes")
return nil, nil, fmt.Errorf("could not calculate container nodes: %w", err)
}
return cn, nm, nil

2
pkg/local_object_storage/blobovnicza/blobovnicza_test.go
View file

@ -2,6 +2,7 @@ package blobovnicza
import (
"crypto/sha256"
"errors"
"math/rand"
"os"
"testing"
@ -10,7 +11,6 @@ import (
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/util/logger/test"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
)

10
pkg/local_object_storage/blobovnicza/control.go
View file

@ -1,10 +1,11 @@
package blobovnicza
import (
"errors"
"fmt"
"os"
"path"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
"go.uber.org/zap"
)
@ -58,8 +59,11 @@ func (b *Blobovnicza) Init() error {
return true, b.syncFullnessCounter()
}
return false, errors.Wrapf(err,
"(%T) could not create bucket for bounds [%d:%d]", b, lower, upper)
if err != nil {
return false, fmt.Errorf("(%T) could not create bucket for bounds [%d:%d]: %w",
b, lower, upper, err)
}
return false, nil
})
})
}

5
pkg/local_object_storage/blobovnicza/get_range.go
View file

@ -1,9 +1,10 @@
package blobovnicza
import (
"fmt"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/pkg/errors"
)
// GetRangePrm groups the parameters of GetRange operation.
@ -59,7 +60,7 @@ func (b *Blobovnicza) GetRange(prm *GetRangePrm) (*GetRangeRes, error) {
payload := res.obj
if from > to {
return nil, errors.Errorf("invalid range [%d:%d]", from, to)
return nil, fmt.Errorf("invalid range [%d:%d]", from, to)
} else if uint64(len(payload)) < to {
return nil, object.ErrRangeOutOfBounds
}

5
pkg/local_object_storage/blobovnicza/iterate.go
View file

@ -1,7 +1,8 @@
package blobovnicza
import (
"github.com/pkg/errors"
"fmt"
"go.etcd.io/bbolt"
)
@ -12,7 +13,7 @@ func (b *Blobovnicza) iterateBuckets(tx *bbolt.Tx, f func(uint64, uint64, *bbolt
// expected to happen:
// - before initialization step (incorrect usage by design)
// - if DB is corrupted (in future this case should be handled)
return false, errors.Errorf("(%T) could not get bucket %s", b, stringifyBounds(lower, upper))
return false, fmt.Errorf("(%T) could not get bucket %s", b, stringifyBounds(lower, upper))
}
return f(lower, upper, buck)

8
pkg/local_object_storage/blobovnicza/put.go
View file

@ -1,8 +1,10 @@
package blobovnicza
import (
"errors"
"fmt"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
)
@ -65,12 +67,12 @@ func (b *Blobovnicza) Put(prm *PutPrm) (*PutRes, error) {
// expected to happen:
// - before initialization step (incorrect usage by design)
// - if DB is corrupted (in future this case should be handled)
return errors.Errorf("(%T) bucket for size %d not created", b, sz)
return fmt.Errorf("(%T) bucket for size %d not created", b, sz)
}
// save the object in bucket
if err := buck.Put(addressKey(addr), prm.objData); err != nil {
return errors.Wrapf(err, "(%T) could not save object in bucket", b)
return fmt.Errorf("(%T) could not save object in bucket: %w", b, err)
}
// increase fullness counter

11
pkg/local_object_storage/blobovnicza/sizes.go
View file

@ -5,7 +5,6 @@ import (
"fmt"
"code.cloudfoundry.org/bytefmt"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
)
@ -54,13 +53,13 @@ func (b *Blobovnicza) full() bool {
}
func (b *Blobovnicza) syncFullnessCounter() error {
return errors.Wrap(b.boltDB.View(func(tx *bbolt.Tx) error {
err := b.boltDB.View(func(tx *bbolt.Tx) error {
sz := uint64(0)
if err := b.iterateBucketKeys(func(lower, upper uint64, key []byte) (bool, error) {
buck := tx.Bucket(key)
if buck == nil {
return false, errors.Errorf("bucket not found %s", stringifyBounds(lower, upper))
return false, fmt.Errorf("bucket not found %s", stringifyBounds(lower, upper))
}
sz += uint64(buck.Stats().KeyN) * (upper - lower)
@ -73,5 +72,9 @@ func (b *Blobovnicza) syncFullnessCounter() error {
b.filled.Store(sz)
return nil
}), "(%T) could not sync fullness counter")
})
if err != nil {
return fmt.Errorf("could not sync fullness counter: %w", err)
}
return nil
}

18
pkg/local_object_storage/blobstor/blobovnicza.go
View file

@ -1,6 +1,7 @@
package blobstor
import (
"errors"
"fmt"
"path"
"strconv"
@ -11,7 +12,6 @@ import (
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobovnicza"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -101,7 +101,7 @@ func newBlobovniczaTree(c *cfg) (blz *blobovniczas) {
})
if err != nil {
// occurs only if the size is not positive
panic(errors.Wrapf(err, "could not create LRU cache of size %d", c.openedCacheSize))
panic(fmt.Errorf("could not create LRU cache of size %d: %w", c.openedCacheSize, err))
}
cp := uint64(1)
@ -563,13 +563,13 @@ func (b *blobovniczas) getObject(blz *blobovnicza.Blobovnicza, prm *blobovnicza.
// decompress the data
data, err := b.decompressor(res.Object())
if err != nil {
return nil, errors.Wrap(err, "could not decompress object data")
return nil, fmt.Errorf("could not decompress object data: %w", err)
}
// unmarshal the object
obj := object.New()
if err := obj.Unmarshal(data); err != nil {
return nil, errors.Wrap(err, "could not unmarshal the object")
return nil, fmt.Errorf("could not unmarshal the object: %w", err)
}
return &GetSmallRes{
@ -596,13 +596,13 @@ func (b *blobovniczas) getObjectRange(blz *blobovnicza.Blobovnicza, prm *GetRang
// decompress the data
data, err := b.decompressor(res.Object())
if err != nil {
return nil, errors.Wrap(err, "could not decompress object data")
return nil, fmt.Errorf("could not decompress object data: %w", err)
}
// unmarshal the object
obj := object.New()
if err := obj.Unmarshal(data); err != nil {
return nil, errors.Wrap(err, "could not unmarshal the object")
return nil, fmt.Errorf("could not unmarshal the object: %w", err)
}
from := prm.rng.GetOffset()
@ -766,9 +766,9 @@ func (b *blobovniczas) init() error {
return b.iterateLeaves(func(p string) (bool, error) {
blz, err := b.openBlobovnicza(p)
if err != nil {
return false, errors.Wrapf(err, "could not open blobovnicza %s", p)
return false, fmt.Errorf("could not open blobovnicza %s: %w", p, err)
} else if err := blz.Init(); err != nil {
return false, errors.Wrapf(err, "could not initialize blobovnicza structure %s", p)
return false, fmt.Errorf("could not initialize blobovnicza structure %s: %w", p, err)
}
log := b.log.With(zap.String("id", p))
@ -831,7 +831,7 @@ func (b *blobovniczas) openBlobovnicza(p string) (*blobovnicza.Blobovnicza, erro
)...)
if err := blz.Open(); err != nil {
return nil, errors.Wrapf(err, "could not open blobovnicza %s", p)
return nil, fmt.Errorf("could not open blobovnicza %s: %w", p, err)
}
b.activeMtx.Lock()

3
pkg/local_object_storage/blobstor/delete_big.go
View file

@ -1,9 +1,10 @@
package blobstor
import (
"errors"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobstor/fstree"
"github.com/pkg/errors"
)
// DeleteBigPrm groups the parameters of DeleteBig operation.

3
pkg/local_object_storage/blobstor/exists.go
View file

@ -1,9 +1,10 @@
package blobstor
import (
"errors"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobstor/fstree"
"github.com/pkg/errors"
)
// ExistsPrm groups the parameters of Exists operation.

10
pkg/local_object_storage/blobstor/get_big.go
View file

@ -1,9 +1,11 @@
package blobstor
import (
"errors"
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobstor/fstree"
"github.com/pkg/errors"
)
// GetBigPrm groups the parameters of GetBig operation.
@ -31,18 +33,18 @@ func (b *BlobStor) GetBig(prm *GetBigPrm) (*GetBigRes, error) {
return nil, object.ErrNotFound
}
return nil, errors.Wrap(err, "could not read object from fs tree")
return nil, fmt.Errorf("could not read object from fs tree: %w", err)
}
data, err = b.decompressor(data)
if err != nil {
return nil, errors.Wrap(err, "could not decompress object data")
return nil, fmt.Errorf("could not decompress object data: %w", err)
}
// unmarshal the object
obj := object.New()
if err := obj.Unmarshal(data); err != nil {
return nil, errors.Wrap(err, "could not unmarshal the object")
return nil, fmt.Errorf("could not unmarshal the object: %w", err)
}
return &GetBigRes{

9
pkg/local_object_storage/blobstor/get_range_big.go
View file

@ -1,8 +1,9 @@
package blobstor
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/pkg/errors"
)
// GetRangeBigPrm groups the parameters of GetRangeBig operation.
@ -26,18 +27,18 @@ func (b *BlobStor) GetRangeBig(prm *GetRangeBigPrm) (*GetRangeBigRes, error) {
// get compressed object data
data, err := b.fsTree.Get(prm.addr)
if err != nil {
return nil, errors.Wrap(err, "could not read object from fs tree")
return nil, fmt.Errorf("could not read object from fs tree: %w", err)
}
data, err = b.decompressor(data)
if err != nil {
return nil, errors.Wrap(err, "could not decompress object data")
return nil, fmt.Errorf("could not decompress object data: %w", err)
}
// unmarshal the object
obj := object.New()
if err := obj.Unmarshal(data); err != nil {
return nil, errors.Wrap(err, "could not unmarshal the object")
return nil, fmt.Errorf("could not unmarshal the object: %w", err)
}
payload := obj.Payload()

5
pkg/local_object_storage/blobstor/put.go
View file

@ -1,8 +1,9 @@
package blobstor
import (
"fmt"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/pkg/errors"
)
// PutPrm groups the parameters of Put operation.
@ -27,7 +28,7 @@ func (b *BlobStor) Put(prm *PutPrm) (*PutRes, error) {
// marshal object
data, err := prm.obj.Marshal()
if err != nil {
return nil, errors.Wrap(err, "could not marshal the object")
return nil, fmt.Errorf("could not marshal the object: %w", err)
}
return b.PutRaw(prm.obj.Address(), data)

7
pkg/local_object_storage/engine/control.go
View file

@ -1,7 +1,8 @@
package engine
import (
"github.com/pkg/errors"
"fmt"
"go.uber.org/zap"
)
@ -12,7 +13,7 @@ func (e *StorageEngine) Open() error {
for id, sh := range e.shards {
if err := sh.Open(); err != nil {
return errors.Wrapf(err, "could not open shard %s", id)
return fmt.Errorf("could not open shard %s: %w", id, err)
}
}
@ -26,7 +27,7 @@ func (e *StorageEngine) Init() error {
for id, sh := range e.shards {
if err := sh.Init(); err != nil {
return errors.Wrapf(err, "could not initialize shard %s", id)
return fmt.Errorf("could not initialize shard %s: %w", id, err)
}
}

3
pkg/local_object_storage/engine/head.go
View file

@ -1,11 +1,12 @@
package engine
import (
"errors"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/shard"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/util"
"github.com/pkg/errors"
"go.uber.org/zap"
)

4
pkg/local_object_storage/engine/shards.go
View file

@ -1,13 +1,13 @@
package engine
import (
"errors"
"fmt"
"github.com/google/uuid"
"github.com/nspcc-dev/hrw"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/shard"
"github.com/pkg/errors"
)
var errShardNotFound = errors.New("shard not found")
@ -26,7 +26,7 @@ func (e *StorageEngine) AddShard(opts ...shard.Option) (*shard.ID, error) {
id, err := generateShardID()
if err != nil {
return nil, errors.Wrap(err, "could not generate shard ID")
return nil, fmt.Errorf("could not generate shard ID: %w", err)
}
e.shards[id.String()] = shard.New(append(opts,

4
pkg/local_object_storage/metabase/delete.go
View file

@ -2,11 +2,11 @@ package meta
import (
"bytes"
"errors"
"fmt"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
)
@ -80,7 +80,7 @@ func (db *DB) delete(tx *bbolt.Tx, addr *objectSDK.Address, refCounter reference
if graveyard != nil {
err := graveyard.Delete(addressKey(addr))
if err != nil {
return errors.Wrap(err, "could not remove from graveyard")
return fmt.Errorf("could not remove from graveyard: %w", err)
}
}

2
pkg/local_object_storage/metabase/delete_test.go
View file

@ -1,11 +1,11 @@
package meta_test
import (
"errors"
"testing"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
)

7
pkg/local_object_storage/metabase/graveyard.go
View file

@ -2,9 +2,10 @@ package meta
import (
"bytes"
"errors"
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
)
@ -50,7 +51,7 @@ func (db *DB) iterateOverGraveyard(tx *bbolt.Tx, h GraveHandler) error {
// parse Grave
g, err := graveFromKV(k, v)
if err != nil {
return errors.Wrap(err, "could not parse Grave")
return fmt.Errorf("could not parse Grave: %w", err)
}
// handler Grave
@ -67,7 +68,7 @@ func (db *DB) iterateOverGraveyard(tx *bbolt.Tx, h GraveHandler) error {
func graveFromKV(k, v []byte) (*Grave, error) {
addr, err := addressFromKey(k)
if err != nil {
return nil, errors.Wrap(err, "could not parse address")
return nil, fmt.Errorf("could not parse address: %w", err)
}
return &Grave{

5
pkg/local_object_storage/metabase/inhume.go
View file

@ -2,9 +2,10 @@ package meta
import (
"bytes"
"errors"
"fmt"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
)
@ -86,7 +87,7 @@ func (db *DB) Inhume(prm *InhumePrm) (res *InhumeRes, err error) {
if data != nil && !bytes.Equal(data, []byte(inhumeGCMarkValue)) {
err := graveyard.Delete(tombKey)
if err != nil {
return errors.Wrap(err, "could not remove grave with tombstone key")
return fmt.Errorf("could not remove grave with tombstone key: %w", err)
}
}
} else {

2
pkg/local_object_storage/metabase/inhume_test.go
View file

@ -1,11 +1,11 @@
package meta_test
import (
"errors"
"testing"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
)

11
pkg/local_object_storage/metabase/iterators.go
View file

@ -1,12 +1,13 @@
package meta
import (
"errors"
"fmt"
"strconv"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
objectV2 "github.com/nspcc-dev/neofs-api-go/v2/object"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
)
@ -60,7 +61,7 @@ func (db *DB) iterateExpired(tx *bbolt.Tx, epoch uint64, h ExpiredObjectHandler)
expiresAt, err := strconv.ParseUint(string(expKey), 10, 64)
if err != nil {
return errors.Wrap(err, "could not parse expiration epoch")
return fmt.Errorf("could not parse expiration epoch: %w", err)
} else if expiresAt >= epoch {
return nil
}
@ -70,14 +71,14 @@ func (db *DB) iterateExpired(tx *bbolt.Tx, epoch uint64, h ExpiredObjectHandler)
err = id.Parse(string(idKey))
if err != nil {
return errors.Wrap(err, "could not parse ID of expired object")
return fmt.Errorf("could not parse ID of expired object: %w", err)
}
cid := container.NewID()
err = cid.Parse(string(cidBytes))
if err != nil {
return errors.Wrap(err, "could not parse container ID of expired bucket")
return fmt.Errorf("could not parse container ID of expired bucket: %w", err)
}
addr := object.NewAddress()
@ -133,7 +134,7 @@ func (db *DB) iterateCoveredByTombstones(tx *bbolt.Tx, tss map[string]struct{},
if _, ok := tss[string(v)]; ok {
addr, err := addressFromKey(k)
if err != nil {
return errors.Wrap(err, "could not parse address of the object under tombstone")
return fmt.Errorf("could not parse address of the object under tombstone: %w", err)
}
return h(addr)

2
pkg/local_object_storage/metabase/select.go
View file

@ -2,13 +2,13 @@ package meta
import (
"encoding/binary"
"errors"
"fmt"
"strings"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
v2object "github.com/nspcc-dev/neofs-api-go/v2/object"
"github.com/pkg/errors"
"go.etcd.io/bbolt"
"go.uber.org/zap"
)

5
pkg/local_object_storage/shard/container.go
View file

@ -1,8 +1,9 @@
package shard
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/pkg/errors"
)
type ContainerSizePrm struct {
@ -28,7 +29,7 @@ func (r *ContainerSizeRes) Size() uint64 {
func (s *Shard) ContainerSize(prm *ContainerSizePrm) (*ContainerSizeRes, error) {
size, err := s.metaBase.ContainerSize(prm.cid)
if err != nil {
return nil, errors.Wrap(err, "could not get container size")
return nil, fmt.Errorf("could not get container size: %w", err)
}
return &ContainerSizeRes{

8
pkg/local_object_storage/shard/control.go
View file

@ -1,7 +1,7 @@
package shard
import (
"github.com/pkg/errors"
"fmt"
)
// Open opens all Shard's components.
@ -16,7 +16,7 @@ func (s *Shard) Open() error {
for _, component := range components {
if err := component.Open(); err != nil {
return errors.Wrapf(err, "could not open %T", component)
return fmt.Errorf("could not open %T: %w", component, err)
}
}
@ -35,7 +35,7 @@ func (s *Shard) Init() error {
for _, component := range components {
if err := component.Init(); err != nil {
return errors.Wrapf(err, "could not initialize %T", component)
return fmt.Errorf("could not initialize %T: %w", component, err)
}
}
@ -70,7 +70,7 @@ func (s *Shard) Close() error {
for _, component := range components {
if err := component.Close(); err != nil {
return errors.Wrapf(err, "could not close %s", component)
return fmt.Errorf("could not close %s: %w", component, err)
}
}

3
pkg/local_object_storage/shard/delete.go
View file

@ -1,12 +1,13 @@
package shard
import (
"errors"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobovnicza"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobstor"
meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
"github.com/pkg/errors"
"go.uber.org/zap"
)

2
pkg/local_object_storage/shard/get.go
View file

@ -1,6 +1,7 @@
package shard
import (
"errors"
"fmt"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
@ -8,7 +9,6 @@ import (
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobovnicza"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobstor"
meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
"github.com/pkg/errors"
"go.uber.org/zap"
)

3
pkg/local_object_storage/shard/list.go
View file

@ -6,7 +6,6 @@ import (
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/nspcc-dev/neofs-api-go/pkg/object"
meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -48,7 +47,7 @@ func (s *Shard) List() (*SelectRes, error) {
func (s *Shard) ListContainers(_ *ListContainersPrm) (*ListContainersRes, error) {
containers, err := s.metaBase.Containers()
if err != nil {
return nil, errors.Wrap(err, "could not get list of containers")
return nil, fmt.Errorf("could not get list of containers: %w", err)
}
return &ListContainersRes{

7
pkg/local_object_storage/shard/put.go
View file

@ -1,10 +1,11 @@
package shard
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/core/object"
"github.com/nspcc-dev/neofs-node/pkg/local_object_storage/blobstor"
meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -52,14 +53,14 @@ func (s *Shard) Put(prm *PutPrm) (*PutRes, error) {
// res == nil if there is no writeCache or writeCache.Put has been failed
if res, err = s.blobStor.Put(putPrm); err != nil {
return nil, errors.Wrap(err, "could not put object to BLOB storage")
return nil, fmt.Errorf("could not put object to BLOB storage: %w", err)
}
// put to metabase
if err := meta.Put(s.metaBase, prm.obj, res.BlobovniczaID()); err != nil {
// may we need to handle this case in a special way
// since the object has been successfully written to BlobStor
return nil, errors.Wrap(err, "could not put object to metabase")
return nil, fmt.Errorf("could not put object to metabase: %w", err)
}
return nil, nil

5
pkg/local_object_storage/shard/select.go
View file

@ -1,10 +1,11 @@
package shard
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
objectSDK "github.com/nspcc-dev/neofs-api-go/pkg/object"
meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
"github.com/pkg/errors"
)
// SelectPrm groups the parameters of Select operation.
@ -48,7 +49,7 @@ func (r *SelectRes) AddressList() []*objectSDK.Address {
func (s *Shard) Select(prm *SelectPrm) (*SelectRes, error) {
addrList, err := meta.Select(s.metaBase, prm.cid, prm.filters)
if err != nil {
return nil, errors.Wrap(err, "could not select objects from metabase")
return nil, fmt.Errorf("could not select objects from metabase: %w", err)
}
return &SelectRes{

9
pkg/morph/client/audit/get_result.go
View file

@ -1,8 +1,9 @@
package audit
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// GetAuditResultArgs groups the arguments
@ -35,14 +36,14 @@ func (c *Client) GetAuditResult(args GetAuditResultArgs) (*GetAuditResultValue,
args.id,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.getResultMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.getResultMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.getResultMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.getResultMethod, ln)
}
resultBytes, err := client.BytesFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array from stack item (%s)", c.getResultMethod)
return nil, fmt.Errorf("could not get byte array from stack item (%s): %w", c.getResultMethod, err)
}
return &GetAuditResultValue{

17
pkg/morph/client/audit/list_results.go
View file

@ -1,9 +1,10 @@
package audit
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// ListResultsArgs groups the arguments
@ -66,7 +67,7 @@ func (c *Client) ListAuditResults(args ListResultsArgs) (*ListResultsValues, err
c.listResultsMethod,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.listResultsMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.listResultsMethod, err)
}
return parseAuditResults(items, c.listResultsMethod)
@ -80,7 +81,7 @@ func (c *Client) ListAuditResultsByEpoch(args ListResultsByEpochArgs) (*ListResu
args.epoch,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.listByEpochResultsMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.listByEpochResultsMethod, err)
}
return parseAuditResults(items, c.listByEpochResultsMethod)
@ -95,7 +96,7 @@ func (c *Client) ListAuditResultsByCID(args ListResultsByCIDArgs) (*ListResultsV
args.cid,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.listByCIDResultsMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.listByCIDResultsMethod, err)
}
return parseAuditResults(items, c.listByCIDResultsMethod)
@ -111,7 +112,7 @@ func (c *Client) ListAuditResultsByNode(args ListResultsByNodeArgs) (*ListResult
args.nodeKey,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.listByNodeResultsMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.listByNodeResultsMethod, err)
}
return parseAuditResults(items, c.listByNodeResultsMethod)
@ -119,12 +120,12 @@ func (c *Client) ListAuditResultsByNode(args ListResultsByNodeArgs) (*ListResult
func parseAuditResults(items []stackitem.Item, method string) (*ListResultsValues, error) {
if ln := len(items); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", method, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", method, ln)
}
items, err := client.ArrayFromStackItem(items[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get stack item array from stack item (%s)", method)
return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", method, err)
}
res := &ListResultsValues{
@ -134,7 +135,7 @@ func parseAuditResults(items []stackitem.Item, method string) (*ListResultsValue
for i := range items {
rawRes, err := client.BytesFromStackItem(items[i])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array from stack item (%s)", method)
return nil, fmt.Errorf("could not get byte array from stack item (%s): %w", method, err)
}
res.rawResults = append(res.rawResults, rawRes)

11
pkg/morph/client/audit/put_result.go
View file

@ -1,7 +1,7 @@
package audit
import (
"github.com/pkg/errors"
"fmt"
)
// PutAuditResultArgs groups the arguments
@ -19,8 +19,13 @@ func (g *PutAuditResultArgs) SetRawResult(v []byte) {
// PutAuditResult invokes the call of "put audit result" method
// of NeoFS Audit contract.
func (c *Client) PutAuditResult(args PutAuditResultArgs) error {
return errors.Wrapf(c.client.Invoke(
err := c.client.Invoke(
c.putResultMethod,
args.rawResult,
), "could not invoke method (%s)", c.putResultMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.putResultMethod, err)
}
return nil
}

8
pkg/morph/client/audit/wrapper/result.go
View file

@ -1,10 +1,12 @@
package audit
import (
"errors"
"fmt"
auditAPI "github.com/nspcc-dev/neofs-api-go/pkg/audit"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/nspcc-dev/neofs-node/pkg/morph/client/audit"
"github.com/pkg/errors"
)
// ResultID is an identity of audit result inside audit contract.
@ -19,7 +21,7 @@ var errUnsupported = errors.New("unsupported structure version")
func (w *ClientWrapper) PutAuditResult(result *auditAPI.Result) error {
rawResult, err := result.Marshal()
if err != nil {
return errors.Wrap(err, "could not marshal audit result")
return fmt.Errorf("could not marshal audit result: %w", err)
}
args := audit.PutAuditResultArgs{}
@ -121,7 +123,7 @@ func (w *ClientWrapper) GetAuditResult(id ResultID) (*auditAPI.Result, error) {
auditRes := auditAPI.NewResult()
if err := auditRes.Unmarshal(value.Result()); err != nil {
return nil, errors.Wrap(err, "could not unmarshal audit result structure")
return nil, fmt.Errorf("could not unmarshal audit result structure: %w", err)
}
return auditRes, nil

8
pkg/morph/client/balance/balanceOf.go
View file

@ -1,10 +1,10 @@
package balance
import (
"fmt"
"math/big"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// GetBalanceOfArgs groups the arguments
@ -38,14 +38,14 @@ func (c *Client) BalanceOf(args GetBalanceOfArgs) (*GetBalanceOfValues, error) {
args.wallet,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.balanceOfMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.balanceOfMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.balanceOfMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.balanceOfMethod, ln)
}
amount, err := client.BigIntFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get integer stack item from stack item (%s)", c.balanceOfMethod)
return nil, fmt.Errorf("could not get integer stack item from stack item (%s): %w", c.balanceOfMethod, err)
}
return &GetBalanceOfValues{

9
pkg/morph/client/balance/decimals.go
View file

@ -1,8 +1,9 @@
package balance
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// DecimalsArgs groups the arguments
@ -28,14 +29,14 @@ func (c *Client) Decimals(args DecimalsArgs) (*DecimalsValues, error) {
c.decimalsMethod,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.decimalsMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.decimalsMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.decimalsMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.decimalsMethod, ln)
}
decimals, err := client.IntFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get integer stack item from stack item (%s)", c.decimalsMethod)
return nil, fmt.Errorf("could not get integer stack item from stack item (%s): %w", c.decimalsMethod, err)
}
return &DecimalsValues{

11
pkg/morph/client/balance/transfer.go
View file

@ -1,7 +1,7 @@
package balance
import (
"github.com/pkg/errors"
"fmt"
)
// TransferXArgs groups the arguments
@ -58,11 +58,16 @@ func (c *Client) transferX(notary bool, args TransferXArgs) error {
f = c.client.NotaryInvoke
}
return errors.Wrapf(f(
err := f(
c.transferXMethod,
args.sender,
args.recipient,
args.amount,
args.details,
), "could not invoke method (%s)", c.transferXMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.transferXMethod, err)
}
return nil
}

5
pkg/morph/client/balance/wrapper/decimals.go
View file

@ -1,8 +1,9 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client/balance"
"github.com/pkg/errors"
)
// Decimals decimal precision of currency transactions
@ -14,7 +15,7 @@ func (w *Wrapper) Decimals() (uint32, error) {
// invoke smart contract call
values, err := w.client.Decimals(args)
if err != nil {
return 0, errors.Wrap(err, "could not invoke smart contract")
return 0, fmt.Errorf("could not invoke smart contract: %w", err)
}
return uint32(values.Decimals()), nil

7
pkg/morph/client/balance/wrapper/transfer.go
View file

@ -1,9 +1,10 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/owner"
"github.com/nspcc-dev/neofs-node/pkg/morph/client/balance"
"github.com/pkg/errors"
)
// TransferPrm groups parameters of TransferX method.
@ -30,12 +31,12 @@ func (w *Wrapper) TransferXNotary(p TransferPrm) error {
func (w *Wrapper) transferX(notary bool, p TransferPrm) error {
from, err := owner.ScriptHashBE(p.From)
if err != nil {
return errors.Wrap(err, "invalid sender")
return fmt.Errorf("invalid sender: %w", err)
}
to, err := owner.ScriptHashBE(p.To)
if err != nil {
return errors.Wrap(err, "invalid recipient")
return fmt.Errorf("invalid recipient: %w", err)
}
// prepare invocation arguments

8
pkg/morph/client/client.go
View file

@ -2,6 +2,7 @@ package client
import (
"context"
"errors"
"fmt"
"time"
@ -17,7 +18,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neo-go/pkg/wallet"
"github.com/nspcc-dev/neofs-node/pkg/util/logger"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -230,7 +230,7 @@ func (c *Client) TxHalt(h util.Uint256) (bool, error) {
func (c *Client) NeoFSAlphabetList() (keys.PublicKeys, error) {
list, err := c.roleList(noderoles.NeoFSAlphabet)
if err != nil {
return nil, errors.Wrap(err, "can't get alphabet nodes role list")
return nil, fmt.Errorf("can't get alphabet nodes role list: %w", err)
}
return list, nil
@ -239,7 +239,7 @@ func (c *Client) NeoFSAlphabetList() (keys.PublicKeys, error) {
func (c *Client) roleList(r noderoles.Role) (keys.PublicKeys, error) {
height, err := c.client.GetBlockCount()
if err != nil {
return nil, errors.Wrap(err, "can't get chain height")
return nil, fmt.Errorf("can't get chain height: %w", err)
}
return c.client.GetDesignatedByRole(r, height)
@ -285,7 +285,7 @@ func toStackParameter(value interface{}) (sc.Parameter, error) {
return toStackParameter(arr)
default:
return result, errors.Errorf("chain/client: unsupported parameter %v", value)
return result, fmt.Errorf("chain/client: unsupported parameter %v", value)
}
return result, nil

13
pkg/morph/client/container/delete.go
View file

@ -1,6 +1,8 @@
package container
import "github.com/pkg/errors"
import (
"fmt"
)
// DeleteArgs groups the arguments
// of delete container invocation call.
@ -25,9 +27,14 @@ func (p *DeleteArgs) SetSignature(v []byte) {
// Delete invokes the call of delete container
// method of NeoFS Container contract.
func (c *Client) Delete(args DeleteArgs) error {
return errors.Wrapf(c.client.Invoke(
err := c.client.Invoke(
c.deleteMethod,
args.cid,
args.sig,
), "could not invoke method (%s)", c.deleteMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.deleteMethod, err)
}
return nil
}

17
pkg/morph/client/container/eacl.go
View file

@ -1,8 +1,9 @@
package container
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// EACLArgs groups the arguments
@ -51,33 +52,33 @@ func (c *Client) EACL(args EACLArgs) (*EACLValues, error) {
args.cid,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.eaclMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.eaclMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.eaclMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.eaclMethod, ln)
}
arr, err := client.ArrayFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get item array of eACL (%s)", c.eaclMethod)
return nil, fmt.Errorf("could not get item array of eACL (%s): %w", c.eaclMethod, err)
}
if len(arr) != 3 {
return nil, errors.Errorf("unexpected eacl stack item count (%s): %d", c.eaclMethod, len(arr))
return nil, fmt.Errorf("unexpected eacl stack item count (%s): %d", c.eaclMethod, len(arr))
}
eacl, err := client.BytesFromStackItem(arr[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array of eACL (%s)", c.eaclMethod)
return nil, fmt.Errorf("could not get byte array of eACL (%s): %w", c.eaclMethod, err)
}
sig, err := client.BytesFromStackItem(arr[1])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array of eACL signature (%s)", c.eaclMethod)
return nil, fmt.Errorf("could not get byte array of eACL signature (%s): %w", c.eaclMethod, err)
}
pub, err := client.BytesFromStackItem(arr[2])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array of eACL public key (%s)", c.eaclMethod)
return nil, fmt.Errorf("could not get byte array of eACL public key (%s): %w", c.eaclMethod, err)
}
return &EACLValues{

13
pkg/morph/client/container/eacl_set.go
View file

@ -1,6 +1,8 @@
package container
import "github.com/pkg/errors"
import (
"fmt"
)
// SetEACLArgs groups the arguments
// of set eACL invocation call.
@ -25,9 +27,14 @@ func (p *SetEACLArgs) SetSignature(v []byte) {
// SetEACL invokes the call of set eACL method
// of NeoFS Container contract.
func (c *Client) SetEACL(args SetEACLArgs) error {
return errors.Wrapf(c.client.Invoke(
err := c.client.Invoke(
c.setEACLMethod,
args.eacl,
args.sig,
), "could not invoke method (%s)", c.setEACLMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.setEACLMethod, err)
}
return nil
}

34
pkg/morph/client/container/estimations.go
View file

@ -1,7 +1,7 @@
package container
import (
"github.com/pkg/errors"
"fmt"
)
type StartEstimation struct {
@ -21,29 +21,29 @@ func (e *StopEstimation) SetEpoch(v int64) {
}
func (c *Client) StartEstimation(args StartEstimation) error {
return errors.Wrapf(c.client.Invoke(
c.startEstimation,
args.epoch,
), "could not invoke method (%s)", c.startEstimation)
if err := c.client.Invoke(c.startEstimation, args.epoch); err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.startEstimation, err)
}
return nil
}
func (c *Client) StartEstimationNotary(args StartEstimation) error {
return errors.Wrapf(c.client.NotaryInvoke(
c.startEstimation,
args.epoch,
), "could not invoke method (%s)", c.startEstimation)
if err := c.client.NotaryInvoke(c.startEstimation, args.epoch); err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.startEstimation, err)
}
return nil
}
func (c *Client) StopEstimation(args StopEstimation) error {
return errors.Wrapf(c.client.Invoke(
c.stopEstimation,
args.epoch,
), "could not invoke method (%s)", c.stopEstimation)
if err := c.client.Invoke(c.stopEstimation, args.epoch); err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.stopEstimation, err)
}
return nil
}
func (c *Client) StopEstimationNotary(args StopEstimation) error {
return errors.Wrapf(c.client.NotaryInvoke(
c.stopEstimation,
args.epoch,
), "could not invoke method (%s)", c.stopEstimation)
if err := c.client.NotaryInvoke(c.stopEstimation, args.epoch); err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.stopEstimation, err)
}
return nil
}

9
pkg/morph/client/container/get.go
View file

@ -1,8 +1,9 @@
package container
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// GetArgs groups the arguments
@ -37,14 +38,14 @@ func (c *Client) Get(args GetArgs) (*GetValues, error) {
args.cid,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.getMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.getMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.getMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.getMethod, ln)
}
cnrBytes, err := client.BytesFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array from stack item (%s)", c.getMethod)
return nil, fmt.Errorf("could not get byte array from stack item (%s): %w", c.getMethod, err)
}
return &GetValues{

11
pkg/morph/client/container/list.go
View file

@ -1,8 +1,9 @@
package container
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// ListArgs groups the arguments
@ -41,14 +42,14 @@ func (c *Client) List(args ListArgs) (*ListValues, error) {
invokeArgs...,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.listMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.listMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.listMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.listMethod, ln)
}
prms, err = client.ArrayFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get stack item array from stack item (%s)", c.listMethod)
return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", c.listMethod, err)
}
res := &ListValues{
@ -58,7 +59,7 @@ func (c *Client) List(args ListArgs) (*ListValues, error) {
for i := range prms {
cid, err := client.BytesFromStackItem(prms[i])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array from stack item (%s)", c.listMethod)
return nil, fmt.Errorf("could not get byte array from stack item (%s): %w", c.listMethod, err)
}
res.cidList = append(res.cidList, cid)

40
pkg/morph/client/container/load.go
View file

@ -1,8 +1,9 @@
package container
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// PutSizeArgs groups the arguments
@ -43,13 +44,18 @@ func (p *PutSizeArgs) SetReporterKey(v []byte) {
// Put invokes the call of put container method
// of NeoFS Container contract.
func (c *Client) PutSize(args PutSizeArgs) error {
return errors.Wrapf(c.client.Invoke(
err := c.client.Invoke(
c.putSizeMethod,
args.epoch,
args.cid,
args.size,
args.reporterKey,
), "could not invoke method (%s)", c.putSizeMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.putSizeMethod, err)
}
return nil
}
// ListSizesArgs groups the arguments
@ -84,14 +90,14 @@ func (c *Client) ListSizes(args ListSizesArgs) (*ListSizesValues, error) {
args.epoch,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.listSizesMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.listSizesMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.listSizesMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.listSizesMethod, ln)
}
prms, err = client.ArrayFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get stack item array from stack item (%s)", c.listSizesMethod)
return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", c.listSizesMethod, err)
}
res := &ListSizesValues{
@ -101,7 +107,7 @@ func (c *Client) ListSizes(args ListSizesArgs) (*ListSizesValues, error) {
for i := range prms {
id, err := client.BytesFromStackItem(prms[i])
if err != nil {
return nil, errors.Wrapf(err, "could not get ID byte array from stack item (%s)", c.listSizesMethod)
return nil, fmt.Errorf("could not get ID byte array from stack item (%s): %w", c.listSizesMethod, err)
}
res.ids = append(res.ids, id)
@ -152,28 +158,28 @@ func (c *Client) GetContainerSize(args GetSizeArgs) (*GetSizeValues, error) {
args.id,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.getSizeMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.getSizeMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.getSizeMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.getSizeMethod, ln)
}
prms, err = client.ArrayFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get stack items of estimation fields from stack item (%s)", c.getSizeMethod)
return nil, fmt.Errorf("could not get stack items of estimation fields from stack item (%s): %w", c.getSizeMethod, err)
} else if ln := len(prms); ln != 2 {
return nil, errors.Errorf("unexpected stack item count of estimations fields (%s)", c.getSizeMethod)
return nil, fmt.Errorf("unexpected stack item count of estimations fields (%s)", c.getSizeMethod)
}
es := Estimations{}
es.ContainerID, err = client.BytesFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get container ID byte array from stack item (%s)", c.getSizeMethod)
return nil, fmt.Errorf("could not get container ID byte array from stack item (%s): %w", c.getSizeMethod, err)
}
prms, err = client.ArrayFromStackItem(prms[1])
if err != nil {
return nil, errors.Wrapf(err, "could not get estimation list array from stack item (%s)", c.getSizeMethod)
return nil, fmt.Errorf("could not get estimation list array from stack item (%s): %w", c.getSizeMethod, err)
}
es.Estimations = make([]Estimation, 0, len(prms))
@ -181,21 +187,21 @@ func (c *Client) GetContainerSize(args GetSizeArgs) (*GetSizeValues, error) {
for i := range prms {
arr, err := client.ArrayFromStackItem(prms[i])
if err != nil {
return nil, errors.Wrapf(err, "could not get estimation struct from stack item (%s)", c.getSizeMethod)
return nil, fmt.Errorf("could not get estimation struct from stack item (%s): %w", c.getSizeMethod, err)
} else if ln := len(arr); ln != 2 {
return nil, errors.Errorf("unexpected stack item count of estimation fields (%s)", c.getSizeMethod)
return nil, fmt.Errorf("unexpected stack item count of estimation fields (%s)", c.getSizeMethod)
}
e := Estimation{}
e.Reporter, err = client.BytesFromStackItem(arr[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get reporter byte array from stack item (%s)", c.getSizeMethod)
return nil, fmt.Errorf("could not get reporter byte array from stack item (%s): %w", c.getSizeMethod, err)
}
e.Size, err = client.IntFromStackItem(arr[1])
if err != nil {
return nil, errors.Wrapf(err, "could not get estimation size from stack item (%s)", c.getSizeMethod)
return nil, fmt.Errorf("could not get estimation size from stack item (%s): %w", c.getSizeMethod, err)
}
es.Estimations = append(es.Estimations, e)

11
pkg/morph/client/container/put.go
View file

@ -1,7 +1,7 @@
package container
import (
"github.com/pkg/errors"
"fmt"
)
// PutArgs groups the arguments
@ -35,10 +35,15 @@ func (p *PutArgs) SetSignature(v []byte) {
// Put invokes the call of put container method
// of NeoFS Container contract.
func (c *Client) Put(args PutArgs) error {
return errors.Wrapf(c.client.Invoke(
err := c.client.Invoke(
c.putMethod,
args.cnr,
args.sig,
args.publicKey,
), "could not invoke method (%s)", c.putMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.putMethod, err)
}
return nil
}

7
pkg/morph/client/container/wrapper/container.go
View file

@ -2,13 +2,14 @@ package wrapper
import (
"crypto/sha256"
"errors"
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/nspcc-dev/neofs-api-go/pkg/owner"
v2refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
core "github.com/nspcc-dev/neofs-node/pkg/core/container"
client "github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
"github.com/pkg/errors"
)
var (
@ -34,7 +35,7 @@ func (w *Wrapper) Put(cnr *container.Container, pubKey, signature []byte) (*cont
data, err := cnr.Marshal()
if err != nil {
return nil, errors.Wrap(err, "can't marshal container")
return nil, fmt.Errorf("can't marshal container: %w", err)
}
id.SetSHA256(sha256.Sum256(data))
@ -79,7 +80,7 @@ func (w *Wrapper) Get(cid *container.ID) (*container.Container, error) {
cnr := container.New()
if err := cnr.Unmarshal(rpcAnswer.Container()); err != nil {
// use other major version if there any
return nil, errors.Wrap(err, "can't unmarshal container")
return nil, fmt.Errorf("can't unmarshal container: %w", err)
}
return cnr, nil

5
pkg/morph/client/container/wrapper/eacl.go
View file

@ -1,12 +1,13 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg"
"github.com/nspcc-dev/neofs-api-go/pkg/acl/eacl"
containerSDK "github.com/nspcc-dev/neofs-api-go/pkg/container"
"github.com/nspcc-dev/neofs-node/pkg/core/container"
client "github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
"github.com/pkg/errors"
)
// GetEACL reads the extended ACL table from NeoFS system
@ -65,7 +66,7 @@ func (w *Wrapper) PutEACL(table *eacl.Table, signature []byte) error {
data, err := table.Marshal()
if err != nil {
return errors.Wrap(err, "can't marshal eacl table")
return fmt.Errorf("can't marshal eacl table: %w", err)
}
args.SetEACL(data)

12
pkg/morph/client/netmap/add_peer.go
View file

@ -1,7 +1,7 @@
package netmap
import (
"github.com/pkg/errors"
"fmt"
)
// AddPeerArgs groups the arguments
@ -18,10 +18,8 @@ func (a *AddPeerArgs) SetInfo(v []byte) {
// AddPeer invokes the call of add peer method
// of NeoFS Netmap contract.
func (c *Client) AddPeer(args AddPeerArgs) error {
info := args.info
return errors.Wrapf(c.client.Invoke(
c.addPeerMethod,
info,
), "could not invoke method (%s)", c.addPeerMethod)
if err := c.client.Invoke(c.addPeerMethod, args.info); err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.addPeerMethod, err)
}
return nil
}

12
pkg/morph/client/netmap/config.go
View file

@ -1,9 +1,10 @@
package netmap
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// ConfigArgs groups the arguments
@ -36,19 +37,18 @@ func (c *Client) Config(args ConfigArgs, assert func(stackitem.Item) (interface{
args.key,
)
if err != nil {
return nil, errors.Wrapf(err,
"could not perform test invocation (%s)",
c.configMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
c.configMethod, err)
}
if ln := len(items); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d",
return nil, fmt.Errorf("unexpected stack item count (%s): %d",
c.configMethod, ln)
}
val, err := assert(items[0])
if err != nil {
return nil, errors.Wrap(err, "value type assertion failed")
return nil, fmt.Errorf("value type assertion failed: %w", err)
}
return &ConfigValues{

12
pkg/morph/client/netmap/epoch.go
View file

@ -1,8 +1,9 @@
package netmap
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// EpochArgs groups the arguments
@ -28,19 +29,18 @@ func (c *Client) Epoch(_ EpochArgs) (*EpochValues, error) {
c.epochMethod,
)
if err != nil {
return nil, errors.Wrapf(err,
"could not perform test invocation (%s)",
c.epochMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
c.epochMethod, err)
}
if ln := len(items); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d",
return nil, fmt.Errorf("unexpected stack item count (%s): %d",
c.epochMethod, ln)
}
num, err := client.IntFromStackItem(items[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get number from stack item (%s)", c.epochMethod)
return nil, fmt.Errorf("could not get number from stack item (%s): %w", c.epochMethod, err)
}
return &EpochValues{

32
pkg/morph/client/netmap/netmap.go
View file

@ -1,9 +1,10 @@
package netmap
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// GetNetMapArgs groups the arguments
@ -61,9 +62,8 @@ func (c *Client) NetMap(_ GetNetMapArgs) (*GetNetMapValues, error) {
c.netMapMethod,
)
if err != nil {
return nil, errors.Wrapf(err,
"could not perform test invocation (%s)",
c.netMapMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
c.netMapMethod, err)
}
return peersFromStackItems(prms, c.netMapMethod)
@ -78,9 +78,8 @@ func (c *Client) Snapshot(a GetSnapshotArgs) (*GetNetMapValues, error) {
int64(a.diff),
)
if err != nil {
return nil, errors.Wrapf(err,
"could not perform test invocation (%s)",
c.netMapMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
c.netMapMethod, err)
}
return peersFromStackItems(prms, c.snapshotMethod)
@ -94,9 +93,8 @@ func (c *Client) EpochSnapshot(args EpochSnapshotArgs) (*EpochSnapshotValues, er
int64(args.epoch),
)
if err != nil {
return nil, errors.Wrapf(err,
"could not perform test invocation (%s)",
c.epochSnapshotMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
c.epochSnapshotMethod, err)
}
nmVals, err := peersFromStackItems(prms, c.epochSnapshotMethod)
@ -111,15 +109,14 @@ func (c *Client) EpochSnapshot(args EpochSnapshotArgs) (*EpochSnapshotValues, er
func peersFromStackItems(stack []stackitem.Item, method string) (*GetNetMapValues, error) {
if ln := len(stack); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d",
return nil, fmt.Errorf("unexpected stack item count (%s): %d",
method, ln)
}
peers, err := client.ArrayFromStackItem(stack[0])
if err != nil {
return nil, errors.Wrapf(err,
"could not get stack item array from stack item (%s)",
method)
return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w",
method, err)
}
res := &GetNetMapValues{
@ -129,8 +126,7 @@ func peersFromStackItems(stack []stackitem.Item, method string) (*GetNetMapValue
for i := range peers {
peer, err := peerInfoFromStackItem(peers[i])
if err != nil {
return nil, errors.Wrapf(err,
"could not parse stack item (Peer #%d)", i)
return nil, fmt.Errorf("could not parse stack item (Peer #%d): %w", i, err)
}
res.peers = append(res.peers, peer)
@ -142,9 +138,9 @@ func peersFromStackItems(stack []stackitem.Item, method string) (*GetNetMapValue
func peerInfoFromStackItem(prm stackitem.Item) ([]byte, error) {
prms, err := client.ArrayFromStackItem(prm)
if err != nil {
return nil, errors.Wrapf(err, "could not get stack item array (PeerInfo)")
return nil, fmt.Errorf("could not get stack item array (PeerInfo): %w", err)
} else if ln := len(prms); ln != nodeInfoFixedPrmNumber {
return nil, errors.Errorf("unexpected stack item count (PeerInfo): expected %d, has %d", 1, ln)
return nil, fmt.Errorf("unexpected stack item count (PeerInfo): expected %d, has %d", 1, ln)
}
return client.BytesFromStackItem(prms[0])

12
pkg/morph/client/netmap/new_epoch.go
View file

@ -1,6 +1,8 @@
package netmap
import "github.com/pkg/errors"
import (
"fmt"
)
// NewEpochArgs groups the arguments
// of new epoch invocation call.
@ -16,8 +18,8 @@ func (a *NewEpochArgs) SetEpochNumber(v int64) {
// NewEpoch invokes the call of new epoch method
// of NeoFS Netmap contract.
func (c *Client) NewEpoch(args NewEpochArgs) error {
return errors.Wrapf(c.client.Invoke(
c.addPeerMethod,
args.number,
), "could not invoke method (%s)", c.newEpochMethod)
if err := c.client.Invoke(c.addPeerMethod, args.number); err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.newEpochMethod, err)
}
return nil
}

12
pkg/morph/client/netmap/update_state.go
View file

@ -1,7 +1,7 @@
package netmap
import (
"github.com/pkg/errors"
"fmt"
)
// UpdateStateArgs groups the arguments
@ -26,9 +26,15 @@ func (u *UpdateStateArgs) SetState(v int64) {
// UpdateState invokes the call of update state method
// of NeoFS Netmap contract.
func (c *Client) UpdateState(args UpdateStateArgs) error {
return errors.Wrapf(c.client.Invoke(
err := c.client.Invoke(
c.updateStateMethod,
args.state,
args.key,
), "could not invoke method (%s)", c.updateStateMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.updateStateMethod, err)
}
return nil
}

12
pkg/morph/client/netmap/wrapper/add_peer.go
View file

@ -1,8 +1,10 @@
package wrapper
import (
"errors"
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
"github.com/pkg/errors"
)
// AddPeer registers peer in NeoFS network through
@ -20,8 +22,8 @@ func (w *Wrapper) AddPeer(nodeInfo *netmap.NodeInfo) error {
args := netmap.AddPeerArgs{}
args.SetInfo(rawNodeInfo)
return errors.Wrap(
w.client.AddPeer(args),
"could not invoke smart contract",
)
if err := w.client.AddPeer(args); err != nil {
return fmt.Errorf("could not invoke smart contract: %w", err)
}
return nil
}

24
pkg/morph/client/netmap/wrapper/config.go
View file

@ -1,10 +1,10 @@
package wrapper
import (
"fmt"
"strconv"
"github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
"github.com/pkg/errors"
)
const (
@ -24,7 +24,7 @@ const (
func (w *Wrapper) MaxObjectSize() (uint64, error) {
objectSize, err := w.readUInt64Config(maxObjectSizeConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get epoch number", w)
return 0, fmt.Errorf("(%T) could not get epoch number: %w", w, err)
}
return objectSize, nil
@ -35,7 +35,7 @@ func (w *Wrapper) MaxObjectSize() (uint64, error) {
func (w *Wrapper) BasicIncomeRate() (uint64, error) {
rate, err := w.readUInt64Config(basicIncomeRateConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get basic income rate", w)
return 0, fmt.Errorf("(%T) could not get basic income rate: %w", w, err)
}
return rate, nil
@ -46,7 +46,7 @@ func (w *Wrapper) BasicIncomeRate() (uint64, error) {
func (w *Wrapper) AuditFee() (uint64, error) {
fee, err := w.readUInt64Config(auditFeeConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get audit fee", w)
return 0, fmt.Errorf("(%T) could not get audit fee: %w", w, err)
}
return fee, nil
@ -56,7 +56,7 @@ func (w *Wrapper) AuditFee() (uint64, error) {
func (w *Wrapper) EpochDuration() (uint64, error) {
epochDuration, err := w.readUInt64Config(epochDurationConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get epoch duration", w)
return 0, fmt.Errorf("(%T) could not get epoch duration: %w", w, err)
}
return epochDuration, nil
@ -67,7 +67,7 @@ func (w *Wrapper) EpochDuration() (uint64, error) {
func (w *Wrapper) ContainerFee() (uint64, error) {
fee, err := w.readUInt64Config(containerFeeConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get container fee", w)
return 0, fmt.Errorf("(%T) could not get container fee: %w", w, err)
}
return fee, nil
@ -78,7 +78,7 @@ func (w *Wrapper) ContainerFee() (uint64, error) {
func (w *Wrapper) EigenTrustIterations() (uint64, error) {
iterations, err := w.readUInt64Config(etIterationsConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get eigen trust iterations", w)
return 0, fmt.Errorf("(%T) could not get eigen trust iterations: %w", w, err)
}
return iterations, nil
@ -89,7 +89,7 @@ func (w *Wrapper) EigenTrustIterations() (uint64, error) {
func (w *Wrapper) EigenTrustAlpha() (float64, error) {
strAlpha, err := w.readStringConfig(etAlphaConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get eigen trust alpha", w)
return 0, fmt.Errorf("(%T) could not get eigen trust alpha: %w", w, err)
}
return strconv.ParseFloat(strAlpha, 64)
@ -100,7 +100,7 @@ func (w *Wrapper) EigenTrustAlpha() (float64, error) {
func (w *Wrapper) InnerRingCandidateFee() (uint64, error) {
fee, err := w.readUInt64Config(irCandidateFeeConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get inner ring candidate fee", w)
return 0, fmt.Errorf("(%T) could not get inner ring candidate fee: %w", w, err)
}
return fee, nil
@ -111,7 +111,7 @@ func (w *Wrapper) InnerRingCandidateFee() (uint64, error) {
func (w *Wrapper) WithdrawFee() (uint64, error) {
fee, err := w.readUInt64Config(withdrawFeeConfig)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get withdraw fee", w)
return 0, fmt.Errorf("(%T) could not get withdraw fee: %w", w, err)
}
return fee, nil
@ -130,7 +130,7 @@ func (w *Wrapper) readUInt64Config(key string) (uint64, error) {
numeric, ok := v.(int64)
if !ok {
return 0, errors.Errorf("(%T) invalid value type %T", w, v)
return 0, fmt.Errorf("(%T) invalid value type %T", w, v)
}
return uint64(numeric), nil
@ -149,7 +149,7 @@ func (w *Wrapper) readStringConfig(key string) (string, error) {
str, ok := v.(string)
if !ok {
return "", errors.Errorf("(%T) invalid value type %T", w, v)
return "", fmt.Errorf("(%T) invalid value type %T", w, v)
}
return str, nil

5
pkg/morph/client/netmap/wrapper/epoch.go
View file

@ -1,8 +1,9 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
"github.com/pkg/errors"
)
// Epoch receives number of current NeoFS epoch
@ -12,7 +13,7 @@ func (w *Wrapper) Epoch() (uint64, error) {
vals, err := w.client.Epoch(args)
if err != nil {
return 0, errors.Wrapf(err, "(%T) could not get epoch number", w)
return 0, fmt.Errorf("(%T) could not get epoch number: %w", w, err)
}
return uint64(vals.Number()), nil

5
pkg/morph/client/netmap/wrapper/netmap.go
View file

@ -1,9 +1,10 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
client "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
"github.com/pkg/errors"
)
// GetNetMap receives information list about storage nodes
@ -43,7 +44,7 @@ func unmarshalNetmap(rawPeers [][]byte) (*netmap.Netmap, error) {
for _, peer := range rawPeers {
nodeInfo := netmap.NewNodeInfo()
if err := nodeInfo.Unmarshal(peer); err != nil {
return nil, errors.Wrap(err, "can't unmarshal peer info")
return nil, fmt.Errorf("can't unmarshal peer info: %w", err)
}
infos = append(infos, *nodeInfo)

13
pkg/morph/client/netmap/wrapper/update_state.go
View file

@ -1,9 +1,10 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
contract "github.com/nspcc-dev/neofs-node/pkg/morph/client/netmap"
"github.com/pkg/errors"
)
// UpdatePeerState changes peer status through Netmap contract
@ -14,10 +15,8 @@ func (w *Wrapper) UpdatePeerState(key []byte, state netmap.NodeState) error {
args.SetState(int64(state.ToV2()))
// invoke smart contract call
//
// Note: errors.Wrap returns nil on nil error arg.
return errors.Wrap(
w.client.UpdateState(args),
"could not invoke smart contract",
)
if err := w.client.UpdateState(args); err != nil {
return fmt.Errorf("could not invoke smart contract: %w", err)
}
return nil
}

21
pkg/morph/client/notary.go
View file

@ -1,6 +1,8 @@
package client
import (
"errors"
"fmt"
"strings"
"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
@ -13,7 +15,6 @@ import (
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
"github.com/nspcc-dev/neo-go/pkg/wallet"
"github.com/pkg/errors"
"go.uber.org/zap"
)
@ -74,7 +75,7 @@ func (c *Client) EnableNotarySupport(proxy util.Uint160, opts ...NotaryOption) e
notaryContract, err := c.client.GetNativeContractHash(nativenames.Notary)
if err != nil {
return errors.Wrap(err, "can't get notary contract script hash")
return fmt.Errorf("can't get notary contract script hash: %w", err)
}
c.notary = &notary{
@ -110,7 +111,7 @@ func (c *Client) DepositNotary(amount fixedn.Fixed8, delta uint32) (util.Uint256
bc, err := c.client.GetBlockCount()
if err != nil {
return util.Uint256{}, errors.Wrap(err, "can't get blockchain height")
return util.Uint256{}, fmt.Errorf("can't get blockchain height: %w", err)
}
txHash, err := c.client.TransferNEP17(
@ -123,7 +124,7 @@ func (c *Client) DepositNotary(amount fixedn.Fixed8, delta uint32) (util.Uint256
nil,
)
if err != nil {
return util.Uint256{}, errors.Wrap(err, "can't make notary deposit")
return util.Uint256{}, fmt.Errorf("can't make notary deposit: %w", err)
}
c.logger.Debug("notary deposit invoke",
@ -148,16 +149,16 @@ func (c *Client) GetNotaryDeposit() (int64, error) {
items, err := c.TestInvoke(c.notary.notary, notaryBalanceOfMethod, sh)
if err != nil {
return 0, errors.Wrap(err, notaryBalanceErrMsg)
return 0, fmt.Errorf("%v: %w", notaryBalanceErrMsg, err)
}
if len(items) != 1 {
return 0, errors.Wrap(errUnexpectedItems, notaryBalanceErrMsg)
return 0, fmt.Errorf("%v: %w", notaryBalanceErrMsg, errUnexpectedItems)
}
bigIntDeposit, err := items[0].TryInteger()
if err != nil {
return 0, errors.Wrap(err, notaryBalanceErrMsg)
return 0, fmt.Errorf("%v: %w", notaryBalanceErrMsg, err)
}
return bigIntDeposit.Int64(), nil
@ -328,7 +329,7 @@ func (c *Client) notaryCosigners(ir []*keys.PublicKey, committee bool) ([]transa
multisigScript, err := sc.CreateMultiSigRedeemScript(m, ir)
if err != nil {
return nil, errors.Wrap(err, "can't create ir multisig redeem script")
return nil, fmt.Errorf("can't create ir multisig redeem script: %w", err)
}
s = append(s, transaction.Signer{
@ -412,7 +413,7 @@ func (c *Client) notaryMultisigAccount(ir []*keys.PublicKey, committee bool) (*w
err := multisigAccount.ConvertMultisig(m, ir)
if err != nil {
return nil, errors.Wrap(err, "can't make inner ring multisig wallet")
return nil, fmt.Errorf("can't make inner ring multisig wallet: %w", err)
}
return multisigAccount, nil
@ -421,7 +422,7 @@ func (c *Client) notaryMultisigAccount(ir []*keys.PublicKey, committee bool) (*w
func (c *Client) notaryTxValidationLimit() (uint32, error) {
bc, err := c.client.GetBlockCount()
if err != nil {
return 0, errors.Wrap(err, "can't get current blockchain height")
return 0, fmt.Errorf("can't get current blockchain height: %w", err)
}
min := bc + c.notary.txValidTime

13
pkg/morph/client/reputation/get.go
View file

@ -1,9 +1,10 @@
package reputation
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// GetArgs groups the arguments of "get reputation value" test invocation.
@ -52,7 +53,7 @@ func (c *Client) Get(args GetArgs) (*GetResult, error) {
args.peerID,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.getMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.getMethod, err)
}
return parseReputations(prms, c.getMethod)
@ -66,7 +67,7 @@ func (c *Client) GetByID(args GetByIDArgs) (*GetResult, error) {
args.id,
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.getByIDMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.getByIDMethod, err)
}
return parseReputations(prms, c.getByIDMethod)
@ -74,12 +75,12 @@ func (c *Client) GetByID(args GetByIDArgs) (*GetResult, error) {
func parseReputations(items []stackitem.Item, method string) (*GetResult, error) {
if ln := len(items); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", method, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", method, ln)
}
items, err := client.ArrayFromStackItem(items[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get stack item array from stack item (%s)", method)
return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", method, err)
}
res := &GetResult{
@ -89,7 +90,7 @@ func parseReputations(items []stackitem.Item, method string) (*GetResult, error)
for i := range items {
rawReputation, err := client.BytesFromStackItem(items[i])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array from stack item (%s)", method)
return nil, fmt.Errorf("could not get byte array from stack item (%s): %w", method, err)
}
res.reputations = append(res.reputations, rawReputation)

11
pkg/morph/client/reputation/list.go
View file

@ -1,8 +1,9 @@
package reputation
import (
"fmt"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/pkg/errors"
)
// ListByEpochArgs groups the arguments of
@ -35,14 +36,14 @@ func (c *Client) ListByEpoch(args ListByEpochArgs) (*ListByEpochResult, error) {
int64(args.epoch),
)
if err != nil {
return nil, errors.Wrapf(err, "could not perform test invocation (%s)", c.listByEpochMethod)
return nil, fmt.Errorf("could not perform test invocation (%s): %w", c.listByEpochMethod, err)
} else if ln := len(prms); ln != 1 {
return nil, errors.Errorf("unexpected stack item count (%s): %d", c.listByEpochMethod, ln)
return nil, fmt.Errorf("unexpected stack item count (%s): %d", c.listByEpochMethod, ln)
}
items, err := client.ArrayFromStackItem(prms[0])
if err != nil {
return nil, errors.Wrapf(err, "could not get stack item array from stack item (%s)", c.listByEpochMethod)
return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", c.listByEpochMethod, err)
}
res := &ListByEpochResult{
@ -52,7 +53,7 @@ func (c *Client) ListByEpoch(args ListByEpochArgs) (*ListByEpochResult, error) {
for i := range items {
rawReputation, err := client.BytesFromStackItem(items[i])
if err != nil {
return nil, errors.Wrapf(err, "could not get byte array from stack item (%s)", c.listByEpochMethod)
return nil, fmt.Errorf("could not get byte array from stack item (%s): %w", c.listByEpochMethod, err)
}
res.ids = append(res.ids, rawReputation)

20
pkg/morph/client/reputation/put.go
View file

@ -1,7 +1,7 @@
package reputation
import (
"github.com/pkg/errors"
"fmt"
)
// PutArgs groups the arguments of "put reputation value" invocation call.
@ -28,21 +28,31 @@ func (p *PutArgs) SetValue(v []byte) {
// Put invokes direct call of "put reputation value" method of reputation contract.
func (c *Client) Put(args PutArgs) error {
return errors.Wrapf(c.client.Invoke(
err := c.client.Invoke(
c.putMethod,
int64(args.epoch),
args.peerID,
args.value,
), "could not invoke method (%s)", c.putMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.putMethod, err)
}
return nil
}
// PutViaNotary invokes notary call of "put reputation value" method of
// reputation contract.
func (c *Client) PutViaNotary(args PutArgs) error {
return errors.Wrapf(c.client.NotaryInvoke(
err := c.client.NotaryInvoke(
c.putMethod,
int64(args.epoch),
args.peerID,
args.value,
), "could not invoke method (%s)", c.putMethod)
)
if err != nil {
return fmt.Errorf("could not invoke method (%s): %w", c.putMethod, err)
}
return err
}

5
pkg/morph/client/reputation/wrapper/get.go
View file

@ -1,9 +1,10 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/reputation"
reputationClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/reputation"
"github.com/pkg/errors"
)
type (
@ -83,7 +84,7 @@ func parseGetResult(data *reputationClient.GetResult) (*GetResult, error) {
err := r.Unmarshal(rawReputations[i])
if err != nil {
return nil, errors.Wrap(err, "can't unmarshal global trust value")
return nil, fmt.Errorf("can't unmarshal global trust value: %w", err)
}
reputations = append(reputations, r)

5
pkg/morph/client/reputation/wrapper/put.go
View file

@ -1,9 +1,10 @@
package wrapper
import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/pkg/reputation"
reputationClient "github.com/nspcc-dev/neofs-node/pkg/morph/client/reputation"
"github.com/pkg/errors"
)
type (
@ -56,7 +57,7 @@ func preparePutArgs(v PutArgs) (reputationClient.PutArgs, error) {
data, err := v.value.Marshal()
if err != nil {
return args, errors.Wrap(err, "can't marshal global trust value")
return args, fmt.Errorf("can't marshal global trust value: %w", err)
}
args.SetEpoch(v.epoch)

Some files were not shown because too many files have changed in this diff Show more