diff --git a/cmd/neofs-node/reputation.go b/cmd/neofs-node/reputation.go
index 78192ae21..2b097ae03 100644
--- a/cmd/neofs-node/reputation.go
+++ b/cmd/neofs-node/reputation.go
@@ -1,22 +1,14 @@
package main
import (
- "bytes"
"context"
- "crypto/ecdsa"
- "encoding/hex"
- "github.com/nspcc-dev/hrw"
- apiClient "github.com/nspcc-dev/neofs-api-go/pkg/client"
- apiNetmap "github.com/nspcc-dev/neofs-api-go/pkg/netmap"
- reputationapi "github.com/nspcc-dev/neofs-api-go/pkg/reputation"
v2reputation "github.com/nspcc-dev/neofs-api-go/v2/reputation"
v2reputationgrpc "github.com/nspcc-dev/neofs-api-go/v2/reputation/grpc"
crypto "github.com/nspcc-dev/neofs-crypto"
- netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
+ localreputation "github.com/nspcc-dev/neofs-node/cmd/neofs-node/reputation/local"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
"github.com/nspcc-dev/neofs-node/pkg/morph/event/netmap"
- "github.com/nspcc-dev/neofs-node/pkg/network"
"github.com/nspcc-dev/neofs-node/pkg/network/cache"
grpcreputation "github.com/nspcc-dev/neofs-node/pkg/network/transport/reputation/grpc"
"github.com/nspcc-dev/neofs-node/pkg/services/reputation"
@@ -31,272 +23,38 @@ import (
"go.uber.org/zap"
)
-type localTrustStorage struct {
- log *logger.Logger
-
- storage *truststorage.Storage
-
- nmSrc netmapcore.Source
-
- localKey []byte
-}
-
-type localTrustIterator struct {
- ctx reputationcommon.Context
-
- storage *localTrustStorage
-
- epochStorage *truststorage.EpochTrustValueStorage
-}
-
-type managerBuilder struct {
- log *logger.Logger
- nmSrc netmapcore.Source
-}
-
-type remoteLocalTrustProvider struct {
- localAddrSrc network.LocalAddressSource
- deadEndProvider reputationcommon.WriterProvider
- key *ecdsa.PrivateKey
-
- clientCache interface {
- Get(string) (apiClient.Client, error)
- }
-}
-
-type nopReputationWriter struct{}
-
-func (nopReputationWriter) Write(reputation.Trust) error {
- return nil
-}
-
-func (nopReputationWriter) Close() error {
- return nil
-}
-
-type remoteLocalTrustWriter struct {
- ctx reputationcommon.Context
- client apiClient.Client
- key *ecdsa.PrivateKey
-
- buf []*reputationapi.Trust
-}
-
-func (rtp *remoteLocalTrustWriter) Write(t reputation.Trust) error {
- apiTrust := reputationapi.NewTrust()
-
- apiPeer := reputationapi.NewPeerID()
- apiPeer.SetPublicKey(t.Peer())
-
- apiTrust.SetValue(t.Value().Float64())
- apiTrust.SetPeer(apiPeer)
-
- rtp.buf = append(rtp.buf, apiTrust)
-
- return nil
-}
-
-func (rtp *remoteLocalTrustWriter) Close() error {
- prm := apiClient.SendLocalTrustPrm{}
-
- prm.SetEpoch(rtp.ctx.Epoch())
- prm.SetTrusts(rtp.buf)
-
- _, err := rtp.client.SendLocalTrust(
- rtp.ctx,
- prm,
- apiClient.WithKey(rtp.key),
- )
-
- return err
-}
-
-type remoteLocalTrustWriterProvider struct {
- client apiClient.Client
- key *ecdsa.PrivateKey
-}
-
-type localTrustLogger struct {
- ctx reputationcommon.Context
-
- log *logger.Logger
-}
-
-func (l *localTrustLogger) Write(t reputation.Trust) error {
- l.log.Info("received local trust",
- zap.Uint64("epoch", l.ctx.Epoch()),
- zap.String("peer", hex.EncodeToString(t.Peer().Bytes())),
- zap.Stringer("value", t.Value()),
- )
-
- return nil
-}
-
-func (*localTrustLogger) Close() error {
- return nil
-}
-
-func (rtwp *remoteLocalTrustWriterProvider) InitWriter(ctx reputationcommon.Context) (reputationcommon.Writer, error) {
- return &remoteLocalTrustWriter{
- ctx: ctx,
- client: rtwp.client,
- key: rtwp.key,
- }, nil
-}
-
-func (rtp *remoteLocalTrustProvider) InitRemote(srv reputationrouter.ServerInfo) (reputationcommon.WriterProvider, error) {
- if srv == nil {
- return rtp.deadEndProvider, nil
- }
-
- addr := srv.Address()
-
- if rtp.localAddrSrc.LocalAddress().String() == srv.Address() {
- // if local => return no-op writer
- return trustcontroller.SimpleWriterProvider(new(nopReputationWriter)), nil
- }
-
- ipAddr, err := network.IPAddrFromMultiaddr(addr)
- if err != nil {
- return nil, errors.Wrap(err, "could not convert address to IP format")
- }
-
- c, err := rtp.clientCache.Get(ipAddr)
- if err != nil {
- return nil, errors.Wrap(err, "could not initialize API client")
- }
-
- return &remoteLocalTrustWriterProvider{
- client: c,
- key: rtp.key,
- }, nil
-}
-
-// BuildManagers sorts nodes in NetMap with HRW algorithms and
-// takes the next node after the current one as the only manager.
-func (mb *managerBuilder) BuildManagers(epoch uint64, p reputation.PeerID) ([]reputationrouter.ServerInfo, error) {
- nm, err := mb.nmSrc.GetNetMapByEpoch(epoch)
- if err != nil {
- return nil, err
- }
-
- // make a copy to keep order consistency of the origin netmap after sorting
- nodes := make([]*apiNetmap.Node, len(nm.Nodes))
-
- copy(nodes, nm.Nodes)
-
- hrw.SortSliceByValue(nodes, epoch)
-
- for i := range nodes {
- if bytes.Equal(nodes[i].PublicKey(), p.Bytes()) {
- managerIndex := i + 1
-
- if managerIndex == len(nodes) {
- managerIndex = 0
- }
-
- return []reputationrouter.ServerInfo{nodes[managerIndex]}, nil
- }
- }
-
- return nil, nil
-}
-
-func (s *localTrustStorage) InitIterator(ctx reputationcommon.Context) (trustcontroller.Iterator, error) {
- epochStorage, err := s.storage.DataForEpoch(ctx.Epoch())
- if err != nil && !errors.Is(err, truststorage.ErrNoPositiveTrust) {
- return nil, err
- }
-
- return &localTrustIterator{
- ctx: ctx,
- storage: s,
- epochStorage: epochStorage,
- }, nil
-}
-
-func (s *localTrustStorage) InitWriter(ctx reputationcommon.Context) (reputationcommon.Writer, error) {
- return &localTrustLogger{
- ctx: ctx,
- log: s.log,
- }, nil
-}
-
-func (it *localTrustIterator) Iterate(h reputation.TrustHandler) error {
- if it.epochStorage != nil {
- err := it.epochStorage.Iterate(h)
- if !errors.Is(err, truststorage.ErrNoPositiveTrust) {
- return err
- }
- }
-
- nm, err := it.storage.nmSrc.GetNetMapByEpoch(it.ctx.Epoch())
- if err != nil {
- return err
- }
-
- // find out if local node is presented in netmap
- localIndex := -1
-
- for i := range nm.Nodes {
- if bytes.Equal(nm.Nodes[i].PublicKey(), it.storage.localKey) {
- localIndex = i
- }
- }
-
- ln := len(nm.Nodes)
- if localIndex >= 0 && ln > 0 {
- ln--
- }
-
- // calculate Pj http://ilpubs.stanford.edu:8090/562/1/2002-56.pdf Chapter 4.5.
- p := reputation.TrustOne.Div(reputation.TrustValueFromInt(ln))
-
- for i := range nm.Nodes {
- if i == localIndex {
- continue
- }
-
- trust := reputation.Trust{}
- trust.SetPeer(reputation.PeerIDFromBytes(nm.Nodes[i].PublicKey()))
- trust.SetValue(p)
-
- if err := h(trust); err != nil {
- return err
- }
- }
-
- return nil
-}
-
func initReputationService(c *cfg) {
// consider sharing this between application components
nmSrc := newCachedNetmapStorage(c.cfgNetmap.state, c.cfgNetmap.wrapper)
c.cfgReputation.localTrustStorage = truststorage.New(truststorage.Prm{})
- trustStorage := &localTrustStorage{
- log: c.log,
- storage: c.cfgReputation.localTrustStorage,
- nmSrc: nmSrc,
- localKey: crypto.MarshalPublicKey(&c.key.PublicKey),
+ trustStorage := &localreputation.TrustStorage{
+ Log: c.log,
+ Storage: c.cfgReputation.localTrustStorage,
+ NmSrc: nmSrc,
+ LocalKey: crypto.MarshalPublicKey(&c.key.PublicKey),
}
- managerBuilder := &managerBuilder{
- log: c.log,
- nmSrc: nmSrc,
- }
+ managerBuilder := localreputation.NewManagerBuilder(
+ localreputation.ManagersPrm{
+ NetMapSource: nmSrc,
+ },
+ localreputation.WithLogger(c.log),
+ )
routeBuilder := managers.New(managers.Prm{
ManagerBuilder: managerBuilder,
})
- remoteLocalTrustProvider := &remoteLocalTrustProvider{
- localAddrSrc: c,
- deadEndProvider: trustStorage,
- clientCache: cache.NewSDKClientCache(),
- key: c.key,
- }
+ remoteLocalTrustProvider := localreputation.NewRemoteTrustProvider(
+ localreputation.RemoteProviderPrm{
+ LocalAddrSrc: c,
+ DeadEndProvider: trustStorage,
+ ClientCache: cache.NewSDKClientCache(),
+ Key: c.key,
+ },
+ )
router := reputationrouter.New(
reputationrouter.Prm{
@@ -367,33 +125,12 @@ type reputationServer struct {
routeBuilder reputationrouter.Builder
}
-type epochContext struct {
- context.Context
- epoch uint64
-}
-
-func (ctx *epochContext) Epoch() uint64 {
- return ctx.epoch
-}
-
-type reputationOnlyKeyRemoteServerInfo struct {
- key []byte
-}
-
-func (i *reputationOnlyKeyRemoteServerInfo) PublicKey() []byte {
- return i.key
-}
-
-func (*reputationOnlyKeyRemoteServerInfo) Address() string {
- return ""
-}
-
func (s *reputationServer) SendLocalTrust(ctx context.Context, req *v2reputation.SendLocalTrustRequest) (*v2reputation.SendLocalTrustResponse, error) {
var passedRoute []reputationrouter.ServerInfo
for hdr := req.GetVerificationHeader(); hdr != nil; hdr = hdr.GetOrigin() {
- passedRoute = append(passedRoute, &reputationOnlyKeyRemoteServerInfo{
- key: hdr.GetBodySignature().GetKey(),
+ passedRoute = append(passedRoute, &localreputation.OnlyKeyRemoteServerInfo{
+ Key: hdr.GetBodySignature().GetKey(),
})
}
@@ -405,9 +142,9 @@ func (s *reputationServer) SendLocalTrust(ctx context.Context, req *v2reputation
body := req.GetBody()
- eCtx := &epochContext{
+ eCtx := &localreputation.EpochContext{
Context: ctx,
- epoch: body.GetEpoch(),
+ E: body.GetEpoch(),
}
w, err := s.router.InitWriter(reputationrouter.NewRouteContext(eCtx, passedRoute))
diff --git a/cmd/neofs-node/reputation/local/managers.go b/cmd/neofs-node/reputation/local/managers.go
new file mode 100644
index 000000000..b38ccd338
--- /dev/null
+++ b/cmd/neofs-node/reputation/local/managers.go
@@ -0,0 +1,106 @@
+package local
+
+import (
+ "bytes"
+
+ "github.com/nspcc-dev/hrw"
+ apiNetmap "github.com/nspcc-dev/neofs-api-go/pkg/netmap"
+ netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
+ "github.com/nspcc-dev/neofs-node/pkg/services/reputation"
+ reputationrouter "github.com/nspcc-dev/neofs-node/pkg/services/reputation/common/router"
+ "github.com/nspcc-dev/neofs-node/pkg/services/reputation/local/managers"
+ "github.com/nspcc-dev/neofs-node/pkg/util/logger"
+ "go.uber.org/zap"
+)
+
+// managerBuilder is implementation of reputation ManagerBuilder interface.
+// It sorts nodes in NetMap with HRW algorithms and
+// takes the next node after the current one as the only manager.
+type managerBuilder struct {
+ log *logger.Logger
+ nmSrc netmapcore.Source
+}
+
+// ManagersPrm groups the required parameters of the managerBuilder's constructor.
+//
+// All values must comply with the requirements imposed on them.
+// Passing incorrect parameter values will result in constructor
+// failure (error or panic depending on the implementation).
+type ManagersPrm struct {
+ NetMapSource netmapcore.Source
+}
+
+// NewManagerBuilder creates a new instance of the managerBuilder.
+//
+// Panics if at least one value of the parameters is invalid.
+//
+// The created managerBuilder does not require additional
+// initialization and is completely ready for work.
+func NewManagerBuilder(prm ManagersPrm, opts ...MngOption) managers.ManagerBuilder {
+ switch {
+ case prm.NetMapSource == nil:
+ panicOnPrmValue("NetMapSource", prm.NetMapSource)
+ }
+
+ o := defaultMngOpts()
+
+ for i := range opts {
+ opts[i](o)
+ }
+
+ return &managerBuilder{
+ log: o.log,
+ nmSrc: prm.NetMapSource,
+ }
+}
+
+// BuildManagers sorts nodes in NetMap with HRW algorithms and
+// takes the next node after the current one as the only manager.
+func (mb *managerBuilder) BuildManagers(epoch uint64, p reputation.PeerID) ([]reputationrouter.ServerInfo, error) {
+ nm, err := mb.nmSrc.GetNetMapByEpoch(epoch)
+ if err != nil {
+ return nil, err
+ }
+
+ // make a copy to keep order consistency of the origin netmap after sorting
+ nodes := make([]*apiNetmap.Node, len(nm.Nodes))
+
+ copy(nodes, nm.Nodes)
+
+ hrw.SortSliceByValue(nodes, epoch)
+
+ for i := range nodes {
+ if bytes.Equal(nodes[i].PublicKey(), p.Bytes()) {
+ managerIndex := i + 1
+
+ if managerIndex == len(nodes) {
+ managerIndex = 0
+ }
+
+ return []reputationrouter.ServerInfo{nodes[managerIndex]}, nil
+ }
+ }
+
+ return nil, nil
+}
+
+type mngOptions struct {
+ log *logger.Logger
+}
+
+type MngOption func(*mngOptions)
+
+func defaultMngOpts() *mngOptions {
+ return &mngOptions{
+ log: zap.L(),
+ }
+}
+
+// WithLogger returns MngOption to specify logging component.
+func WithLogger(l *logger.Logger) MngOption {
+ return func(o *mngOptions) {
+ if l != nil {
+ o.log = l
+ }
+ }
+}
diff --git a/cmd/neofs-node/reputation/local/remote.go b/cmd/neofs-node/reputation/local/remote.go
new file mode 100644
index 000000000..c760f7952
--- /dev/null
+++ b/cmd/neofs-node/reputation/local/remote.go
@@ -0,0 +1,137 @@
+package local
+
+import (
+ "crypto/ecdsa"
+
+ apiClient "github.com/nspcc-dev/neofs-api-go/pkg/client"
+ reputationapi "github.com/nspcc-dev/neofs-api-go/pkg/reputation"
+ "github.com/nspcc-dev/neofs-node/pkg/network"
+ "github.com/nspcc-dev/neofs-node/pkg/services/reputation"
+ 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 {
+ Get(string) (apiClient.Client, error)
+}
+
+// remoteTrustProvider is implementation of reputation RemoteWriterProvider interface.
+type remoteTrustProvider struct {
+ localAddrSrc network.LocalAddressSource
+ deadEndProvider reputationcommon.WriterProvider
+ key *ecdsa.PrivateKey
+
+ clientCache clientCache
+}
+
+// RemoteProviderPrm groups the required parameters of the remoteTrustProvider's constructor.
+//
+// All values must comply with the requirements imposed on them.
+// Passing incorrect parameter values will result in constructor
+// failure (error or panic depending on the implementation).
+type RemoteProviderPrm struct {
+ LocalAddrSrc network.LocalAddressSource
+ DeadEndProvider reputationcommon.WriterProvider
+ Key *ecdsa.PrivateKey
+ ClientCache clientCache
+}
+
+func NewRemoteTrustProvider(prm RemoteProviderPrm) reputationrouter.RemoteWriterProvider {
+ switch {
+ case prm.LocalAddrSrc == nil:
+ panicOnPrmValue("LocalAddrSrc", prm.LocalAddrSrc)
+ case prm.DeadEndProvider == nil:
+ panicOnPrmValue("DeadEndProvider", prm.DeadEndProvider)
+ case prm.Key == nil:
+ panicOnPrmValue("Key", prm.Key)
+ case prm.ClientCache == nil:
+ panicOnPrmValue("ClientCache", prm.ClientCache)
+ }
+
+ return &remoteTrustProvider{
+ localAddrSrc: prm.LocalAddrSrc,
+ deadEndProvider: prm.DeadEndProvider,
+ key: prm.Key,
+ clientCache: prm.ClientCache,
+ }
+}
+
+func (rtp *remoteTrustProvider) InitRemote(srv reputationrouter.ServerInfo) (reputationcommon.WriterProvider, error) {
+ if srv == nil {
+ return rtp.deadEndProvider, nil
+ }
+
+ addr := srv.Address()
+
+ if rtp.localAddrSrc.LocalAddress().String() == srv.Address() {
+ // if local => return no-op writer
+ return trustcontroller.SimpleWriterProvider(new(NopReputationWriter)), nil
+ }
+
+ ipAddr, err := network.IPAddrFromMultiaddr(addr)
+ if err != nil {
+ return nil, errors.Wrap(err, "could not convert address to IP format")
+ }
+
+ c, err := rtp.clientCache.Get(ipAddr)
+ if err != nil {
+ return nil, errors.Wrap(err, "could not initialize API client")
+ }
+
+ return &RemoteTrustWriterProvider{
+ client: c,
+ key: rtp.key,
+ }, nil
+}
+
+type RemoteTrustWriterProvider struct {
+ client apiClient.Client
+ key *ecdsa.PrivateKey
+}
+
+func (rtwp *RemoteTrustWriterProvider) InitWriter(ctx reputationcommon.Context) (reputationcommon.Writer, error) {
+ return &RemoteTrustWriter{
+ ctx: ctx,
+ client: rtwp.client,
+ key: rtwp.key,
+ }, nil
+}
+
+type RemoteTrustWriter struct {
+ ctx reputationcommon.Context
+ client apiClient.Client
+ key *ecdsa.PrivateKey
+
+ buf []*reputationapi.Trust
+}
+
+func (rtp *RemoteTrustWriter) Write(t reputation.Trust) error {
+ apiTrust := reputationapi.NewTrust()
+
+ apiPeer := reputationapi.NewPeerID()
+ apiPeer.SetPublicKey(t.Peer())
+
+ apiTrust.SetValue(t.Value().Float64())
+ apiTrust.SetPeer(apiPeer)
+
+ rtp.buf = append(rtp.buf, apiTrust)
+
+ return nil
+}
+
+func (rtp *RemoteTrustWriter) Close() error {
+ prm := apiClient.SendLocalTrustPrm{}
+
+ prm.SetEpoch(rtp.ctx.Epoch())
+ prm.SetTrusts(rtp.buf)
+
+ _, err := rtp.client.SendLocalTrust(
+ rtp.ctx,
+ prm,
+ apiClient.WithKey(rtp.key),
+ )
+
+ return err
+}
diff --git a/cmd/neofs-node/reputation/local/storage.go b/cmd/neofs-node/reputation/local/storage.go
new file mode 100644
index 000000000..c12df4d73
--- /dev/null
+++ b/cmd/neofs-node/reputation/local/storage.go
@@ -0,0 +1,120 @@
+package local
+
+import (
+ "bytes"
+ "encoding/hex"
+
+ netmapcore "github.com/nspcc-dev/neofs-node/pkg/core/netmap"
+ "github.com/nspcc-dev/neofs-node/pkg/services/reputation"
+ reputationcommon "github.com/nspcc-dev/neofs-node/pkg/services/reputation/common"
+ 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"
+ "go.uber.org/zap"
+)
+
+type TrustStorage struct {
+ Log *logger.Logger
+
+ Storage *truststorage.Storage
+
+ NmSrc netmapcore.Source
+
+ LocalKey []byte
+}
+
+func (s *TrustStorage) InitIterator(ctx reputationcommon.Context) (trustcontroller.Iterator, error) {
+ epochStorage, err := s.Storage.DataForEpoch(ctx.Epoch())
+ if err != nil && !errors.Is(err, truststorage.ErrNoPositiveTrust) {
+ return nil, err
+ }
+
+ return &TrustIterator{
+ ctx: ctx,
+ storage: s,
+ epochStorage: epochStorage,
+ }, nil
+}
+
+func (s *TrustStorage) InitWriter(ctx reputationcommon.Context) (reputationcommon.Writer, error) {
+ return &TrustLogger{
+ ctx: ctx,
+ log: s.Log,
+ }, nil
+}
+
+type TrustIterator struct {
+ ctx reputationcommon.Context
+
+ storage *TrustStorage
+
+ epochStorage *truststorage.EpochTrustValueStorage
+}
+
+func (it *TrustIterator) Iterate(h reputation.TrustHandler) error {
+ if it.epochStorage != nil {
+ err := it.epochStorage.Iterate(h)
+ if !errors.Is(err, truststorage.ErrNoPositiveTrust) {
+ return err
+ }
+ }
+
+ nm, err := it.storage.NmSrc.GetNetMapByEpoch(it.ctx.Epoch())
+ if err != nil {
+ return err
+ }
+
+ // find out if local node is presented in netmap
+ localIndex := -1
+
+ for i := range nm.Nodes {
+ if bytes.Equal(nm.Nodes[i].PublicKey(), it.storage.LocalKey) {
+ localIndex = i
+ }
+ }
+
+ ln := len(nm.Nodes)
+ if localIndex >= 0 && ln > 0 {
+ ln--
+ }
+
+ // calculate Pj http://ilpubs.stanford.edu:8090/562/1/2002-56.pdf Chapter 4.5.
+ p := reputation.TrustOne.Div(reputation.TrustValueFromInt(ln))
+
+ for i := range nm.Nodes {
+ if i == localIndex {
+ continue
+ }
+
+ trust := reputation.Trust{}
+ trust.SetPeer(reputation.PeerIDFromBytes(nm.Nodes[i].PublicKey()))
+ trust.SetValue(p)
+
+ if err := h(trust); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+type TrustLogger struct {
+ ctx reputationcommon.Context
+
+ log *logger.Logger
+}
+
+func (l *TrustLogger) Write(t reputation.Trust) error {
+ l.log.Info("received local trust",
+ zap.Uint64("epoch", l.ctx.Epoch()),
+ zap.String("peer", hex.EncodeToString(t.Peer().Bytes())),
+ zap.Stringer("value", t.Value()),
+ )
+
+ return nil
+}
+
+func (*TrustLogger) Close() error {
+ return nil
+}
diff --git a/cmd/neofs-node/reputation/local/util.go b/cmd/neofs-node/reputation/local/util.go
new file mode 100644
index 000000000..2f030153e
--- /dev/null
+++ b/cmd/neofs-node/reputation/local/util.go
@@ -0,0 +1,45 @@
+package local
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/nspcc-dev/neofs-node/pkg/services/reputation"
+)
+
+type EpochContext struct {
+ context.Context
+ E uint64
+}
+
+func (ctx *EpochContext) Epoch() uint64 {
+ return ctx.E
+}
+
+type NopReputationWriter struct{}
+
+func (NopReputationWriter) Write(reputation.Trust) error {
+ return nil
+}
+
+func (NopReputationWriter) Close() error {
+ return nil
+}
+
+type OnlyKeyRemoteServerInfo struct {
+ Key []byte
+}
+
+func (i *OnlyKeyRemoteServerInfo) PublicKey() []byte {
+ return i.Key
+}
+
+func (*OnlyKeyRemoteServerInfo) Address() string {
+ return ""
+}
+
+const invalidPrmValFmt = "invalid parameter %s (%T):%v"
+
+func panicOnPrmValue(n string, v interface{}) {
+ panic(fmt.Sprintf(invalidPrmValFmt, n, v, v))
+}