realloc/frostfs-node
1
0
Fork 0
forked from TrueCloudLab/frostfs-node
Code Releases Packages Activity

[#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

10
pkg/morph/event/container/delete.go
View file

@ -3,8 +3,9 @@ package container
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/rpc/response/result/subscriptions"
"github.com/nspcc-dev/neo-go/pkg/network/payload"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
)
@ -46,12 +47,17 @@ const expectedItemNumDelete = 3
// ParseDelete from notification into container event structure.
//
// Expects 3 stack items.
func ParseDelete(params []stackitem.Item) (event.Event, error) {
func ParseDelete(e *subscriptions.NotificationEvent) (event.Event, error) {
var (
ev Delete
err 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 != expectedItemNumDelete {
return nil, event.WrongNumberOfParameters(expectedItemNumDelete, ln)
}

18
pkg/morph/event/container/delete_test.go
View file

@ -20,43 +20,43 @@ func TestParseDelete(t *testing.T) {
stackitem.NewMap(),
}
_, err := ParseDelete(prms)
_, err := ParseDelete(createNotifyEventFromItems(prms))
require.EqualError(t, err, event.WrongNumberOfParameters(3, len(prms)).Error())
})
t.Run("wrong container parameter", func(t *testing.T) {
_, err := ParseDelete([]stackitem.Item{
_, err := ParseDelete(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong signature parameter", func(t *testing.T) {
_, err := ParseDelete([]stackitem.Item{
_, err := ParseDelete(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(containerID),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong session token parameter", func(t *testing.T) {
_, err := ParseDelete([]stackitem.Item{
_, err := ParseDelete(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(containerID),
stackitem.NewByteArray(signature),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("correct behavior", func(t *testing.T) {
ev, err := ParseDelete([]stackitem.Item{
ev, err := ParseDelete(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(containerID),
stackitem.NewByteArray(signature),
stackitem.NewByteArray(token),
})
}))
require.NoError(t, err)

19
pkg/morph/event/container/eacl.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"
)
@ -58,36 +58,41 @@ const expectedItemNumEACL = 4
// ParseSetEACL parses SetEACL notification event from list of stack items.
//
// Expects 4 stack items.
func ParseSetEACL(items []stackitem.Item) (event.Event, error) {
func ParseSetEACL(e *subscriptions.NotificationEvent) (event.Event, error) {
var (
ev SetEACL
err error
)
if ln := len(items); ln != expectedItemNumEACL {
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 != expectedItemNumEACL {
return nil, event.WrongNumberOfParameters(expectedItemNumEACL, ln)
}
// parse table
ev.table, err = client.BytesFromStackItem(items[0])
ev.table, err = client.BytesFromStackItem(params[0])
if err != nil {
return nil, fmt.Errorf("could not parse binary table: %w", err)
}
// parse signature
ev.signature, err = client.BytesFromStackItem(items[1])
ev.signature, err = client.BytesFromStackItem(params[1])
if err != nil {
return nil, fmt.Errorf("could not parse table signature: %w", err)
}
// parse public key
ev.publicKey, err = client.BytesFromStackItem(items[2])
ev.publicKey, err = client.BytesFromStackItem(params[2])
if err != nil {
return nil, fmt.Errorf("could not parse binary public key: %w", err)
}
// parse session token
ev.token, err = client.BytesFromStackItem(items[3])
ev.token, err = client.BytesFromStackItem(params[3])
if err != nil {
return nil, fmt.Errorf("could not get session token: %w", err)
}

37
pkg/morph/event/container/eacl_test.go
View file

@ -1,11 +1,12 @@
package container_test
package container
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/nspcc-dev/neofs-node/pkg/morph/event/container"
"github.com/stretchr/testify/require"
)
@ -23,60 +24,60 @@ func TestParseEACL(t *testing.T) {
stackitem.NewMap(),
}
_, err := container.ParseSetEACL(items)
_, err := ParseSetEACL(createNotifyEventFromItems(items))
require.EqualError(t, err, event.WrongNumberOfParameters(4, len(items)).Error())
})
t.Run("wrong container parameter", func(t *testing.T) {
_, err := container.ParseSetEACL([]stackitem.Item{
_, err := ParseSetEACL(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
stackitem.NewMap(),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong signature parameter", func(t *testing.T) {
_, err := container.ParseSetEACL([]stackitem.Item{
_, err := ParseSetEACL(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(binaryTable),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong key parameter", func(t *testing.T) {
_, err := container.ParseSetEACL([]stackitem.Item{
_, err := ParseSetEACL(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(binaryTable),
stackitem.NewByteArray(signature),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong session token parameter", func(t *testing.T) {
_, err := container.ParseSetEACL([]stackitem.Item{
_, err := ParseSetEACL(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(binaryTable),
stackitem.NewByteArray(signature),
stackitem.NewByteArray(publicKey),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("correct behavior", func(t *testing.T) {
ev, err := container.ParseSetEACL([]stackitem.Item{
ev, err := ParseSetEACL(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(binaryTable),
stackitem.NewByteArray(signature),
stackitem.NewByteArray(publicKey),
stackitem.NewByteArray(token),
})
}))
require.NoError(t, err)
e := ev.(container.SetEACL)
e := ev.(SetEACL)
require.Equal(t, binaryTable, e.Table())
require.Equal(t, signature, e.Signature())
@ -84,3 +85,11 @@ func TestParseEACL(t *testing.T) {
require.Equal(t, token, e.SessionToken())
})
}
func createNotifyEventFromItems(items []stackitem.Item) *subscriptions.NotificationEvent {
return &subscriptions.NotificationEvent{
NotificationEvent: state.NotificationEvent{
Item: stackitem.NewArray(items),
},
}
}

16
pkg/morph/event/container/estimates.go
View file

@ -3,6 +3,8 @@ package container
import (
"fmt"
"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/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
@ -33,7 +35,12 @@ func (s StartEstimation) Epoch() uint64 { return s.epoch }
func (s StopEstimation) Epoch() uint64 { return s.epoch }
// ParseStartEstimation from notification into container event structure.
func ParseStartEstimation(params []stackitem.Item) (event.Event, error) {
func ParseStartEstimation(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)
}
epoch, err := parseEstimation(params)
if err != nil {
return nil, err
@ -43,7 +50,12 @@ func ParseStartEstimation(params []stackitem.Item) (event.Event, error) {
}
// ParseStopEstimation from notification into container event structure.
func ParseStopEstimation(params []stackitem.Item) (event.Event, error) {
func ParseStopEstimation(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)
}
epoch, err := parseEstimation(params)
if err != nil {
return nil, err

20
pkg/morph/event/container/estimates_test.go
View file

@ -19,22 +19,22 @@ func TestStartEstimation(t *testing.T) {
stackitem.NewMap(),
}
_, err := ParseStartEstimation(prms)
_, err := ParseStartEstimation(createNotifyEventFromItems(prms))
require.EqualError(t, err, event.WrongNumberOfParameters(1, len(prms)).Error())
})
t.Run("wrong estimation parameter", func(t *testing.T) {
_, err := ParseStartEstimation([]stackitem.Item{
_, err := ParseStartEstimation(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("correct behavior", func(t *testing.T) {
ev, err := ParseStartEstimation([]stackitem.Item{
ev, err := ParseStartEstimation(createNotifyEventFromItems([]stackitem.Item{
epochItem,
})
}))
require.NoError(t, err)
@ -54,22 +54,22 @@ func TestStopEstimation(t *testing.T) {
stackitem.NewMap(),
}
_, err := ParseStopEstimation(prms)
_, err := ParseStopEstimation(createNotifyEventFromItems(prms))
require.EqualError(t, err, event.WrongNumberOfParameters(1, len(prms)).Error())
})
t.Run("wrong estimation parameter", func(t *testing.T) {
_, err := ParseStopEstimation([]stackitem.Item{
_, err := ParseStopEstimation(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("correct behavior", func(t *testing.T) {
ev, err := ParseStopEstimation([]stackitem.Item{
ev, err := ParseStopEstimation(createNotifyEventFromItems([]stackitem.Item{
epochItem,
})
}))
require.NoError(t, err)

10
pkg/morph/event/container/put.go
View file

@ -3,8 +3,9 @@ package container
import (
"fmt"
"github.com/nspcc-dev/neo-go/pkg/rpc/response/result/subscriptions"
"github.com/nspcc-dev/neo-go/pkg/network/payload"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
"github.com/nspcc-dev/neofs-node/pkg/morph/event"
)
@ -65,12 +66,17 @@ func (x PutNamed) Zone() string {
}
// ParsePut from notification into container event structure.
func ParsePut(params []stackitem.Item) (event.Event, error) {
func ParsePut(e *subscriptions.NotificationEvent) (event.Event, error) {
var (
ev Put
err 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 != expectedItemNumPut {
return nil, event.WrongNumberOfParameters(expectedItemNumPut, ln)
}

22
pkg/morph/event/container/put_test.go
View file

@ -22,55 +22,55 @@ func TestParsePut(t *testing.T) {
stackitem.NewMap(),
}
_, err := ParsePut(prms)
_, err := ParsePut(createNotifyEventFromItems(prms))
require.EqualError(t, err, event.WrongNumberOfParameters(expectedItemNumPut, len(prms)).Error())
})
t.Run("wrong container parameter", func(t *testing.T) {
_, err := ParsePut([]stackitem.Item{
_, err := ParsePut(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong signature parameter", func(t *testing.T) {
_, err := ParsePut([]stackitem.Item{
_, err := ParsePut(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(containerData),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong key parameter", func(t *testing.T) {
_, err := ParsePut([]stackitem.Item{
_, err := ParsePut(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(containerData),
stackitem.NewByteArray(signature),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("wrong session token parameter", func(t *testing.T) {
_, err := ParsePut([]stackitem.Item{
_, err := ParsePut(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(containerData),
stackitem.NewByteArray(signature),
stackitem.NewByteArray(publicKey),
stackitem.NewMap(),
})
}))
require.Error(t, err)
})
t.Run("correct behavior", func(t *testing.T) {
ev, err := ParsePut([]stackitem.Item{
ev, err := ParsePut(createNotifyEventFromItems([]stackitem.Item{
stackitem.NewByteArray(containerData),
stackitem.NewByteArray(signature),
stackitem.NewByteArray(publicKey),
stackitem.NewByteArray(token),
})
}))
require.NoError(t, err)
require.Equal(t, Put{