[#488] reputation/eigentrust/calculator: Implement calc wrapper

Signed-off-by: Pavel Karpy <carpawell@nspcc.ru>

cmd/neofs-node/reputation/intermediate/calculator.go

@@ -0,0 +1,27 @@
+package intermediate
+
+import (
+	"github.com/nspcc-dev/neofs-node/pkg/services/reputation/eigentrust"
+	eigencalc "github.com/nspcc-dev/neofs-node/pkg/services/reputation/eigentrust/calculator"
+	eigentrustctrl "github.com/nspcc-dev/neofs-node/pkg/services/reputation/eigentrust/controller"
+)
+
+// DaughtersTrustCalculator wraps EigenTrust calculator and implements
+// eigentrust/calculator's DaughtersTrustCalculator interface.
+type DaughtersTrustCalculator struct {
+	Calculator *eigencalc.Calculator
+}
+
+// Calculate converts and passes values to wrapped calculator.
+func (c *DaughtersTrustCalculator) Calculate(ctx eigentrustctrl.IterationContext) {
+	calcPrm := eigencalc.CalculatePrm{}
+	epochIteration := eigentrust.EpochIteration{}
+
+	epochIteration.SetEpoch(ctx.Epoch())
+	epochIteration.SetI(ctx.I())
+
+	calcPrm.SetLast(ctx.Last())
+	calcPrm.SetEpochIteration(epochIteration)
+
+	c.Calculator.Calculate(calcPrm)
+}

cmd/neofs-node/reputation/intermediate/consumers.go

@@ -2,7 +2,6 @@ package intermediate
 
 import (
 	"errors"
-	"fmt"
 
 	"github.com/nspcc-dev/neofs-node/pkg/services/reputation"
 	"github.com/nspcc-dev/neofs-node/pkg/services/reputation/common"
@@ -36,7 +35,6 @@ func (w *ConsumerTrustWriter) Write(ctx common.Context, t reputation.Trust) erro
 	trust.SetEpoch(eiCtx.Epoch())
 	trust.SetI(eiCtx.I())
 
-	fmt.Println("decided to save consumers trusts to storage for epoch and iteration: ", eiCtx.Epoch(), eiCtx.I())
 	w.storage.Put(trust)
 	return nil
 }

cmd/neofs-node/reputation/intermediate/contract.go

@@ -0,0 +1,143 @@
+package intermediate
+
+import (
+	"crypto/ecdsa"
+	"fmt"
+
+	apireputation "github.com/nspcc-dev/neofs-api-go/pkg/reputation"
+	"github.com/nspcc-dev/neofs-node/pkg/morph/client/reputation/wrapper"
+	"github.com/nspcc-dev/neofs-node/pkg/services/reputation/eigentrust"
+	eigentrustcalc "github.com/nspcc-dev/neofs-node/pkg/services/reputation/eigentrust/calculator"
+	"github.com/nspcc-dev/neofs-node/pkg/util/logger"
+	"go.uber.org/zap"
+)
+
+// FinalWriterProviderPrm groups the required parameters of the FinalWriterProvider'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 FinalWriterProviderPrm struct {
+	PrivatKey *ecdsa.PrivateKey
+	PubKey    []byte
+	Client    *wrapper.ClientWrapper
+}
+
+// NewFinalWriterProvider creates a new instance of the FinalWriterProvider.
+//
+// Panics if at least one value of the parameters is invalid.
+//
+// The created FinalWriterProvider does not require additional
+// initialization and is completely ready for work.
+func NewFinalWriterProvider(prm FinalWriterProviderPrm, opts ...FinalWriterOption) *FinalWriterProvider {
+	o := defaultFinalWriterOptionsOpts()
+
+	for i := range opts {
+		opts[i](o)
+	}
+
+	return &FinalWriterProvider{
+		prm:  prm,
+		opts: o,
+	}
+}
+
+type FinalWriterProvider struct {
+	prm  FinalWriterProviderPrm
+	opts *finalWriterOptions
+}
+
+func (fwp FinalWriterProvider) InitIntermediateWriter(
+	_ eigentrustcalc.Context) (eigentrustcalc.IntermediateWriter, error) {
+	return &FinalWriter{
+		privatKey: fwp.prm.PrivatKey,
+		pubKey:    fwp.prm.PubKey,
+		client:    fwp.prm.Client,
+		l:         fwp.opts.log,
+	}, nil
+
+}
+
+type FinalWriter struct {
+	privatKey *ecdsa.PrivateKey
+	pubKey    []byte
+	client    *wrapper.ClientWrapper
+
+	l *logger.Logger
+}
+
+func (fw FinalWriter) WriteIntermediateTrust(t eigentrust.IterationTrust) error {
+	args := wrapper.PutArgs{}
+
+	var trustedPublicKey [33]byte
+	copy(trustedPublicKey[:], t.Peer().Bytes())
+
+	apiTrustedPeerID := apireputation.NewPeerID()
+	apiTrustedPeerID.SetPublicKey(trustedPublicKey)
+
+	apiTrust := apireputation.NewTrust()
+	apiTrust.SetValue(t.Value().Float64())
+	apiTrust.SetPeer(apiTrustedPeerID)
+
+	var managerPublicKey [33]byte
+	copy(managerPublicKey[:], fw.pubKey)
+
+	apiMangerPeerID := apireputation.NewPeerID()
+	apiMangerPeerID.SetPublicKey(managerPublicKey)
+
+	gTrust := apireputation.NewGlobalTrust()
+	gTrust.SetTrust(apiTrust)
+	gTrust.SetManager(apiMangerPeerID)
+
+	err := gTrust.Sign(fw.privatKey)
+	if err != nil {
+		fw.l.Debug(
+			"failed to sign global trust",
+			zap.Error(err),
+		)
+		return fmt.Errorf("failed to sign global trust: %w", err)
+	}
+
+	args.SetEpoch(t.Epoch())
+	args.SetValue(*gTrust)
+	args.SetPeerID(*apiTrustedPeerID)
+
+	err = fw.client.Put(
+		args,
+	)
+	if err != nil {
+		fw.l.Debug(
+			"failed to write global trust to contract",
+			zap.Error(err),
+		)
+		return fmt.Errorf("failed to write global trust to contract: %w", err)
+	}
+
+	fw.l.Debug(
+		"sent global trust to contract",
+		zap.Uint64("epoch", t.Epoch()),
+		zap.Float64("value", t.Value().Float64()),
+	)
+
+	return nil
+}
+
+type finalWriterOptions struct {
+	log *logger.Logger
+}
+
+type FinalWriterOption func(*finalWriterOptions)
+
+func defaultFinalWriterOptionsOpts() *finalWriterOptions {
+	return &finalWriterOptions{
+		log: zap.L(),
+	}
+}
+
+func FinalWriterWithLogger(l *logger.Logger) FinalWriterOption {
+	return func(o *finalWriterOptions) {
+		if l != nil {
+			o.log = l
+		}
+	}
+}

