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

354 lines
9.3 KiB
Go
Raw Permalink Normal View History

package netmap
import (
"errors"
"fmt"
"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client"
"github.com/nspcc-dev/neo-go/pkg/encoding/bigint"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
)
const (
MaxObjectSizeConfig = "MaxObjectSize"
EpochDurationConfig = "EpochDuration"
ContainerFeeConfig = "ContainerFee"
ContainerAliasFeeConfig = "ContainerAliasFee"
IrCandidateFeeConfig = "InnerRingCandidateFee"
WithdrawFeeConfig = "WithdrawFee"
HomomorphicHashingDisabledKey = "HomomorphicHashingDisabled"
MaintenanceModeAllowedConfig = "MaintenanceModeAllowed"
)
// MaxObjectSize receives max object size configuration
// value through the Netmap contract call.
func (c *Client) MaxObjectSize() (uint64, error) {
objectSize, err := c.readUInt64Config(MaxObjectSizeConfig)
if err != nil {
return 0, fmt.Errorf("(%T) could not get epoch number: %w", c, err)
}
return objectSize, nil
}
// EpochDuration returns number of sidechain blocks per one FrostFS epoch.
func (c *Client) EpochDuration() (uint64, error) {
epochDuration, err := c.readUInt64Config(EpochDurationConfig)
if err != nil {
return 0, fmt.Errorf("(%T) could not get epoch duration: %w", c, err)
}
return epochDuration, nil
}
// ContainerFee returns fee paid by container owner to each alphabet node
// for container registration.
func (c *Client) ContainerFee() (uint64, error) {
fee, err := c.readUInt64Config(ContainerFeeConfig)
if err != nil {
return 0, fmt.Errorf("(%T) could not get container fee: %w", c, err)
}
return fee, nil
}
// ContainerAliasFee returns additional fee paid by container owner to each
// alphabet node for container nice name registration.
func (c *Client) ContainerAliasFee() (uint64, error) {
fee, err := c.readUInt64Config(ContainerAliasFeeConfig)
if err != nil {
return 0, fmt.Errorf("(%T) could not get container alias fee: %w", c, err)
}
return fee, nil
}
// HomomorphicHashDisabled returns global configuration value of homomorphic hashing
// settings.
//
// Returns (false, nil) if config key is not found in the contract.
func (c *Client) HomomorphicHashDisabled() (bool, error) {
return c.readBoolConfig(HomomorphicHashingDisabledKey)
}
// InnerRingCandidateFee returns global configuration value of fee paid by
// node to be in inner ring candidates list.
func (c *Client) InnerRingCandidateFee() (uint64, error) {
fee, err := c.readUInt64Config(IrCandidateFeeConfig)
if err != nil {
return 0, fmt.Errorf("(%T) could not get inner ring candidate fee: %w", c, err)
}
return fee, nil
}
// WithdrawFee returns global configuration value of fee paid by user to
// withdraw assets from FrostFS contract.
func (c *Client) WithdrawFee() (uint64, error) {
fee, err := c.readUInt64Config(WithdrawFeeConfig)
if err != nil {
return 0, fmt.Errorf("(%T) could not get withdraw fee: %w", c, err)
}
return fee, nil
}
// MaintenanceModeAllowed reads admission of "maintenance" state from the
// FrostFS network configuration stored in the Sidechain. The admission means
// that storage nodes are allowed to switch their state to "maintenance".
//
// By default, maintenance state is disallowed.
func (c *Client) MaintenanceModeAllowed() (bool, error) {
return c.readBoolConfig(MaintenanceModeAllowedConfig)
}
func (c *Client) readUInt64Config(key string) (uint64, error) {
v, err := c.config([]byte(key), IntegerAssert)
if err != nil {
return 0, err
}
// IntegerAssert is guaranteed to return int64 if the error is nil.
return uint64(v.(int64)), nil
}
// reads boolean value by the given key from the FrostFS network configuration
// stored in the Sidechain. Returns false if key is not presented.
func (c *Client) readBoolConfig(key string) (bool, error) {
v, err := c.config([]byte(key), BoolAssert)
if err != nil {
if errors.Is(err, ErrConfigNotFound) {
return false, nil
}
return false, fmt.Errorf("read boolean configuration value %s from the Sidechain: %w", key, err)
}
// BoolAssert is guaranteed to return bool if the error is nil.
return v.(bool), nil
}
// SetConfigPrm groups parameters of SetConfig operation.
type SetConfigPrm struct {
id []byte
key []byte
value any
client.InvokePrmOptional
}
// SetID sets ID of the config value.
func (s *SetConfigPrm) SetID(id []byte) {
s.id = id
}
// SetKey sets key of the config value.
func (s *SetConfigPrm) SetKey(key []byte) {
s.key = key
}
// SetValue sets value of the config value.
func (s *SetConfigPrm) SetValue(value any) {
s.value = value
}
// SetConfig sets config field.
func (c *Client) SetConfig(p SetConfigPrm) error {
prm := client.InvokePrm{}
prm.SetMethod(setConfigMethod)
prm.SetArgs(p.id, p.key, p.value)
prm.InvokePrmOptional = p.InvokePrmOptional
_, err := c.client.Invoke(prm)
return err
}
// RawNetworkParameter is a FrostFS network parameter which is transmitted but
// not interpreted by the FrostFS API protocol.
type RawNetworkParameter struct {
// Name of the parameter.
Name string
// Raw parameter value.
Value []byte
}
// NetworkConfiguration represents FrostFS network configuration stored
// in the FrostFS Sidechain.
type NetworkConfiguration struct {
MaxObjectSize uint64
EpochDuration uint64
ContainerFee uint64
ContainerAliasFee uint64
IRCandidateFee uint64
WithdrawalFee uint64
HomomorphicHashingDisabled bool
MaintenanceModeAllowed bool
Raw []RawNetworkParameter
}
// ReadNetworkConfiguration reads NetworkConfiguration from the FrostFS Sidechain.
func (c *Client) ReadNetworkConfiguration() (NetworkConfiguration, error) {
var res NetworkConfiguration
prm := client.TestInvokePrm{}
prm.SetMethod(configListMethod)
items, err := c.client.TestInvoke(prm)
if err != nil {
return res, fmt.Errorf("could not perform test invocation (%s): %w",
configListMethod, err)
}
if ln := len(items); ln != 1 {
return res, fmt.Errorf("unexpected stack item count (%s): %d", configListMethod, ln)
}
arr, err := client.ArrayFromStackItem(items[0])
if err != nil {
return res, fmt.Errorf("record list (%s): %w", configListMethod, err)
}
m := make(map[string]struct{}, len(arr))
res.Raw = make([]RawNetworkParameter, 0, len(arr))
err = iterateRecords(arr, func(name string, value []byte) error {
_, ok := m[name]
if ok {
return fmt.Errorf("duplicated config name %s", name)
}
m[name] = struct{}{}
switch name {
default:
res.Raw = append(res.Raw, RawNetworkParameter{
Name: name,
Value: value,
})
case MaxObjectSizeConfig:
res.MaxObjectSize = bytesToUint64(value)
case EpochDurationConfig:
res.EpochDuration = bytesToUint64(value)
case ContainerFeeConfig:
res.ContainerFee = bytesToUint64(value)
case ContainerAliasFeeConfig:
res.ContainerAliasFee = bytesToUint64(value)
case IrCandidateFeeConfig:
res.IRCandidateFee = bytesToUint64(value)
case WithdrawFeeConfig:
res.WithdrawalFee = bytesToUint64(value)
case HomomorphicHashingDisabledKey:
res.HomomorphicHashingDisabled = bytesToBool(value)
case MaintenanceModeAllowedConfig:
res.MaintenanceModeAllowed = bytesToBool(value)
}
return nil
})
return res, err
}
func bytesToUint64(val []byte) uint64 {
if len(val) == 0 {
return 0
}
return bigint.FromBytes(val).Uint64()
}
func bytesToBool(val []byte) bool {
for i := range val {
if val[i] != 0 {
return true
}
}
return false
}
// ErrConfigNotFound is returned when the requested key was not found
// in the network config (returned value is `Null`).
var ErrConfigNotFound = errors.New("config value not found")
// config performs the test invoke of get config value
// method of FrostFS Netmap contract.
//
// Returns ErrConfigNotFound if config key is not found in the contract.
func (c *Client) config(key []byte, assert func(stackitem.Item) (any, error)) (any, error) {
prm := client.TestInvokePrm{}
prm.SetMethod(configMethod)
prm.SetArgs(key)
items, err := c.client.TestInvoke(prm)
if err != nil {
return nil, fmt.Errorf("could not perform test invocation (%s): %w",
configMethod, err)
}
if ln := len(items); ln != 1 {
return nil, fmt.Errorf("unexpected stack item count (%s): %d",
configMethod, ln)
}
if _, ok := items[0].(stackitem.Null); ok {
return nil, ErrConfigNotFound
}
return assert(items[0])
}
// IntegerAssert converts stack item to int64.
func IntegerAssert(item stackitem.Item) (any, error) {
return client.IntFromStackItem(item)
}
// StringAssert converts stack item to string.
func StringAssert(item stackitem.Item) (any, error) {
return client.StringFromStackItem(item)
}
// BoolAssert converts stack item to bool.
func BoolAssert(item stackitem.Item) (any, error) {
return client.BoolFromStackItem(item)
}
// iterateRecords iterates over all config records and passes them to f.
//
// Returns f's errors directly.
func iterateRecords(arr []stackitem.Item, f func(key string, value []byte) error) error {
for i := range arr {
fields, err := client.ArrayFromStackItem(arr[i])
if err != nil {
return fmt.Errorf("record fields: %w", err)
}
if ln := len(fields); ln != 2 {
return fmt.Errorf("unexpected record fields number: %d", ln)
}
k, err := client.BytesFromStackItem(fields[0])
if err != nil {
return fmt.Errorf("record key: %w", err)
}
v, err := client.BytesFromStackItem(fields[1])
if err != nil {
return fmt.Errorf("record value: %w", err)
}
if err := f(string(k), v); err != nil {
return err
}
}
return nil
}