From 269288119db586282d4df3bfb408a31a48ad7315 Mon Sep 17 00:00:00 2001
From: Leonard Lyubich <leonard@nspcc.ru>
Date: Fri, 9 Apr 2021 11:28:06 +0300
Subject: [PATCH] [#265] v2/reputation: Support PeerToPeerTrust message

Signed-off-by: Leonard Lyubich <leonard@nspcc.ru>
---
 v2/reputation/convert.go         |  57 ++++++++++++++++++++++++++++++-
 v2/reputation/grpc/service.go    |   2 +-
 v2/reputation/grpc/service.pb.go | Bin 39676 -> 39856 bytes
 v2/reputation/grpc/types.go      |  14 ++++++++
 v2/reputation/grpc/types.pb.go   | Bin 14863 -> 17780 bytes
 v2/reputation/json.go            |   8 +++++
 v2/reputation/marshal.go         |  39 +++++++++++++++++++++
 v2/reputation/message_test.go    |   1 +
 v2/reputation/test/generate.go   |  11 +++++-
 v2/reputation/types.go           |  46 +++++++++++++++++++++++--
 10 files changed, 172 insertions(+), 6 deletions(-)

diff --git a/v2/reputation/convert.go b/v2/reputation/convert.go
index 19be9f0..52df2fa 100644
--- a/v2/reputation/convert.go
+++ b/v2/reputation/convert.go
@@ -81,6 +81,61 @@ func (x *Trust) FromGRPCMessage(m grpc.Message) error {
 	return nil
 }
 
+// ToGRPCMessage converts PeerToPeerTrust to gRPC-generated
+// reputation.PeerToPeerTrust message.
+func (x *PeerToPeerTrust) ToGRPCMessage() grpc.Message {
+	var m *reputation.PeerToPeerTrust
+
+	if x != nil {
+		m = new(reputation.PeerToPeerTrust)
+
+		m.SetTrustingPeer(x.trusting.ToGRPCMessage().(*reputation.PeerID))
+		m.SetTrust(x.trust.ToGRPCMessage().(*reputation.Trust))
+	}
+
+	return m
+}
+
+// FromGRPCMessage tries to restore PeerToPeerTrust from grpc.Message.
+//
+// Returns message.ErrUnexpectedMessageType if m is not
+// a gRPC-generated reputation.PeerToPeerTrust message.
+func (x *PeerToPeerTrust) FromGRPCMessage(m grpc.Message) error {
+	v, ok := m.(*reputation.PeerToPeerTrust)
+	if !ok {
+		return message.NewUnexpectedMessageType(m, v)
+	}
+
+	var err error
+
+	trusting := v.GetTrustingPeer()
+	if trusting == nil {
+		x.trusting = nil
+	} else {
+		if x.trusting == nil {
+			x.trusting = new(PeerID)
+		}
+
+		err = x.trusting.FromGRPCMessage(trusting)
+		if err != nil {
+			return err
+		}
+	}
+
+	trust := v.GetTrust()
+	if trust == nil {
+		x.trust = nil
+	} else {
+		if x.trust == nil {
+			x.trust = new(Trust)
+		}
+
+		err = x.trust.FromGRPCMessage(trust)
+	}
+
+	return err
+}
+
 // TrustsToGRPC converts slice of Trust structures
 // to slice of gRPC-generated Trust messages.
 func TrustsToGRPC(xs []*Trust) (res []*reputation.Trust) {
@@ -404,7 +459,7 @@ func (x *SendIntermediateResultRequestBody) ToGRPCMessage() grpc.Message {
 		m = new(reputation.SendIntermediateResultRequest_Body)
 
 		m.SetIteration(x.iter)
-		m.SetTrust(x.trust.ToGRPCMessage().(*reputation.Trust))
+		m.SetTrust(x.trust.ToGRPCMessage().(*reputation.PeerToPeerTrust))
 	}
 
 	return m
diff --git a/v2/reputation/grpc/service.go b/v2/reputation/grpc/service.go
index bf8626e..2104d94 100644
--- a/v2/reputation/grpc/service.go
+++ b/v2/reputation/grpc/service.go
@@ -68,7 +68,7 @@ func (x *SendIntermediateResultRequest_Body) SetIteration(v uint32) {
 }
 
 // SetTrust sets current global trust value.
-func (x *SendIntermediateResultRequest_Body) SetTrust(v *Trust) {
+func (x *SendIntermediateResultRequest_Body) SetTrust(v *PeerToPeerTrust) {
 	if x != nil {
 		x.Trust = v
 	}
diff --git a/v2/reputation/grpc/service.pb.go b/v2/reputation/grpc/service.pb.go
index fea43eafb3a6a823dd6f408994ca2b8f139a15d5..0116189178d2ba9a344c2f9f6bf554dcf5a68993 100644
GIT binary patch
delta 740
zcmYk4NlX(_7{@bBI?z%|LRcnkEiEm!V4>56g3O_di3%-U>`svBUOkX1iNwS$O*|Tn
z{JnTF_Npn85Mv}N7mvnx<EA8>AtmuB(f5WLdU@~rzW4j~_vgKA>w|2o=~hO|<+VhO
zp4&|~Bk$BVFV=>b{I)(CWMv))jv`hd^_eLkmd@g1$cS8wg|Eb7FD=gUHl>2U>zTG0
z{+}~WDo?v5OGT3Tv)5B{#))XaD(9z(H^lTXzF$?~VMdEaiNk(OB_rnDjDR-<GZl}+
zc0{r&97Z{O2}rN?tblNgBXy_{&9C8pQG*|u3F4uGu-JpWqJAS{z)_HcQdHvQwF?kJ
zHjG`jV<c|IPDqVUB*c@r0nhv_p5}UxTCk(IXhCnHg2UxmyiLS$FYE-LjBiBLw2s>g
z185|J__{m_b;?V~Asnn&&|FYpK-5x%7X`+ERnbJ1=c0gDm*&9cEbXCjFa%lbhUNI3
z4q!E?!8dUZC;47H3TRk5N=F{`%kyZZ`?2G*gU_%8v(ae#;(0<2!dup2s-Tc)-htNq
zc)NR!Qpcrnyj$w)c1UY*x!{kDU^4f(%}Db+DV-yXj^xxU^K>^ZH(dmiw8NL<X_VL%
z18ya|NNTR_$WrsKl0Y2I=r8E7R5p@MAC#p|8)e$|&r?NKp^CR+A{~UVSs5hv6k3%&
zVr8llKUSqkp=v_b=kE4MwelWJ`bW19s`aj3g>~ZWhhn&91hcN|{G=<j*DT}0-#a%u
KtvA+RnEwHQ7WhH{

delta 708
zcmXX@OH5Ny6in;mwU0E7G!+|ao9Z<XYK49gMB8E|YAF=^p_G=set1+D2K-f5*v6HK
zhQ`_HrY_uQ2#pPKg~pX8h5$=90*Nj(kr0<gQ}2E0?#`S!=ggd2f2;hvrmU~H+hVuw
z-oAtNHdEt^dxvYmir&=tHZ<O;us58OW4zLH1`npbD;$s#Nf@sP_?URexozzNwl8;K
zBF|$XVMI14U~}52Y!{wpjnGOK{3@7Ho8)mW;z2oSqZO<q3BF$FLo=yGXL=akv2I4+
zyrhSJT!lY5L#tE6=&cz7QL<wxC__hzz!#!JBBu}zshMIgV!~>Q$K#6{e2y7V3mF)_
z8`R@n;xxQ*9@VT4+6>R=OnitMA#LtCW`1*Y5IY$ayfF(aiZO!bxDKINE7nr|csc8&
z7N27+-owfjzXj#+5o~3w41NfE=rRr-Q4Ww6iNb=4ILvD6BEh~-z)#VIL%Fj^WP7k5
z>ZM_AsEZoBDiG8I-FQEyp;wcmjpPWja{@ZzL0PstXJ(UL1UxO38Ozc!Eae5d=23na
zpQbuco*YCq&EdM#Avl~glKsBRg~ePP<$|1dBR5LV*~KPp=Z~UU(9r)dw0g{(gI!@a
z+NE~nY!=$<Ms?ym6Z>YOs0CzWHTo1K`Kd^G@mf001RD~I`&*LZ_RTX8otMG#JfYjI
z@K1C2=hrgvL5uPhbqroDGI^;e%ik0U4u?5Z#eVgGlew@D;9!I_T-Pe9hIa88uXNh5
Ww_rl{#tHl=^`cf%HORduC;tN-2JM&t

diff --git a/v2/reputation/grpc/types.go b/v2/reputation/grpc/types.go
index 0a469bd..07d1d8b 100644
--- a/v2/reputation/grpc/types.go
+++ b/v2/reputation/grpc/types.go
@@ -25,6 +25,20 @@ func (x *Trust) SetValue(v float64) {
 	}
 }
 
+// SetTrustingPeer sets trusting peer ID.
+func (x *PeerToPeerTrust) SetTrustingPeer(v *PeerID) {
+	if x != nil {
+		x.TrustingPeer = v
+	}
+}
+
+// SetTrust sets trust value of trusting peer to the trusted one.
+func (x *PeerToPeerTrust) SetTrust(v *Trust) {
+	if x != nil {
+		x.Trust = v
+	}
+}
+
 // SetManager sets manager ID.
 func (x *GlobalTrust_Body) SetManager(v *PeerID) {
 	if x != nil {
diff --git a/v2/reputation/grpc/types.pb.go b/v2/reputation/grpc/types.pb.go
index c2adca51263e3d19acf4c72486db26153b4695b2..7c4ec0471b08820d1ace4baa412ec39ef00020ea 100644
GIT binary patch
delta 1465
zcmaJ>OKcle6xBE%$CHoacqXwEyPokl9#3k|j6Y+$aRMX~DqU19QH4MiO)Qw8q9!(}
zTTvE>RtN+L5p+}}lue^bNFXGLykUV7s_u$N)eY<_v7k~Ge2Um1KKH%E#AzfpPw(8%
zx#!;Z`JnN~yTX@qe*4VIrHc*aa`nO`SE(&3Ri*B_D@vobw=>1YmAb2(CgYhJTM-f0
zg6EfC;&G<v<N1VfOEgLiMn+(sk)&U~SX-WMnOJVRzEW${@^OWECgUyFJpK|jTpu|r
zww3uYFwzeH4&3tZdwEg(5_+;d<VK&?2Ahusj|*)W?@4Am+>$Ow9w9W8<8FgfvwprB
zINH|&ED&$VkwX$5j6Kyn<?rpll~5gbhQ7yk_&2Od9|?JE42?Bs<x+>I@I0RGpF+&5
zV{51vJE5P10@j1SVsrF{kZ;b9?Q}`yQd+TJwX=M!@^ulP9*HPUfq~*8TOFJ4o&B|x
z!+lK)XLHO{XwQC;SxTtKqH^&VPjJ(skC=ENXA$eMAih50!(dXzl0J;7<bX%?L5Wwe
zttZ&_o+{y+q&~<h^8)q@EmA4OxJtX)TJ#iGEHTlzsRmKdCA=Q%#>Z+ep3_gmuehBB
zl7OkyDAK73%&KFo$~m=ylPMqGk9qN#DlyX*nMl$gmzs0`Q@<z92RF`Buaed~YGi<m
z%U5}Sb`@$OhAu5c6mlR}WZ8!~+8XS}rl#Vm8e%efD3rBUz{B_mVhL4HFq_brs#nG{
z-ZEpe^H|U|Y$ke`d0LyHfiX?N&OGaHA(8VqIm{)FGWR><75ozyad&)_!9SBa9?)F>
zcj8oYC&_E}>lGT}APrDLR2#-MU8g~IV?jHIH&vM_?xM3H;;cSGk$yark|}*D#nV4b
zRS0bFg5No?3=MB3D;;#9u*&z7omIMUcxdnxd4i?PO=w+g3=TGoN>6e3^ouwZ4O0`%
zA10<f9>>6Urh&&Z*AG3T)bjZYMp{uUOUWT%9eBszW)jGn8ivdmy#jJ#)u#T;n8%sK
zniU4js8Ga)`MJkV<BLor{Kz9U_kRu3vb=QXTV)PCP9bXx4$`FZZ7buY%Sw^0ntix$
z9rM!dAe*zNqYpE7iHh&4Iw6$yb^&;@mPlt$v1iMZWz@1!Je%!5Xfh7MVf>sGW%hZ_
zFISgb(RU!9d7}bj8g8n&*E-sMrsld674V63o96RG;RM#4-sWcUnjkpMnew*qFT(`5
ArT_o{

delta 703
zcmZXQPiPZC7{%F5W7DMnj7^$$OFHewB%9r2H_2wV*+fWH6c2?`2#SI=LOcl72nnQ0
zK|Lt-pu~qF2vVU4Lb1w1LC~vSBr16FAczK!1`$tIok=}dJPq%Czc=5T`F@SNQGGl&
zV9)qm4&2&V#!sOSF9YxJ#oNNg(fg<k4Nz~;E(p2<#Xtq0gDu=0Y2ztb*^yF+w&cd_
zc+g&&c;Up=n2#g47t3K$^59c!6m2<*usnn{Z5Xq1Kb}cJtSCYBCEZw+1^kdF@KF|c
zcMmpY(MhzrRzfK*;*i2Zem-SjU6TK13izc=FqTl_TSCBmydy7Bxt<8%c|63XCsYBO
zaThkE5Df;H)gKaYJmJE_M37QGPli>mYgvWPRudxi{P>UvGt{Yy$ZB5X)L5tX1@+(B
z)9BU+!=jo<5kF?6PHLIT=59Y8ZOKaXAlj4ut}<Id;sl3dG2Bl2SaK~X(qDR;%rViI
zVj`95h%+e>uO^T1>63UOj({X1&QgipprsjAOn0b8TI{0bGiXG^bcwgu-J{iwtp^!c
z2#wog`V`OW5*8*U4DRp772`UNngUcafY+u6cg%6rOcC$R5U1m}Y4RBhE7mCHrW(Ai
z;Hxo4xn8`<#`&}Y+1!#5E6ZmToHHX>wx-~)LTFigaEhJ>a=P14h^mrfhGl@{{b=U8
zhtJlkm0ESax>zZ@d;Xj6+8!bB<UQN1G}pPyKAk`BxH;X#MxkhndoOdGZa>)9<o*B_
Crq})e

diff --git a/v2/reputation/json.go b/v2/reputation/json.go
index 637035a..5ee1cc2 100644
--- a/v2/reputation/json.go
+++ b/v2/reputation/json.go
@@ -21,6 +21,14 @@ func (x *Trust) UnmarshalJSON(data []byte) error {
 	return message.UnmarshalJSON(x, data, new(reputation.Trust))
 }
 
+func (x *PeerToPeerTrust) MarshalJSON() ([]byte, error) {
+	return message.MarshalJSON(x)
+}
+
+func (x *PeerToPeerTrust) UnmarshalJSON(data []byte) error {
+	return message.UnmarshalJSON(x, data, new(reputation.PeerToPeerTrust))
+}
+
 func (x *GlobalTrust) MarshalJSON() ([]byte, error) {
 	return message.MarshalJSON(x)
 }
diff --git a/v2/reputation/marshal.go b/v2/reputation/marshal.go
index 76b5e9d..20fa677 100644
--- a/v2/reputation/marshal.go
+++ b/v2/reputation/marshal.go
@@ -84,6 +84,45 @@ func (x *Trust) Unmarshal(data []byte) error {
 	return message.Unmarshal(x, data, new(reputation.Trust))
 }
 
+const (
+	_ = iota
+	p2pTrustTrustingFNum
+	p2pTrustValueFNum
+)
+
+func (x *PeerToPeerTrust) StableMarshal(buf []byte) ([]byte, error) {
+	if x == nil {
+		return []byte{}, nil
+	}
+
+	if buf == nil {
+		buf = make([]byte, x.StableSize())
+	}
+
+	offset, err := protoutil.NestedStructureMarshal(p2pTrustTrustingFNum, buf, x.trusting)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = protoutil.NestedStructureMarshal(p2pTrustValueFNum, buf[offset:], x.trust)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+func (x *PeerToPeerTrust) StableSize() (size int) {
+	size += protoutil.NestedStructureSize(p2pTrustTrustingFNum, x.trusting)
+	size += protoutil.NestedStructureSize(p2pTrustValueFNum, x.trust)
+
+	return
+}
+
+func (x *PeerToPeerTrust) Unmarshal(data []byte) error {
+	return message.Unmarshal(x, data, new(reputation.PeerToPeerTrust))
+}
+
 const (
 	_ = iota
 	globalTrustBodyManagerFNum
diff --git a/v2/reputation/message_test.go b/v2/reputation/message_test.go
index ecbec7b..2d5899a 100644
--- a/v2/reputation/message_test.go
+++ b/v2/reputation/message_test.go
@@ -25,5 +25,6 @@ func TestMessageConvert(t *testing.T) {
 		func(empty bool) message.Message { return reputationtest.GenerateSendIntermediateResultResponse(empty) },
 		func(empty bool) message.Message { return reputationtest.GenerateGlobalTrustBody(empty) },
 		func(empty bool) message.Message { return reputationtest.GenerateGlobalTrust(empty) },
+		func(empty bool) message.Message { return reputationtest.GeneratePeerToPeerTrust(empty) },
 	)
 }
diff --git a/v2/reputation/test/generate.go b/v2/reputation/test/generate.go
index 4cb525f..65e50e8 100644
--- a/v2/reputation/test/generate.go
+++ b/v2/reputation/test/generate.go
@@ -28,6 +28,15 @@ func GenerateTrust(empty bool) *reputation.Trust {
 	return m
 }
 
+func GeneratePeerToPeerTrust(empty bool) *reputation.PeerToPeerTrust {
+	m := new(reputation.PeerToPeerTrust)
+
+	m.SetTrustingPeer(GeneratePeerID(empty))
+	m.SetTrust(GenerateTrust(empty))
+
+	return m
+}
+
 func GenerateGlobalTrustBody(empty bool) *reputation.GlobalTrustBody {
 	m := new(reputation.GlobalTrustBody)
 
@@ -103,7 +112,7 @@ func GenerateSendIntermediateResultRequestBody(empty bool) *reputation.SendInter
 		m.SetIteration(564)
 	}
 
-	m.SetTrust(GenerateTrust(empty))
+	m.SetTrust(GeneratePeerToPeerTrust(empty))
 
 	return m
 }
diff --git a/v2/reputation/types.go b/v2/reputation/types.go
index 3b67c13..b7ef545 100644
--- a/v2/reputation/types.go
+++ b/v2/reputation/types.go
@@ -67,6 +67,46 @@ func (x *Trust) SetValue(v float64) {
 	}
 }
 
+// PeerToPeerTrust represents reputation.PeerToPeerTrust message
+// from NeoFS API v2.
+type PeerToPeerTrust struct {
+	trusting *PeerID
+
+	trust *Trust
+}
+
+// GetTrustingPeer returns trusting peer ID.
+func (x *PeerToPeerTrust) GetTrustingPeer() *PeerID {
+	if x != nil {
+		return x.trusting
+	}
+
+	return nil
+}
+
+// SetTrustingPeer sets trusting peer ID.
+func (x *PeerToPeerTrust) SetTrustingPeer(v *PeerID) {
+	if x != nil {
+		x.trusting = v
+	}
+}
+
+// GetTrust returns trust value of trusting peer to the trusted one.
+func (x *PeerToPeerTrust) GetTrust() *Trust {
+	if x != nil {
+		return x.trust
+	}
+
+	return nil
+}
+
+// SetTrust sets trust value of trusting peer to the trusted one.
+func (x *PeerToPeerTrust) SetTrust(v *Trust) {
+	if x != nil {
+		x.trust = v
+	}
+}
+
 // GlobalTrustBody represents reputation.GlobalTrust.Body message
 // from NeoFS API v2.
 type GlobalTrustBody struct {
@@ -259,7 +299,7 @@ func (x *SendLocalTrustResponse) SetBody(v *SendLocalTrustResponseBody) {
 type SendIntermediateResultRequestBody struct {
 	iter uint32
 
-	trust *Trust
+	trust *PeerToPeerTrust
 }
 
 // GetIteration returns sequence number of the iteration.
@@ -279,7 +319,7 @@ func (x *SendIntermediateResultRequestBody) SetIteration(v uint32) {
 }
 
 // GetTrust returns current global trust value.
-func (x *SendIntermediateResultRequestBody) GetTrust() *Trust {
+func (x *SendIntermediateResultRequestBody) GetTrust() *PeerToPeerTrust {
 	if x != nil {
 		return x.trust
 	}
@@ -288,7 +328,7 @@ func (x *SendIntermediateResultRequestBody) GetTrust() *Trust {
 }
 
 // SetTrust sets current global trust value.
-func (x *SendIntermediateResultRequestBody) SetTrust(v *Trust) {
+func (x *SendIntermediateResultRequestBody) SetTrust(v *PeerToPeerTrust) {
 	if x != nil {
 		x.trust = v
 	}