forked from TrueCloudLab/frostfs-node
7c02a2e251
- Update `neofs-sdk-go`: v0.0.0-20211230072947-1fe37df88f80 => v0.0.0-20220113123743-7f3162110659 - Add client interface that duplicates SDK's client behaviour and new `MultiAddressClient` interface that has method that iterates over wrapped clients. - Also start using simple client mode that does not require parsing statuses outside the SDK library. Signed-off-by: Pavel Karpy <carpawell@nspcc.ru>
110 lines
3.1 KiB
Go
110 lines
3.1 KiB
Go
package intermediate
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
|
|
"github.com/nspcc-dev/neofs-node/cmd/neofs-node/reputation/common"
|
|
internalclient "github.com/nspcc-dev/neofs-node/cmd/neofs-node/reputation/internal/client"
|
|
coreclient "github.com/nspcc-dev/neofs-node/pkg/core/client"
|
|
"github.com/nspcc-dev/neofs-node/pkg/services/reputation"
|
|
reputationcommon "github.com/nspcc-dev/neofs-node/pkg/services/reputation/common"
|
|
eigentrustcalc "github.com/nspcc-dev/neofs-node/pkg/services/reputation/eigentrust/calculator"
|
|
reputationapi "github.com/nspcc-dev/neofs-sdk-go/reputation"
|
|
)
|
|
|
|
// RemoteProviderPrm groups the required parameters of the RemoteProvider'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 {
|
|
Key *ecdsa.PrivateKey
|
|
}
|
|
|
|
// NewRemoteProvider creates a new instance of the RemoteProvider.
|
|
//
|
|
// Panics if at least one value of the parameters is invalid.
|
|
//
|
|
// The created RemoteProvider does not require additional
|
|
// initialization and is completely ready for work.
|
|
func NewRemoteProvider(prm RemoteProviderPrm) *RemoteProvider {
|
|
switch {
|
|
case prm.Key == nil:
|
|
common.PanicOnPrmValue("NetMapSource", prm.Key)
|
|
}
|
|
|
|
return &RemoteProvider{
|
|
key: prm.Key,
|
|
}
|
|
}
|
|
|
|
// RemoteProvider is an implementation of the clientKeyRemoteProvider interface.
|
|
type RemoteProvider struct {
|
|
key *ecdsa.PrivateKey
|
|
}
|
|
|
|
func (rp RemoteProvider) WithClient(c coreclient.Client) reputationcommon.WriterProvider {
|
|
return &TrustWriterProvider{
|
|
client: c,
|
|
key: rp.key,
|
|
}
|
|
}
|
|
|
|
type TrustWriterProvider struct {
|
|
client coreclient.Client
|
|
key *ecdsa.PrivateKey
|
|
}
|
|
|
|
func (twp *TrustWriterProvider) InitWriter(ctx reputationcommon.Context) (reputationcommon.Writer, error) {
|
|
eiContext, ok := ctx.(eigentrustcalc.Context)
|
|
if !ok {
|
|
// TODO: think if this can be done without such limitation
|
|
panic(ErrIncorrectContextPanicMsg)
|
|
}
|
|
|
|
return &RemoteTrustWriter{
|
|
eiCtx: eiContext,
|
|
client: twp.client,
|
|
key: twp.key,
|
|
}, nil
|
|
}
|
|
|
|
type RemoteTrustWriter struct {
|
|
eiCtx eigentrustcalc.Context
|
|
client coreclient.Client
|
|
key *ecdsa.PrivateKey
|
|
}
|
|
|
|
// Write sends trust value to remote node via ReputationService.AnnounceIntermediateResult RPC.
|
|
func (rtp *RemoteTrustWriter) Write(t reputation.Trust) error {
|
|
apiTrustingPeer := reputationapi.NewPeerID()
|
|
apiTrustingPeer.SetPublicKey(t.TrustingPeer())
|
|
|
|
apiTrustedPeer := reputationapi.NewPeerID()
|
|
apiTrustedPeer.SetPublicKey(t.Peer())
|
|
|
|
apiTrust := reputationapi.NewTrust()
|
|
apiTrust.SetValue(t.Value().Float64())
|
|
apiTrust.SetPeer(apiTrustedPeer)
|
|
|
|
apiPeerToPeerTrust := reputationapi.NewPeerToPeerTrust()
|
|
apiPeerToPeerTrust.SetTrustingPeer(apiTrustingPeer)
|
|
apiPeerToPeerTrust.SetTrust(apiTrust)
|
|
|
|
var p internalclient.AnnounceIntermediatePrm
|
|
|
|
p.SetContext(rtp.eiCtx)
|
|
p.SetClient(rtp.client)
|
|
p.SetPrivateKey(rtp.key)
|
|
p.SetEpoch(rtp.eiCtx.Epoch())
|
|
p.SetIteration(rtp.eiCtx.I())
|
|
p.SetTrust(apiPeerToPeerTrust)
|
|
|
|
_, err := internalclient.AnnounceIntermediate(p)
|
|
|
|
return err
|
|
}
|
|
|
|
func (rtp *RemoteTrustWriter) Close() error {
|
|
return nil
|
|
}
|