cmd/neofs-node/reputation/intermediate/remote.go

@@ -2,6 +2,7 @@ package intermediate
 
 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/cmd/neofs-node/reputation/common"

cmd/neofs-node/reputation/intermediate/storage.go

@@ -21,8 +21,8 @@ func (i InitialTrustSource) InitialTrust(reputation.PeerID) (reputation.TrustVal
 // DaughterTrustIteratorProvider is implementation of the
 // reputation/eigentrust/calculator's DaughterTrustIteratorProvider interface.
 type DaughterTrustIteratorProvider struct {
-	daughterStorage *daughters.Storage
-	consumerStorage *consumerstorage.Storage
+	DaughterStorage *daughters.Storage
+	ConsumerStorage *consumerstorage.Storage
 }
 
 type ErrNoData struct {
@@ -46,7 +46,7 @@ func (e *ErrNoData) Error() string {
 // specified epoch and daughter's PeerId.
 func (ip *DaughterTrustIteratorProvider) InitDaughterIterator(ctx eigentrustcalc.Context,
 	p reputation.PeerID) (eigentrustcalc.TrustIterator, error) {
-	daughterIterator, ok := ip.daughterStorage.DaughterTrusts(ctx.Epoch(), p)
+	daughterIterator, ok := ip.DaughterStorage.DaughterTrusts(ctx.Epoch(), p)
 	if !ok {
 		return nil, &ErrNoData{
 			daughter:    p,
@@ -66,7 +66,7 @@ func (ip *DaughterTrustIteratorProvider) InitDaughterIterator(ctx eigentrustcalc
 // specified epoch.
 func (ip *DaughterTrustIteratorProvider) InitAllDaughtersIterator(
 	ctx eigentrustcalc.Context) (eigentrustcalc.PeerTrustsIterator, error) {
-	iter, ok := ip.daughterStorage.AllDaughterTrusts(ctx.Epoch())
+	iter, ok := ip.DaughterStorage.AllDaughterTrusts(ctx.Epoch())
 	if !ok {
 		return nil, &ErrNoData{epoch: ctx.Epoch()}
 	}
@@ -83,7 +83,7 @@ func (ip *DaughterTrustIteratorProvider) InitAllDaughtersIterator(
 // specified epoch and iteration.
 func (ip *DaughterTrustIteratorProvider) InitConsumersIterator(
 	ctx eigentrustcalc.Context) (eigentrustcalc.PeerTrustsIterator, error) {
-	consumerIterator, ok := ip.consumerStorage.Consumers(ctx.Epoch(), ctx.I())
+	consumerIterator, ok := ip.ConsumerStorage.Consumers(ctx.Epoch(), ctx.I())
 	if !ok {
 		return nil, &ErrNoData{epoch: ctx.Epoch()}
 	}