frostfs-sdk-go/netmap/node_info.go

package netmap

import (
	"github.com/nspcc-dev/neofs-api-go/v2/netmap"
)

// NodeState is an enumeration of various states of the NeoFS node.
type NodeState uint32

// NodeAttribute represents v2 compatible attribute of the NeoFS Storage Node.
type NodeAttribute netmap.Attribute

// NodeInfo represents v2 compatible descriptor of the NeoFS node.
type NodeInfo struct {
	priceAttr uint64

	capAttr uint64

	m *netmap.NodeInfo
}

const (
	_ NodeState = iota

	// NodeStateOffline is network unavailable state.
	NodeStateOffline

	// NodeStateOnline is an active state in the network.
	NodeStateOnline
)

// Enumeration of well-known attributes.
const (
	// AttrPrice is a key to the node attribute that indicates the
	// price in GAS tokens for storing one GB of data during one Epoch.
	AttrPrice = "Price"

	// AttrCapacity is a key to the node attribute that indicates the
	// total available disk space in Gigabytes.
	AttrCapacity = "Capacity"

	// AttrSubnet is a key to the node attribute that indicates the
	// string ID of node's storage subnet.
	AttrSubnet = "Subnet"

	// AttrUNLOCODE is a key to the node attribute that indicates the
	// node's geographic location in UN/LOCODE format.
	AttrUNLOCODE = "UN-LOCODE"

	// AttrCountryCode is a key to the node attribute that indicates the
	// Country code in ISO 3166-1_alpha-2 format.
	AttrCountryCode = "CountryCode"

	// AttrCountry is a key to the node attribute that indicates the
	// country short name in English, as defined in ISO-3166.
	AttrCountry = "Country"

	// AttrLocation is a key to the node attribute that indicates the
	// place name of the node location.
	AttrLocation = "Location"

	// AttrSubDivCode is a key to the node attribute that indicates the
	// country's administrative subdivision where node is located
	// in ISO 3166-2 format.
	AttrSubDivCode = "SubDivCode"

	// AttrSubDiv is a key to the node attribute that indicates the
	// country's administrative subdivision name, as defined in
	// ISO 3166-2.
	AttrSubDiv = "SubDiv"

	// AttrContinent is a key to the node attribute that indicates the
	// node's continent name according to the Seven-Continent model.
	AttrContinent = "Continent"
)

// calcBucketWeight computes weight for a Bucket.
func calcBucketWeight(ns nodes, a aggregator, wf weightFunc) float64 {
	for i := range ns {
		a.Add(wf(ns[i]))
	}

	return a.Compute()
}

// NodeStateFromV2 converts v2 NodeState to NodeState.
func NodeStateFromV2(s netmap.NodeState) NodeState {
	switch s {
	default:
		return 0
	case netmap.Online:
		return NodeStateOnline
	case netmap.Offline:
		return NodeStateOffline
	}
}

// ToV2 converts NodeState to v2 NodeState.
func (s NodeState) ToV2() netmap.NodeState {
	switch s {
	default:
		return netmap.UnspecifiedState
	case NodeStateOffline:
		return netmap.Offline
	case NodeStateOnline:
		return netmap.Online
	}
}

// String returns string representation of NodeState.
//
// String mapping:
//  * NodeStateOnline: ONLINE;
//  * NodeStateOffline: OFFLINE;
//  * default: UNSPECIFIED.
func (s NodeState) String() string {
	return s.ToV2().String()
}

// FromString parses NodeState from a string representation.
// It is a reverse action to String().
//
// Returns true if s was parsed successfully.
func (s *NodeState) FromString(str string) bool {
	var g netmap.NodeState

	ok := g.FromString(str)

	if ok {
		*s = NodeStateFromV2(g)
	}

	return ok
}

// NewNodeAttribute creates and returns new NodeAttribute instance.
//
// Defaults:
//  - key: "";
//  - value: "";
//  - parents: nil.
func NewNodeAttribute() *NodeAttribute {
	return NewNodeAttributeFromV2(new(netmap.Attribute))
}

// NodeAttributeFromV2 converts v2 node Attribute to NodeAttribute.
//
// Nil netmap.Attribute converts to nil.
func NewNodeAttributeFromV2(a *netmap.Attribute) *NodeAttribute {
	return (*NodeAttribute)(a)
}

// ToV2 converts NodeAttribute to v2 node Attribute.
//
// Nil NodeAttribute converts to nil.
func (a *NodeAttribute) ToV2() *netmap.Attribute {
	return (*netmap.Attribute)(a)
}

// Key returns key to the node attribute.
func (a *NodeAttribute) Key() string {
	return (*netmap.Attribute)(a).
		GetKey()
}

// SetKey sets key to the node attribute.
func (a *NodeAttribute) SetKey(key string) {
	(*netmap.Attribute)(a).
		SetKey(key)
}

// Value returns value of the node attribute.
func (a *NodeAttribute) Value() string {
	return (*netmap.Attribute)(a).
		GetValue()
}

// SetValue sets value of the node attribute.
func (a *NodeAttribute) SetValue(val string) {
	(*netmap.Attribute)(a).
		SetValue(val)
}

// ParentKeys returns list of parent keys.
func (a *NodeAttribute) ParentKeys() []string {
	return (*netmap.Attribute)(a).
		GetParents()
}

