TrueCloudLab/frostfs-node
20
1
Fork 28
Code Issues 109 Pull requests 4 Projects Releases 2 Packages 4 Activity Actions

[#971] morph/event: Change notification parser's signature

Browse source 
Parsers should have original notification
structure to be able to construct internal
event structure that contains necessary
for unique nonce calculation information.
So notification parsers take raw notification
structure instead of slice of stack items.

Signed-off-by: Pavel Karpy <carpawell@nspcc.ru>
This commit is contained in:
Pavel Karpy 2021-10-22 13:06:08 +03:00 • committed by Alex Vanin
parent 3666ae7ad2
commit c167ae26f9
35 changed files with 365 additions and 203 deletions
Download patch file Download diff file Expand all files Collapse all files

13
pkg/morph/event/netmap/add_peer.go
View file

@ -4,7 +4,7 @@ import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/network/payload"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neo-go/pkg/rpc/response/result/subscriptions"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
)
@ -32,17 +32,22 @@ func (s AddPeer) NotaryRequest() *payload.P2PNotaryRequest {
const expectedItemNumAddPeer = 1
func ParseAddPeer(prms []stackitem.Item) (event.Event, error) {
func ParseAddPeer(e *subscriptions.NotificationEvent) (event.Event, error) {
var (
ev AddPeer
err error
)
if ln := len(prms); ln != expectedItemNumAddPeer {
params, err := event.ParseStackArray(e)
if err != nil {
return nil, fmt.Errorf("could not parse stack items from notify event: %w", err)
}
if ln := len(params); ln != expectedItemNumAddPeer {
return nil, event.WrongNumberOfParameters(expectedItemNumAddPeer, ln)
}
ev.node, err = client.BytesFromStackItem(prms[0])
ev.node, err = client.BytesFromStackItem(params[0])
if err != nil {
return nil, fmt.Errorf("could not get raw nodeinfo: %w", err)
}

20
pkg/morph/event/netmap/add_peer_test.go
View file

@ -3,6 +3,8 @@ package netmap
import (
"testing"
"github.com/nspcc-dev/neo-go/pkg/core/state"
"github.com/nspcc-dev/neo-go/pkg/rpc/response/result/subscriptions"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
"github.com/stretchr/testify/require"
@ -15,14 +17,14 @@ func TestParseAddPeer(t *testing.T) {
stackitem.NewMap(),
}
_, err := ParseAddPeer(prms)
_, err := ParseAddPeer(createNotifyEventFromItems(prms))
require.EqualError(t, err, event.WrongNumberOfParameters(1, len(prms)).Error())
})
t.Run("wrong first parameter type", func(t *testing.T) {
_, err := ParseAddPeer([]stackitem.Item{
_, err := ParseAddPeer(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
@ -30,9 +32,9 @@ func TestParseAddPeer(t *testing.T) {
t.Run("correct behavior", func(t *testing.T) {
info := []byte{1, 2, 3}
ev, err := ParseAddPeer([]stackitem.Item{
ev, err := ParseAddPeer(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(info),
})
}))
require.NoError(t, err)
require.Equal(t, AddPeer{
@ -40,3 +42,11 @@ func TestParseAddPeer(t *testing.T) {
}, ev)
})
}
func createNotifyEventFromItems(items []stackitem.Item) *subscriptions.NotificationEvent {
return &subscriptions.NotificationEvent{
NotificationEvent: state.NotificationEvent{
Item: stackitem.NewArray(items),
},
}
}

13
pkg/morph/event/netmap/epoch.go
View file

@ -3,7 +3,7 @@ package netmap
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neo-go/pkg/rpc/response/result/subscriptions"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
)
@ -24,12 +24,17 @@ func (s NewEpoch) EpochNumber() uint64 {
// ParseNewEpoch is a parser of new epoch notification event.
//
// Result is type of NewEpoch.
func ParseNewEpoch(prms []stackitem.Item) (event.Event, error) {
if ln := len(prms); ln != 1 {
func ParseNewEpoch(e *subscriptions.NotificationEvent) (event.Event, error) {
params, err := event.ParseStackArray(e)
if err != nil {
return nil, fmt.Errorf("could not parse stack items from notify event: %w", err)
}
if ln := len(params); ln != 1 {
return nil, event.WrongNumberOfParameters(1, ln)
}
prmEpochNum, err := client.IntFromStackItem(prms[0])
prmEpochNum, err := client.IntFromStackItem(params[0])
if err != nil {
return nil, fmt.Errorf("could not get integer epoch number: %w", err)
}

10
pkg/morph/event/netmap/epoch_test.go
View file

@ -16,14 +16,14 @@ func TestParseNewEpoch(t *testing.T) {
stackitem.NewMap(),
}
_, err := ParseNewEpoch(prms)
_, err := ParseNewEpoch(createNotifyEventFromItems(prms))
require.EqualError(t, err, event.WrongNumberOfParameters(1, len(prms)).Error())
})
t.Run("wrong first parameter type", func(t *testing.T) {
_, err := ParseNewEpoch([]stackitem.Item{
_, err := ParseNewEpoch(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
@ -31,9 +31,9 @@ func TestParseNewEpoch(t *testing.T) {
t.Run("correct behavior", func(t *testing.T) {
epochNum := uint64(100)
ev, err := ParseNewEpoch([]stackitem.Item{
ev, err := ParseNewEpoch(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewBigInteger(new(big.Int).SetUint64(epochNum)),
})
}))
require.NoError(t, err)
require.Equal(t, NewEpoch{

17
pkg/morph/event/netmap/update_peer.go
View file

@ -4,9 +4,11 @@ import (
"crypto/elliptic"
"fmt"
"github.com/nspcc-dev/neo-go/pkg/rpc/response/result/subscriptions"
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
"github.com/nspcc-dev/neo-go/pkg/network/payload"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
v2netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
@ -41,18 +43,23 @@ func (s UpdatePeer) NotaryRequest() *payload.P2PNotaryRequest {
const expectedItemNumUpdatePeer = 2
func ParseUpdatePeer(prms []stackitem.Item) (event.Event, error) {
func ParseUpdatePeer(e *subscriptions.NotificationEvent) (event.Event, error) {
var (
ev UpdatePeer
err error
)
if ln := len(prms); ln != expectedItemNumUpdatePeer {
params, err := event.ParseStackArray(e)
if err != nil {
return nil, fmt.Errorf("could not parse stack items from notify event: %w", err)
}
if ln := len(params); ln != expectedItemNumUpdatePeer {
return nil, event.WrongNumberOfParameters(expectedItemNumUpdatePeer, ln)
}
// parse public key
key, err := client.BytesFromStackItem(prms[1])
key, err := client.BytesFromStackItem(params[1])
if err != nil {
return nil, fmt.Errorf("could not get public key: %w", err)
}
@ -63,7 +70,7 @@ func ParseUpdatePeer(prms []stackitem.Item) (event.Event, error) {
}
// parse node status
st, err := client.IntFromStackItem(prms[0])
st, err := client.IntFromStackItem(params[0])
if err != nil {
return nil, fmt.Errorf("could not get node status: %w", err)
}

14
pkg/morph/event/netmap/update_peer_test.go
View file

@ -25,32 +25,32 @@ func TestParseUpdatePeer(t *testing.T) {
stackitem.NewMap(),
}
_, err := ParseUpdatePeer(prms)
_, err := ParseUpdatePeer(createNotifyEventFromItems(prms))
require.EqualError(t, err, event.WrongNumberOfParameters(2, len(prms)).Error())
})
t.Run("wrong first parameter type", func(t *testing.T) {
_, err := ParseUpdatePeer([]stackitem.Item{
_, err := ParseUpdatePeer(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong second parameter type", func(t *testing.T) {
_, err := ParseUpdatePeer([]stackitem.Item{
_, err := ParseUpdatePeer(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(publicKey.Bytes()),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("correct behavior", func(t *testing.T) {
ev, err := ParseUpdatePeer([]stackitem.Item{
ev, err := ParseUpdatePeer(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewBigInteger(new(big.Int).SetInt64(int64(state.ToV2()))),
stackitem.NewByteArray(publicKey.Bytes()),
})
}))
require.NoError(t, err)
require.Equal(t, UpdatePeer{