From 882236a03b5efc561a9a0abbeba41218a9bfbd16 Mon Sep 17 00:00:00 2001 From: Evgenii Stratonikov Date: Mon, 28 Mar 2022 16:44:53 +0300 Subject: [PATCH] [#1239] morph/client: Remove intermediate conversion in morph client Signed-off-by: Evgenii Stratonikov --- pkg/morph/client/netmap/netmap.go | 77 ++++++-------------------- pkg/morph/client/netmap/netmap_test.go | 50 +++++++++++++++++ 2 files changed, 68 insertions(+), 59 deletions(-) create mode 100644 pkg/morph/client/netmap/netmap_test.go diff --git a/pkg/morph/client/netmap/netmap.go b/pkg/morph/client/netmap/netmap.go index 08c64aad..2b67fd50 100644 --- a/pkg/morph/client/netmap/netmap.go +++ b/pkg/morph/client/netmap/netmap.go @@ -22,21 +22,6 @@ const ( Offline ) -// PeerWithState groups information about peer -// and its state in network map. -type PeerWithState struct { - peer []byte - state State -} - -func (ps PeerWithState) State() State { - return ps.state -} - -func (ps PeerWithState) Peer() []byte { - return ps.peer -} - const ( nodeInfoFixedPrmNumber = 1 @@ -72,12 +57,12 @@ func (c *Client) GetCandidates() (*netmap.Netmap, error) { return nil, fmt.Errorf("could not perform test invocation (%s): %w", netMapCandidatesMethod, err) } - candVals, err := peersWithStateFromStackItems(prms, netMapCandidatesMethod) + candVals, err := nodeInfosFromStackItems(prms, netMapCandidatesMethod) if err != nil { return nil, fmt.Errorf("could not parse contract response: %w", err) } - return unmarshalCandidates(candVals) + return netmap.NewNetmap(netmap.NodesFromInfo(candVals)) } // NetMap performs the test invoke of get network map @@ -95,31 +80,7 @@ func (c *Client) NetMap() ([][]byte, error) { return peersFromStackItems(prms, netMapMethod) } -func unmarshalCandidates(rawCandidate []*PeerWithState) (*netmap.Netmap, error) { - candidates := make([]netmap.NodeInfo, 0, len(rawCandidate)) - - for _, candidate := range rawCandidate { - nodeInfo := netmap.NewNodeInfo() - if err := nodeInfo.Unmarshal(candidate.Peer()); err != nil { - return nil, fmt.Errorf("can't unmarshal peer info: %w", err) - } - - switch candidate.State() { - case Online: - nodeInfo.SetState(netmap.NodeStateOnline) - case Offline: - nodeInfo.SetState(netmap.NodeStateOffline) - default: - nodeInfo.SetState(0) - } - - candidates = append(candidates, *nodeInfo) - } - - return netmap.NewNetmap(netmap.NodesFromInfo(candidates)) -} - -func peersWithStateFromStackItems(stack []stackitem.Item, method string) ([]*PeerWithState, error) { +func nodeInfosFromStackItems(stack []stackitem.Item, method string) ([]netmap.NodeInfo, error) { if ln := len(stack); ln != 1 { return nil, fmt.Errorf("unexpected stack item count (%s): %d", method, ln) } @@ -129,54 +90,52 @@ func peersWithStateFromStackItems(stack []stackitem.Item, method string) ([]*Pee return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", method, err) } - res := make([]*PeerWithState, 0, len(netmapNodes)) + res := make([]netmap.NodeInfo, len(netmapNodes)) for i := range netmapNodes { - node, err := peerWithStateFromStackItem(netmapNodes[i]) + err := stackItemToNodeInfo(netmapNodes[i], &res[i]) if err != nil { return nil, fmt.Errorf("could not parse stack item (Peer #%d): %w", i, err) } - - res = append(res, node) } return res, nil } -func peerWithStateFromStackItem(prm stackitem.Item) (*PeerWithState, error) { +func stackItemToNodeInfo(prm stackitem.Item, res *netmap.NodeInfo) error { prms, err := client.ArrayFromStackItem(prm) if err != nil { - return nil, fmt.Errorf("could not get stack item array (PeerWithState): %w", err) + return fmt.Errorf("could not get stack item array (PeerWithState): %w", err) } else if ln := len(prms); ln != peerWithStateFixedPrmNumber { - return nil, fmt.Errorf( + return fmt.Errorf( "unexpected stack item count (PeerWithState): expected %d, has %d", peerWithStateFixedPrmNumber, ln, ) } - var res PeerWithState - - // peer - if res.peer, err = peerInfoFromStackItem(prms[0]); err != nil { - return nil, fmt.Errorf("could not get bytes from 'node' field of PeerWithState: %w", err) + peer, err := peerInfoFromStackItem(prms[0]) + if err != nil { + return fmt.Errorf("could not get bytes from 'node' field of PeerWithState: %w", err) + } else if err = res.Unmarshal(peer); err != nil { + return fmt.Errorf("can't unmarshal peer info: %w", err) } // state state, err := client.IntFromStackItem(prms[1]) if err != nil { - return nil, fmt.Errorf("could not get int from 'state' field of PeerWithState: %w", err) + return fmt.Errorf("could not get int from 'state' field of PeerWithState: %w", err) } switch state { case 1: - res.state = Online + res.SetState(netmap.NodeStateOnline) case 2: - res.state = Offline + res.SetState(netmap.NodeStateOffline) default: - res.state = Undefined + res.SetState(0) } - return &res, nil + return nil } func peersFromStackItems(stack []stackitem.Item, method string) ([][]byte, error) { diff --git a/pkg/morph/client/netmap/netmap_test.go b/pkg/morph/client/netmap/netmap_test.go new file mode 100644 index 00000000..3b6a4393 --- /dev/null +++ b/pkg/morph/client/netmap/netmap_test.go @@ -0,0 +1,50 @@ +package netmap + +import ( + "math/big" + "math/rand" + "strconv" + "testing" + + "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" + "github.com/nspcc-dev/neofs-sdk-go/netmap" + "github.com/stretchr/testify/require" +) + +func Test_stackItemsToNodeInfos(t *testing.T) { + expected := make([]netmap.NodeInfo, 4) + for i := range expected { + pub := make([]byte, 33) + rand.Read(pub) + + expected[i].SetState(netmap.NodeState(i % 3)) + expected[i].SetPublicKey(pub) + + var attr netmap.NodeAttribute + attr.SetKey("key") + attr.SetValue(strconv.Itoa(i)) + expected[i].SetAttributes(attr) + } + + items := make([]stackitem.Item, 4) + for i := range items { + data, err := expected[i].Marshal() + require.NoError(t, err) + + state := int64(expected[i].State()) + if state != 0 { // In contract online=1, offline=2, in API it is the other way. + state = 3 - state + } + + items[i] = stackitem.NewStruct([]stackitem.Item{ + stackitem.NewStruct([]stackitem.Item{ + stackitem.NewByteArray(data), + }), + stackitem.NewBigInteger(big.NewInt(state)), + }) + } + + actual, err := nodeInfosFromStackItems([]stackitem.Item{stackitem.NewArray(items)}, "") + require.NoError(t, err) + require.Equal(t, expected, actual) +}