frostfs-node/cmd/frostfs-cli/modules/bearer/generate_override.go

package bearer

import (
	"errors"
	"fmt"
	"os"

	"git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/internal/commonflags"
	parseutil "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/frostfs-cli/modules/util"
	commonCmd "git.frostfs.info/TrueCloudLab/frostfs-node/cmd/internal/common"
	apeSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/ape"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/bearer"
	cidSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
	apechain "git.frostfs.info/TrueCloudLab/policy-engine/pkg/chain"
	"github.com/spf13/cobra"
)

var (
	errChainIDCannotBeEmpty = errors.New("chain id cannot be empty")
	errRuleIsNotParsed      = errors.New("rule is not passed")
)

const (
	chainIDFlag    = "chain-id"
	chainIDHexFlag = "chain-id-hex"
	ruleFlag       = "rule"
	pathFlag       = "path"
	outputFlag     = "output"
)

var generateAPEOverrideCmd = &cobra.Command{
	Use:   "generate-ape-override",
	Short: "Generate APE override.",
	Long: `Generate APE override by target and APE chains. Util command.

Generated APE override can be dumped to a file in JSON format that is passed to
"create" command.
`,
	Run: genereateAPEOverride,
}

func genereateAPEOverride(cmd *cobra.Command, _ []string) {
	c := parseChain(cmd)

	targetCID, _ := cmd.Flags().GetString(commonflags.CIDFlag)
	var cid cidSDK.ID
	commonCmd.ExitOnErr(cmd, "invalid cid format: %w", cid.DecodeString(targetCID))

	override := &bearer.APEOverride{
		Target: apeSDK.ChainTarget{
			TargetType: apeSDK.TargetTypeContainer,
			Name:       targetCID,
		},
		Chains: []apeSDK.Chain{
			{
				Raw: c.Bytes(),
			},
		},
	}

	overrideMarshalled, err := override.MarshalJSON()
	commonCmd.ExitOnErr(cmd, "failed to marshal APE override: %w", err)

	outputPath, _ := cmd.Flags().GetString(outputFlag)
	if outputPath != "" {
		err := os.WriteFile(outputPath, []byte(overrideMarshalled), 0o644)
		commonCmd.ExitOnErr(cmd, "dump error: %w", err)
	} else {
		fmt.Print("\n")
		fmt.Println(string(overrideMarshalled))
	}
}

func init() {
	ff := generateAPEOverrideCmd.Flags()

	ff.StringP(commonflags.CIDFlag, "", "", "Target container ID.")
	_ = cobra.MarkFlagRequired(createCmd.Flags(), commonflags.CIDFlag)

	ff.StringArray(ruleFlag, []string{}, "Rule statement")
	ff.String(pathFlag, "", "Path to encoded chain in JSON or binary format")
	ff.String(chainIDFlag, "", "Assign ID to the parsed chain")
	ff.Bool(chainIDHexFlag, false, "Flag to parse chain ID as hex")

	ff.String(outputFlag, "", "Output path to dump result JSON-encoded APE override")
	_ = cobra.MarkFlagFilename(createCmd.Flags(), outputFlag)
}

func parseChainID(cmd *cobra.Command) apechain.ID {
	chainID, _ := cmd.Flags().GetString(chainIDFlag)
	if chainID == "" {
		commonCmd.ExitOnErr(cmd, "read chain id error: %w",
			errChainIDCannotBeEmpty)
	}
	return apechain.ID(chainID)
}

func parseChain(cmd *cobra.Command) *apechain.Chain {
	chain := new(apechain.Chain)

	if rules, _ := cmd.Flags().GetStringArray(ruleFlag); len(rules) > 0 {
		commonCmd.ExitOnErr(cmd, "parser error: %w", parseutil.ParseAPEChain(chain, rules))
	} else if encPath, _ := cmd.Flags().GetString(pathFlag); encPath != "" {
		commonCmd.ExitOnErr(cmd, "decode binary or json error: %w", parseutil.ParseAPEChainBinaryOrJSON(chain, encPath))
	} else {
		commonCmd.ExitOnErr(cmd, "parser error: %w", errRuleIsNotParsed)
	}

	chain.ID = parseChainID(cmd)

	cmd.Println("Parsed chain:")
	parseutil.PrintHumanReadableAPEChain(cmd, chain)

	return chain
}