frostfs-node/cmd/frostfs-adm/internal/modules/morph/config/config.go

package config

import (
	"bytes"
	"encoding/binary"
	"encoding/hex"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"text/tabwriter"

	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/constants"
	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-adm/internal/modules/morph/helper"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/morph/client/netmap"
	"github.com/nspcc-dev/neo-go/pkg/io"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/invoker"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/management"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/unwrap"
	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
	"github.com/nspcc-dev/neo-go/pkg/vm/emit"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

const forceConfigSet = "force"

func dumpNetworkConfig(cmd *cobra.Command, _ []string) error {
	c, err := helper.GetN3Client(viper.GetViper())
	if err != nil {
		return fmt.Errorf("can't create N3 client: %w", err)
	}

	inv := invoker.New(c, nil)
	r := management.NewReader(inv)

	cs, err := helper.GetContractByID(r, 1)
	if err != nil {
		return fmt.Errorf("can't get NNS contract info: %w", err)
	}

	nmHash, err := helper.NNSResolveHash(inv, cs.Hash, helper.DomainOf(constants.NetmapContract))
	if err != nil {
		return fmt.Errorf("can't get netmap contract hash: %w", err)
	}

	arr, err := unwrap.Array(inv.Call(nmHash, "listConfig"))
	if err != nil {
		return errors.New("can't fetch list of network config keys from the netmap contract")
	}

	buf := bytes.NewBuffer(nil)
	tw := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)

	m, err := helper.ParseConfigFromNetmapContract(arr)
	if err != nil {
		return err
	}
	for k, v := range m {
		switch k {
		case netmap.ContainerFeeConfig, netmap.ContainerAliasFeeConfig,
			netmap.EpochDurationConfig, netmap.IrCandidateFeeConfig,
			netmap.MaxObjectSizeConfig, netmap.WithdrawFeeConfig,
			netmap.MaxECDataCountConfig, netmap.MaxECParityCountConfig:
			nbuf := make([]byte, 8)
			copy(nbuf[:], v)
			n := binary.LittleEndian.Uint64(nbuf)
			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%d (int)\n", k, n)))
		case netmap.HomomorphicHashingDisabledKey, netmap.MaintenanceModeAllowedConfig:
			if len(v) == 0 || len(v) > 1 {
				return helper.InvalidConfigValueErr(k)
			}
			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%t (bool)\n", k, v[0] == 1)))
		default:
			_, _ = tw.Write([]byte(fmt.Sprintf("%s:\t%s (hex)\n", k, hex.EncodeToString(v))))
		}
	}

	_ = tw.Flush()
	cmd.Print(buf.String())

	return nil
}

func SetConfigCmd(cmd *cobra.Command, args []string) error {
	if len(args) == 0 {
		return errors.New("empty config pairs")
	}

	wCtx, err := helper.NewInitializeContext(cmd, viper.GetViper())
	if err != nil {
		return fmt.Errorf("can't initialize context: %w", err)
	}

	r := management.NewReader(wCtx.ReadOnlyInvoker)
	cs, err := helper.GetContractByID(r, 1)
	if err != nil {
		return fmt.Errorf("can't get NNS contract info: %w", err)
	}

	nmHash, err := helper.NNSResolveHash(wCtx.ReadOnlyInvoker, cs.Hash, helper.DomainOf(constants.NetmapContract))
	if err != nil {
		return fmt.Errorf("can't get netmap contract hash: %w", err)
	}

	forceFlag, _ := cmd.Flags().GetBool(forceConfigSet)
	bw := io.NewBufBinWriter()
	prm := make(map[string]any)
	for _, arg := range args {
		k, v, err := parseConfigPair(arg, forceFlag)
		if err != nil {
			return err
		}

		prm[k] = v
	}

	if err := validateConfig(prm, forceFlag); err != nil {
		return err
	}

	for k, v := range prm {
		// In NeoFS this is done via Notary contract. Here, however, we can form the
		// transaction locally. The first `nil` argument is required only for notary
		// disabled environment which is not supported by that command.
		emit.AppCall(bw.BinWriter, nmHash, "setConfig", callflag.All, nil, k, v)
		if bw.Err != nil {
			return fmt.Errorf("can't form raw transaction: %w", bw.Err)
		}
	}

	err = wCtx.SendConsensusTx(bw.Bytes())
	if err != nil {
		return err
	}

	return wCtx.AwaitTx()
}

const maxECSum = 256

func validateConfig(args map[string]any, forceFlag bool) error {
	var sumEC int64
	_, okData := args[netmap.MaxECDataCountConfig]
	_, okParity := args[netmap.MaxECParityCountConfig]
	if okData != okParity {
		return fmt.Errorf("both %s and %s must be present in the configuration",
			netmap.MaxECDataCountConfig, netmap.MaxECParityCountConfig)
	}

	for k, v := range args {
		switch k {
		case netmap.ContainerFeeConfig, netmap.ContainerAliasFeeConfig,
			netmap.EpochDurationConfig, netmap.IrCandidateFeeConfig,
			netmap.MaxObjectSizeConfig, netmap.WithdrawFeeConfig,
			netmap.MaxECDataCountConfig, netmap.MaxECParityCountConfig:
			value, ok := v.(int64)
			if !ok {
				return fmt.Errorf("%s has an invalid type. Expected type: int", k)
			}

			if value < 0 {
				return fmt.Errorf("%s must be >= 0, got %v", k, v)
			}

			if k == netmap.MaxECDataCountConfig || k == netmap.MaxECParityCountConfig {
				sumEC += value
			}
		case netmap.HomomorphicHashingDisabledKey, netmap.MaintenanceModeAllowedConfig:
			_, ok := v.(bool)
			if !ok {
				return fmt.Errorf("%s has an invalid type. Expected type: bool", k)
			}
		}
	}

	if sumEC > maxECSum && !forceFlag {
		return fmt.Errorf("the sum of %s and %s must be <= %d, got %d",
			netmap.MaxECDataCountConfig, netmap.MaxECParityCountConfig, maxECSum, sumEC)
	}
	return nil
}

func parseConfigPair(kvStr string, force bool) (key string, val any, err error) {
	k, v, found := strings.Cut(kvStr, "=")
	if !found {
		return "", nil, fmt.Errorf("invalid parameter format: must be 'key=val', got: %s", kvStr)
	}

	key = k
	valRaw := v

	switch key {
	case netmap.ContainerFeeConfig, netmap.ContainerAliasFeeConfig,
		netmap.EpochDurationConfig, netmap.IrCandidateFeeConfig,
		netmap.MaxObjectSizeConfig, netmap.WithdrawFeeConfig,
		netmap.MaxECDataCountConfig, netmap.MaxECParityCountConfig:
		val, err = strconv.ParseInt(valRaw, 10, 64)
		if err != nil {
			err = fmt.Errorf("could not parse %s's value '%s' as int: %w", key, valRaw, err)
		}
	case netmap.HomomorphicHashingDisabledKey, netmap.MaintenanceModeAllowedConfig:
		val, err = strconv.ParseBool(valRaw)
		if err != nil {
			err = fmt.Errorf("could not parse %s's value '%s' as bool: %w", key, valRaw, err)
		}

	default:
		if !force {
			return "", nil, fmt.Errorf(
				"'%s' key is not well-known, use '--%s' flag if want to set it anyway",
				key, forceConfigSet)
		}

		val = valRaw
	}

	return
}