119 lines
2.8 KiB
Go
119 lines
2.8 KiB
Go
package frostfsid
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
frostfsidclient "git.frostfs.info/TrueCloudLab/frostfs-contract/frostfsid/client"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
|
|
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
|
|
"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
|
|
)
|
|
|
|
const methodGetSubject = "getSubject"
|
|
|
|
func (c *Client) GetSubject(addr util.Uint160) (*frostfsidclient.Subject, error) {
|
|
prm := client.TestInvokePrm{}
|
|
prm.SetMethod(methodGetSubject)
|
|
prm.SetArgs(addr)
|
|
|
|
res, err := c.client.TestInvoke(prm)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not perform test invocation (%s): %w", methodGetSubject, err)
|
|
}
|
|
|
|
subj, err := parseSubject(res)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not parse test invocation result (%s): %w", methodGetSubject, err)
|
|
}
|
|
|
|
return subj, nil
|
|
}
|
|
|
|
func parseSubject(res []stackitem.Item) (*frostfsidclient.Subject, error) {
|
|
if ln := len(res); ln != 1 {
|
|
return nil, fmt.Errorf("unexpected stack item count (%s): %d", methodGetSubject, ln)
|
|
}
|
|
|
|
structArr, err := client.ArrayFromStackItem(res[0])
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not get item array of container (%s): %w", methodGetSubject, err)
|
|
}
|
|
|
|
var subj frostfsidclient.Subject
|
|
|
|
subj.PrimaryKey, err = unwrap.PublicKey(makeValidRes(structArr[0]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !structArr[1].Equals(stackitem.Null{}) {
|
|
subj.AdditionalKeys, err = unwrap.ArrayOfPublicKeys(makeValidRes(structArr[1]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if !structArr[2].Equals(stackitem.Null{}) {
|
|
subj.Namespace, err = unwrap.UTF8String(makeValidRes(structArr[2]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if !structArr[3].Equals(stackitem.Null{}) {
|
|
subj.Name, err = unwrap.UTF8String(makeValidRes(structArr[3]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
subj.KV, err = parseMap(structArr[4])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &subj, nil
|
|
}
|
|
|
|
func makeValidRes(item stackitem.Item) (*result.Invoke, error) {
|
|
return &result.Invoke{
|
|
Stack: []stackitem.Item{item},
|
|
State: vmstate.Halt.String(),
|
|
}, nil
|
|
}
|
|
|
|
func parseMap(item stackitem.Item) (map[string]string, error) {
|
|
if item.Equals(stackitem.Null{}) {
|
|
return nil, nil
|
|
}
|
|
|
|
metaMap, err := unwrap.Map(makeValidRes(item))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
meta, ok := metaMap.Value().([]stackitem.MapElement)
|
|
if !ok {
|
|
return nil, errors.New("invalid map type")
|
|
}
|
|
|
|
res := make(map[string]string, len(meta))
|
|
for _, element := range meta {
|
|
key, err := element.Key.TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
val, err := element.Value.TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res[string(key)] = string(val)
|
|
}
|
|
|
|
return res, nil
|
|
}
|