// SetParentKeys sets list of parent keys.
func (a *NodeAttribute) SetParentKeys(keys ...string) {
	(*netmap.Attribute)(a).
		SetParents(keys)
}

// Marshal marshals NodeAttribute into a protobuf binary form.
func (a *NodeAttribute) Marshal() ([]byte, error) {
	return (*netmap.Attribute)(a).StableMarshal(nil), nil
}

// Unmarshal unmarshals protobuf binary representation of NodeAttribute.
func (a *NodeAttribute) Unmarshal(data []byte) error {
	return (*netmap.Attribute)(a).Unmarshal(data)
}

// MarshalJSON encodes NodeAttribute to protobuf JSON format.
func (a *NodeAttribute) MarshalJSON() ([]byte, error) {
	return (*netmap.Attribute)(a).MarshalJSON()
}

// UnmarshalJSON decodes NodeAttribute from protobuf JSON format.
func (a *NodeAttribute) UnmarshalJSON(data []byte) error {
	return (*netmap.Attribute)(a).UnmarshalJSON(data)
}

// NewNodeInfo creates and returns new NodeInfo instance.
//
// Defaults:
//  - publicKey: nil;
//  - address: "";
//  - attributes nil;
//  - state: 0.
func NewNodeInfo() *NodeInfo {
	return NewNodeInfoFromV2(new(netmap.NodeInfo))
}

// NewNodeInfoFromV2 converts v2 NodeInfo to NodeInfo.
//
// Nil netmap.NodeInfo converts to nil.
func NewNodeInfoFromV2(i *netmap.NodeInfo) *NodeInfo {
	var res NodeInfo
	res.m = i
	res.syncAttributes()

	return &res
}

// ToV2 converts NodeInfo to v2 NodeInfo.
//
// Nil NodeInfo converts to nil.
func (i *NodeInfo) ToV2() *netmap.NodeInfo {
	if i == nil {
		return nil
	}

	return i.m
}

// PublicKey returns public key of the node in a binary format.
func (i *NodeInfo) PublicKey() []byte {
	return i.m.GetPublicKey()
}

// SetPublicKey sets public key of the node in a binary format.
func (i *NodeInfo) SetPublicKey(key []byte) {
	if i.m == nil {
		i.m = new(netmap.NodeInfo)
	}

	i.m.SetPublicKey(key)
}

// NumberOfAddresses returns number of network addresses of the node.
func (i *NodeInfo) NumberOfAddresses() int {
	return i.m.NumberOfAddresses()
}

// IterateAddresses iterates over network addresses of the node.
// Breaks iteration on f's true return.
//
// Handler should not be nil.
func (i *NodeInfo) IterateAddresses(f func(string) bool) {
	i.m.IterateAddresses(f)
}

// IterateAllAddresses is a helper function to unconditionally
// iterate over all node addresses.
func IterateAllAddresses(i *NodeInfo, f func(string)) {
	i.IterateAddresses(func(addr string) bool {
		f(addr)
		return false
	})
}

// SetAddresses sets list of network addresses of the node.
func (i *NodeInfo) SetAddresses(v ...string) {
	if i.m == nil {
		i.m = new(netmap.NodeInfo)
	}

	i.m.SetAddresses(v...)
}

// Attributes returns list of the node attributes.
func (i *NodeInfo) Attributes() []NodeAttribute {
	if i == nil {
		return nil
	}

	as := i.m.GetAttributes()

	if as == nil {
		return nil
	}

	res := make([]NodeAttribute, len(as))

	for ind := range as {
		res[ind] = *NewNodeAttributeFromV2(&as[ind])
	}

	return res
}

// SetAttributes sets list of the node attributes.
func (i *NodeInfo) SetAttributes(as ...NodeAttribute) {
	asV2 := make([]netmap.Attribute, len(as))

	for ind := range as {
		asV2[ind] = *as[ind].ToV2()
	}

	if i.m == nil {
		i.m = new(netmap.NodeInfo)
	}

	i.m.SetAttributes(asV2)
}

// State returns node state.
func (i *NodeInfo) State() NodeState {
	return NodeStateFromV2(i.m.GetState())
}

// SetState sets node state.
func (i *NodeInfo) SetState(s NodeState) {
	if i.m == nil {
		i.m = new(netmap.NodeInfo)
	}

	i.m.SetState(s.ToV2())
}

// Marshal marshals NodeInfo into a protobuf binary form.
func (i *NodeInfo) Marshal() ([]byte, error) {
	return i.m.StableMarshal(nil), nil
}

// Unmarshal unmarshals protobuf binary representation of NodeInfo.
func (i *NodeInfo) Unmarshal(data []byte) error {
	if i.m == nil {
		i.m = new(netmap.NodeInfo)
	}

	return i.m.Unmarshal(data)
}

// MarshalJSON encodes NodeInfo to protobuf JSON format.
func (i *NodeInfo) MarshalJSON() ([]byte, error) {
	return i.m.MarshalJSON()
}

// UnmarshalJSON decodes NodeInfo from protobuf JSON format.
func (i *NodeInfo) UnmarshalJSON(data []byte) error {
	if i.m == nil {
		i.m = new(netmap.NodeInfo)
	}

	err := i.m.UnmarshalJSON(data)
	if err != nil {
		return err
	}

	i.syncAttributes()

	return nil
}