frostfs-node/pkg/morph/client/netmap/netmap.go

148 lines
3.5 KiB
Go
Raw Normal View History

2020-07-24 13:54:03 +00:00
package netmap
import (
"fmt"
netmapcontract "git.frostfs.info/TrueCloudLab/frostfs-contract/netmap"
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
2020-07-24 13:54:03 +00:00
)
// GetNetMapByEpoch calls "snapshotByEpoch" method with the given epoch and
// decodes netmap.NetMap from the response.
func (c *Client) GetNetMapByEpoch(epoch uint64) (*netmap.NetMap, error) {
invokePrm := client.TestInvokePrm{}
invokePrm.SetMethod(epochSnapshotMethod)
invokePrm.SetArgs(epoch)
res, err := c.client.TestInvoke(invokePrm)
2020-07-24 13:54:03 +00:00
if err != nil {
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
epochSnapshotMethod, err)
}
nm, err := DecodeNetMap(res)
if err != nil {
return nil, err
}
nm.SetEpoch(epoch)
return nm, err
}
// GetCandidates calls "netmapCandidates" method and decodes []netmap.NodeInfo
// from the response.
func (c *Client) GetCandidates() ([]netmap.NodeInfo, error) {
invokePrm := client.TestInvokePrm{}
invokePrm.SetMethod(netMapCandidatesMethod)
res, err := c.client.TestInvoke(invokePrm)
if err != nil {
return nil, fmt.Errorf("could not perform test invocation (%s): %w", netMapCandidatesMethod, err)
}
if len(res) > 0 {
return decodeNodeList(res[0])
}
return nil, nil
}
// NetMap calls "netmap" method and decode netmap.NetMap from the response.
func (c *Client) NetMap() (*netmap.NetMap, error) {
invokePrm := client.TestInvokePrm{}
invokePrm.SetMethod(netMapMethod)
res, err := c.client.TestInvoke(invokePrm)
if err != nil {
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
netMapMethod, err)
}
return DecodeNetMap(res)
}
func DecodeNetMap(resStack []stackitem.Item) (*netmap.NetMap, error) {
var nm netmap.NetMap
if len(resStack) > 0 {
nodes, err := decodeNodeList(resStack[0])
if err != nil {
return nil, err
}
nm.SetNodes(nodes)
}
return &nm, nil
}
func decodeNodeList(itemNodes stackitem.Item) ([]netmap.NodeInfo, error) {
itemArrNodes, err := client.ArrayFromStackItem(itemNodes)
if err != nil {
return nil, fmt.Errorf("decode item array of nodes from the response item: %w", err)
}
var nodes []netmap.NodeInfo
if len(itemArrNodes) > 0 {
nodes = make([]netmap.NodeInfo, len(itemArrNodes))
for i := range itemArrNodes {
err = decodeNodeInfo(&nodes[i], itemArrNodes[i])
if err != nil {
return nil, fmt.Errorf("decode node #%d: %w", i+1, err)
}
}
}
return nodes, nil
}
func decodeNodeInfo(dst *netmap.NodeInfo, itemNode stackitem.Item) error {
nodeFields, err := client.ArrayFromStackItem(itemNode)
if err != nil {
return fmt.Errorf("decode item array of node fields: %w", err)
2020-07-24 13:54:03 +00:00
}
var node netmapcontract.Node
if len(nodeFields) > 0 {
node.BLOB, err = client.BytesFromStackItem(nodeFields[0])
if err != nil {
return fmt.Errorf("decode node info BLOB: %w", err)
}
2020-07-24 13:54:03 +00:00
}
node.State = netmapcontract.NodeStateOnline
2020-07-24 13:54:03 +00:00
if len(nodeFields) > 1 {
state, err := client.IntFromStackItem(nodeFields[1])
2020-07-24 13:54:03 +00:00
if err != nil {
return fmt.Errorf("decode integer from 2nd item: %w", err)
2020-07-24 13:54:03 +00:00
}
node.State = netmapcontract.NodeState(state)
2020-07-24 13:54:03 +00:00
}
err = dst.Unmarshal(node.BLOB)
2020-07-24 13:54:03 +00:00
if err != nil {
return fmt.Errorf("decode node info: %w", err)
}
switch node.State {
default:
return fmt.Errorf("unsupported state %v", node.State)
case netmapcontract.NodeStateOnline:
dst.SetOnline()
case netmapcontract.NodeStateOffline:
dst.SetOffline()
case netmapcontract.NodeStateMaintenance:
dst.SetMaintenance()
2020-07-24 13:54:03 +00:00
}
return nil
2020-07-24 13:54:03 +00:00
}