e8f8e58e90
Add `subnet` command which contains all subnet-related commands. Add sub-commands: * `create` for creation; * `remove` for removal; * `get` for reading; * `admin` for admin management; * `client` for client management. Signed-off-by: Leonard Lyubich <leonard@nspcc.ru>
711 lines
16 KiB
Go
711 lines
16 KiB
Go
package morph
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
"github.com/nspcc-dev/neofs-node/cmd/neofs-adm/internal/modules/morph/internal"
|
|
"github.com/nspcc-dev/neofs-node/pkg/morph/client"
|
|
morphsubnet "github.com/nspcc-dev/neofs-node/pkg/morph/client/subnet"
|
|
"github.com/nspcc-dev/neofs-node/pkg/util/rand"
|
|
"github.com/nspcc-dev/neofs-sdk-go/owner"
|
|
"github.com/nspcc-dev/neofs-sdk-go/subnet"
|
|
subnetid "github.com/nspcc-dev/neofs-sdk-go/subnet/id"
|
|
"github.com/spf13/cobra"
|
|
"github.com/spf13/viper"
|
|
)
|
|
|
|
// cmdSubnet flags.
|
|
const (
|
|
// Neo RPC endpoint
|
|
flagSubnetEndpoint = endpointFlag
|
|
// filepath to private key
|
|
flagSubnetKey = "key"
|
|
// contract address
|
|
flagSubnetContract = "contract"
|
|
// disable notary
|
|
flagSubnetNonNotary = "non-notary"
|
|
)
|
|
|
|
func viperBindFlags(cmd *cobra.Command, flags ...string) {
|
|
for i := range flags {
|
|
_ = viper.BindPFlag(flags[i], cmd.Flags().Lookup(flags[i]))
|
|
}
|
|
}
|
|
|
|
// subnet command section.
|
|
var cmdSubnet = &cobra.Command{
|
|
Use: "subnet",
|
|
Short: "NeoFS subnet management.",
|
|
PreRun: func(cmd *cobra.Command, _ []string) {
|
|
viperBindFlags(cmd,
|
|
flagSubnetEndpoint,
|
|
flagSubnetKey,
|
|
flagSubnetContract,
|
|
flagSubnetNonNotary,
|
|
)
|
|
},
|
|
}
|
|
|
|
// shared flags of cmdSubnet sub-commands.
|
|
const (
|
|
// subnet identifier
|
|
flagSubnet = "subnet"
|
|
// subnet client group ID
|
|
flagSubnetGroup = "group"
|
|
)
|
|
|
|
// reads private key from the filepath configured in flagSubnetKey flag.
|
|
func readSubnetKey(key *keys.PrivateKey) error {
|
|
// read key from file
|
|
keyPath := viper.GetString(flagSubnetKey)
|
|
if keyPath == "" {
|
|
return errors.New("missing path to private key")
|
|
}
|
|
|
|
data, err := os.ReadFile(keyPath)
|
|
if err != nil {
|
|
return fmt.Errorf("read private key file: %w", err)
|
|
}
|
|
|
|
// decode key
|
|
k, err := keys.NewPrivateKeyFromBytes(data)
|
|
if err != nil {
|
|
return fmt.Errorf("decode private key: %w", err)
|
|
}
|
|
|
|
*key = *k
|
|
|
|
return nil
|
|
}
|
|
|
|
// initializes morph subnet client with the specified private key.
|
|
//
|
|
// Parameters are read from:
|
|
// * contract address: flagSubnetContract;
|
|
// * endpoint: flagSubnetEndpoint;
|
|
// * non-notary mode: flagSubnetNonNotary.
|
|
func initSubnetClient(c *morphsubnet.Client, key *keys.PrivateKey) error {
|
|
// read endpoint
|
|
endpoint := viper.GetString(flagSubnetEndpoint)
|
|
if endpoint == "" {
|
|
return errors.New("missing endpoint")
|
|
}
|
|
|
|
// read contract address
|
|
contractAddr, err := util.Uint160DecodeStringLE(viper.GetString(flagSubnetContract))
|
|
if err != nil {
|
|
return fmt.Errorf("subnet contract address: %w", err)
|
|
}
|
|
|
|
// create base morph client
|
|
cMorph, err := client.New(key, endpoint)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// calc client mode
|
|
cMode := morphsubnet.NotaryNonAlphabet
|
|
|
|
if viper.GetBool(flagSubnetNonNotary) {
|
|
cMode = morphsubnet.NonNotary
|
|
}
|
|
|
|
// init subnet morph client
|
|
var prmInit morphsubnet.InitPrm
|
|
|
|
prmInit.SetBaseClient(cMorph)
|
|
prmInit.SetContractAddress(contractAddr)
|
|
prmInit.SetMode(cMode)
|
|
|
|
if err := c.Init(prmInit); err != nil {
|
|
return fmt.Errorf("init call: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// create subnet command.
|
|
var cmdSubnetCreate = &cobra.Command{
|
|
Use: "create",
|
|
Short: "Create NeoFS subnet.",
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
// read private key
|
|
var key keys.PrivateKey
|
|
|
|
err := readSubnetKey(&key)
|
|
if err != nil {
|
|
return fmt.Errorf("read private key: %w", err)
|
|
}
|
|
|
|
// calculate wallet address from key
|
|
n3Wallet, err := owner.NEO3WalletFromPublicKey(&key.PrivateKey.PublicKey)
|
|
if err != nil {
|
|
return fmt.Errorf("wallet from key: %w", err)
|
|
}
|
|
|
|
// generate subnet ID and marshal it
|
|
var (
|
|
id subnetid.ID
|
|
num uint32
|
|
)
|
|
|
|
for {
|
|
num = uint32(rand.Uint64(rand.New(), math.MaxUint32))
|
|
|
|
id.SetNumber(num)
|
|
|
|
if !subnetid.IsZero(id) {
|
|
break
|
|
}
|
|
}
|
|
|
|
binID, err := id.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal subnet ID: %w", err)
|
|
}
|
|
|
|
// declare creator ID and encode it
|
|
creator := *owner.NewIDFromNeo3Wallet(n3Wallet)
|
|
|
|
binCreator, err := creator.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal creator ID: %w", err)
|
|
}
|
|
|
|
// fill subnet info and encode it
|
|
var info subnet.Info
|
|
|
|
info.SetID(id)
|
|
info.SetOwner(creator)
|
|
|
|
binInfo, err := info.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal subnet info: %w", err)
|
|
}
|
|
|
|
// initialize morph subnet client
|
|
var cSubnet morphsubnet.Client
|
|
|
|
err = initSubnetClient(&cSubnet, &key)
|
|
if err != nil {
|
|
return fmt.Errorf("init subnet client: %w", err)
|
|
}
|
|
|
|
// prepare call parameters and create subnet
|
|
var prm morphsubnet.PutPrm
|
|
|
|
prm.SetID(binID)
|
|
prm.SetOwner(binCreator)
|
|
prm.SetInfo(binInfo)
|
|
|
|
_, err = cSubnet.Put(prm)
|
|
if err != nil {
|
|
return fmt.Errorf("morph call: %w", err)
|
|
}
|
|
|
|
cmd.Printf("Create subnet request sent successfully. ID: %s.\n", &id)
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
// cmdSubnetRemove flags.
|
|
const (
|
|
// subnet ID to be removed
|
|
flagSubnetRemoveID = flagSubnet
|
|
)
|
|
|
|
// errZeroSubnet is returned on attempts to work with zero subnet which is virtual.
|
|
var errZeroSubnet = errors.New("zero subnet")
|
|
|
|
// remove subnet command.
|
|
var cmdSubnetRemove = &cobra.Command{
|
|
Use: "remove",
|
|
Short: "Remove NeoFS subnet.",
|
|
PreRun: func(cmd *cobra.Command, _ []string) {
|
|
viperBindFlags(cmd,
|
|
flagSubnetRemoveID,
|
|
)
|
|
},
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
// read private key
|
|
var key keys.PrivateKey
|
|
|
|
err := readSubnetKey(&key)
|
|
if err != nil {
|
|
return fmt.Errorf("read private key: %w", err)
|
|
}
|
|
|
|
// read ID and encode it
|
|
var id subnetid.ID
|
|
|
|
err = id.UnmarshalText([]byte(viper.GetString(flagSubnetRemoveID)))
|
|
if err != nil {
|
|
return fmt.Errorf("decode ID text: %w", err)
|
|
}
|
|
|
|
if subnetid.IsZero(id) {
|
|
return errZeroSubnet
|
|
}
|
|
|
|
binID, err := id.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal subnet ID: %w", err)
|
|
}
|
|
|
|
// initialize morph subnet client
|
|
var cSubnet morphsubnet.Client
|
|
|
|
err = initSubnetClient(&cSubnet, &key)
|
|
if err != nil {
|
|
return fmt.Errorf("init subnet client: %w", err)
|
|
}
|
|
|
|
// prepare call parameters and remove subnet
|
|
var prm morphsubnet.DeletePrm
|
|
|
|
prm.SetID(binID)
|
|
|
|
_, err = cSubnet.Delete(prm)
|
|
if err != nil {
|
|
return fmt.Errorf("morph call: %w", err)
|
|
}
|
|
|
|
cmd.Println("Remove subnet request sent successfully.")
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
// cmdSubnetGet flags.
|
|
const (
|
|
// subnet ID to be read
|
|
flagSubnetGetID = flagSubnet
|
|
)
|
|
|
|
// get subnet command.
|
|
var cmdSubnetGet = &cobra.Command{
|
|
Use: "get",
|
|
Short: "Read information about the NeoFS subnet.",
|
|
PreRun: func(cmd *cobra.Command, _ []string) {
|
|
viperBindFlags(cmd,
|
|
flagSubnetGetID,
|
|
)
|
|
},
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
// read private key
|
|
var key keys.PrivateKey
|
|
|
|
err := readSubnetKey(&key)
|
|
if err != nil {
|
|
return fmt.Errorf("read private key: %w", err)
|
|
}
|
|
|
|
// read ID and encode it
|
|
var id subnetid.ID
|
|
|
|
err = id.UnmarshalText([]byte(viper.GetString(flagSubnetGetID)))
|
|
if err != nil {
|
|
return fmt.Errorf("decode ID text: %w", err)
|
|
}
|
|
|
|
if subnetid.IsZero(id) {
|
|
return errZeroSubnet
|
|
}
|
|
|
|
binID, err := id.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal subnet ID: %w", err)
|
|
}
|
|
|
|
// initialize morph subnet client
|
|
var cSubnet morphsubnet.Client
|
|
|
|
err = initSubnetClient(&cSubnet, &key)
|
|
if err != nil {
|
|
return fmt.Errorf("init subnet client: %w", err)
|
|
}
|
|
|
|
// prepare call parameters and read subnet
|
|
var prm morphsubnet.GetPrm
|
|
|
|
prm.SetID(binID)
|
|
|
|
res, err := cSubnet.Get(prm)
|
|
if err != nil {
|
|
return fmt.Errorf("morph call: %w", err)
|
|
}
|
|
|
|
// decode info
|
|
var info subnet.Info
|
|
|
|
if err = info.Unmarshal(res.Info()); err != nil {
|
|
return fmt.Errorf("decode subnet info: %w", err)
|
|
}
|
|
|
|
// print information
|
|
var ownerID owner.ID
|
|
|
|
info.ReadOwner(&ownerID)
|
|
|
|
cmd.Printf("Owner: %s\n", ownerID)
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
// cmdSubnetAdmin subnet flags.
|
|
const (
|
|
// subnet ID to be managed
|
|
flagSubnetAdminSubnet = flagSubnet
|
|
// admin public key
|
|
flagSubnetAdminID = "id"
|
|
// manage client admins instead of node ones
|
|
flagSubnetAdminClient = "client"
|
|
)
|
|
|
|
// command to manage subnet admins.
|
|
var cmdSubnetAdmin = &cobra.Command{
|
|
Use: "admin",
|
|
Short: "Manage administrators of the NeoFS subnet.",
|
|
PreRun: func(cmd *cobra.Command, _ []string) {
|
|
viperBindFlags(cmd,
|
|
flagSubnetAdminSubnet,
|
|
flagSubnetAdminID,
|
|
)
|
|
},
|
|
}
|
|
|
|
// cmdSubnetAdminAdd flags.
|
|
const (
|
|
// client group ID
|
|
flagSubnetAdminAddGroup = flagSubnetGroup
|
|
)
|
|
|
|
// common executor cmdSubnetAdminAdd and cmdSubnetAdminRemove commands.
|
|
func manageSubnetAdmins(cmd *cobra.Command, rm bool) error {
|
|
// read private key
|
|
var key keys.PrivateKey
|
|
|
|
err := readSubnetKey(&key)
|
|
if err != nil {
|
|
return fmt.Errorf("read private key: %w", err)
|
|
}
|
|
|
|
// read ID and encode it
|
|
var id subnetid.ID
|
|
|
|
err = id.UnmarshalText([]byte(viper.GetString(flagSubnetAdminSubnet)))
|
|
if err != nil {
|
|
return fmt.Errorf("decode ID text: %w", err)
|
|
}
|
|
|
|
if subnetid.IsZero(id) {
|
|
return errZeroSubnet
|
|
}
|
|
|
|
binID, err := id.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal subnet ID: %w", err)
|
|
}
|
|
|
|
// read admin key and decode it
|
|
binAdminKey, err := hex.DecodeString(viper.GetString(flagSubnetAdminID))
|
|
if err != nil {
|
|
return fmt.Errorf("decode admin key text: %w", err)
|
|
}
|
|
|
|
var pubkey keys.PublicKey
|
|
if err = pubkey.DecodeBytes(binAdminKey); err != nil {
|
|
return fmt.Errorf("admin key format: %w", err)
|
|
}
|
|
|
|
// prepare call parameters
|
|
var prm morphsubnet.ManageAdminsPrm
|
|
|
|
if viper.GetBool(flagSubnetAdminClient) {
|
|
// read group ID and encode it
|
|
var groupID internal.SubnetClientGroupID
|
|
|
|
err = groupID.UnmarshalText([]byte(viper.GetString(flagSubnetAdminAddGroup)))
|
|
if err != nil {
|
|
return fmt.Errorf("decode group ID text: %w", err)
|
|
}
|
|
|
|
binGroupID, err := groupID.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal group ID: %w", err)
|
|
}
|
|
|
|
prm.SetClient()
|
|
prm.SetGroup(binGroupID)
|
|
}
|
|
|
|
prm.SetSubnet(binID)
|
|
prm.SetAdmin(binAdminKey)
|
|
|
|
if rm {
|
|
prm.SetRemove()
|
|
}
|
|
|
|
// initialize morph subnet client
|
|
var cSubnet morphsubnet.Client
|
|
|
|
err = initSubnetClient(&cSubnet, &key)
|
|
if err != nil {
|
|
return fmt.Errorf("init subnet client: %w", err)
|
|
}
|
|
|
|
_, err = cSubnet.ManageAdmins(prm)
|
|
if err != nil {
|
|
return fmt.Errorf("morph call: %w", err)
|
|
}
|
|
|
|
var op string
|
|
|
|
if rm {
|
|
op = "Remove"
|
|
} else {
|
|
op = "Add"
|
|
}
|
|
|
|
cmd.Printf("%s admin request sent successfully.\n", op)
|
|
|
|
return nil
|
|
}
|
|
|
|
// command to add subnet admin.
|
|
var cmdSubnetAdminAdd = &cobra.Command{
|
|
Use: "add",
|
|
Short: "Add admin to the NeoFS subnet.",
|
|
PreRun: func(cmd *cobra.Command, _ []string) {
|
|
viperBindFlags(cmd,
|
|
flagSubnetAdminAddGroup,
|
|
flagSubnetAdminClient,
|
|
)
|
|
},
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
return manageSubnetAdmins(cmd, false)
|
|
},
|
|
}
|
|
|
|
// command to remove subnet admin.
|
|
var cmdSubnetAdminRemove = &cobra.Command{
|
|
Use: "remove",
|
|
Short: "Remove admin of the NeoFS subnet.",
|
|
PreRun: func(cmd *cobra.Command, _ []string) {
|
|
viperBindFlags(cmd,
|
|
flagSubnetAdminClient,
|
|
)
|
|
},
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
return manageSubnetAdmins(cmd, true)
|
|
},
|
|
}
|
|
|
|
// cmdSubnetClient flags.
|
|
const (
|
|
// ID of the subnet to be managed
|
|
flagSubnetClientSubnet = flagSubnet
|
|
// client's NeoFS ID
|
|
flagSubnetClientID = flagSubnetAdminClient
|
|
// ID of the subnet client group
|
|
flagSubnetClientGroup = flagSubnetGroup
|
|
)
|
|
|
|
// command to manage subnet clients.
|
|
var cmdSubnetClient = &cobra.Command{
|
|
Use: "client",
|
|
Short: "Manage clients of the NeoFS subnet.",
|
|
PreRun: func(cmd *cobra.Command, _ []string) {
|
|
viperBindFlags(cmd,
|
|
flagSubnetClientSubnet,
|
|
flagSubnetClientID,
|
|
flagSubnetClientGroup,
|
|
)
|
|
},
|
|
}
|
|
|
|
// common executor cmdSubnetClientAdd and cmdSubnetClientRemove commands.
|
|
func manageSubnetClients(cmd *cobra.Command, rm bool) error {
|
|
// read private key
|
|
var key keys.PrivateKey
|
|
|
|
err := readSubnetKey(&key)
|
|
if err != nil {
|
|
return fmt.Errorf("read private key: %w", err)
|
|
}
|
|
|
|
// read ID and encode it
|
|
var id subnetid.ID
|
|
|
|
err = id.UnmarshalText([]byte(viper.GetString(flagSubnetClientSubnet)))
|
|
if err != nil {
|
|
return fmt.Errorf("decode ID text: %w", err)
|
|
}
|
|
|
|
if subnetid.IsZero(id) {
|
|
return errZeroSubnet
|
|
}
|
|
|
|
binID, err := id.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal subnet ID: %w", err)
|
|
}
|
|
|
|
// read client ID and encode it
|
|
var clientID owner.ID
|
|
|
|
err = clientID.Parse(viper.GetString(flagSubnetClientID))
|
|
if err != nil {
|
|
return fmt.Errorf("decode client ID text: %w", err)
|
|
}
|
|
|
|
binClientID, err := clientID.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal client ID: %w", err)
|
|
}
|
|
|
|
var prm morphsubnet.ManageClientsPrm
|
|
|
|
if viper.GetBool(flagSubnetAdminClient) {
|
|
// read group ID and encode it
|
|
var groupID internal.SubnetClientGroupID
|
|
|
|
err = groupID.UnmarshalText([]byte(viper.GetString(flagSubnetAdminAddGroup)))
|
|
if err != nil {
|
|
return fmt.Errorf("decode group ID text: %w", err)
|
|
}
|
|
|
|
binGroupID, err := groupID.Marshal()
|
|
if err != nil {
|
|
return fmt.Errorf("marshal group ID: %w", err)
|
|
}
|
|
|
|
prm.SetGroup(binGroupID)
|
|
}
|
|
|
|
prm.SetSubnet(binID)
|
|
prm.SetClient(binClientID)
|
|
|
|
if rm {
|
|
prm.SetRemove()
|
|
}
|
|
|
|
// initialize morph subnet client
|
|
var cSubnet morphsubnet.Client
|
|
|
|
err = initSubnetClient(&cSubnet, &key)
|
|
if err != nil {
|
|
return fmt.Errorf("init subnet client: %w", err)
|
|
}
|
|
|
|
_, err = cSubnet.ManageClients(prm)
|
|
if err != nil {
|
|
return fmt.Errorf("morph call: %w", err)
|
|
}
|
|
|
|
var op string
|
|
|
|
if rm {
|
|
op = "Remove"
|
|
} else {
|
|
op = "Add"
|
|
}
|
|
|
|
cmd.Printf("%s client request sent successfully.\n", op)
|
|
|
|
return nil
|
|
}
|
|
|
|
// command to add subnet client.
|
|
var cmdSubnetClientAdd = &cobra.Command{
|
|
Use: "add",
|
|
Short: "Add client to the NeoFS subnet.",
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
return manageSubnetClients(cmd, false)
|
|
},
|
|
}
|
|
|
|
// command to remove subnet client.
|
|
var cmdSubnetClientRemove = &cobra.Command{
|
|
Use: "remove",
|
|
Short: "Remove client of the NeoFS subnet.",
|
|
RunE: func(cmd *cobra.Command, _ []string) error {
|
|
return manageSubnetClients(cmd, true)
|
|
},
|
|
}
|
|
|
|
// registers flags and binds sub-commands for subnet commands.
|
|
func init() {
|
|
// get subnet flags
|
|
cmdSubnetGet.Flags().String(flagSubnetGetID, "", "ID of the subnet to read")
|
|
_ = cmdSubnetAdminAdd.MarkFlagRequired(flagSubnetGetID)
|
|
|
|
// remove subnet flags
|
|
cmdSubnetRemove.Flags().String(flagSubnetRemoveID, "", "ID of the subnet to remove")
|
|
_ = cmdSubnetRemove.MarkFlagRequired(flagSubnetRemoveID)
|
|
|
|
// subnet administer flags
|
|
adminFlags := cmdSubnetAdmin.Flags()
|
|
adminFlags.String(flagSubnetAdminSubnet, "", "ID of the subnet to manage administrators")
|
|
_ = cmdSubnetAdmin.MarkFlagRequired(flagSubnetAdminSubnet)
|
|
adminFlags.String(flagSubnetAdminID, "", "Hex-encoded public key of the admin")
|
|
_ = cmdSubnetAdmin.MarkFlagRequired(flagSubnetAdminID)
|
|
|
|
// add admin flags
|
|
cmdSubnetAdminAddFlags := cmdSubnetAdminAdd.Flags()
|
|
cmdSubnetAdminAddFlags.String(flagSubnetAdminAddGroup, "", fmt.Sprintf(
|
|
"Client group ID in text format (needed with --%s only)", flagSubnetAdminClient))
|
|
cmdSubnetAdminAddFlags.Bool(flagSubnetAdminClient, false, "Add client admin instead of node one")
|
|
|
|
// remove admin flags
|
|
cmdSubnetAdminRemoveFlags := cmdSubnetAdminRemove.Flags()
|
|
cmdSubnetAdminRemoveFlags.Bool(flagSubnetAdminClient, false, "Remove client admin instead of node one")
|
|
|
|
// client managements flags
|
|
clientFlags := cmdSubnetClient.Flags()
|
|
clientFlags.String(flagSubnetClientSubnet, "", "ID of the subnet to be managed")
|
|
_ = cmdSubnetClient.MarkFlagRequired(flagSubnetClientSubnet)
|
|
clientFlags.String(flagSubnetClientGroup, "", "ID of the client group to work with")
|
|
_ = cmdSubnetClient.MarkFlagRequired(flagSubnetClientGroup)
|
|
clientFlags.String(flagSubnetClientID, "", "Client's user ID in NeoFS system in text format")
|
|
_ = cmdSubnetClient.MarkFlagRequired(flagSubnetClientID)
|
|
|
|
// add all admin managing commands to corresponding command section
|
|
cmdSubnetAdmin.AddCommand(
|
|
cmdSubnetAdminAdd,
|
|
cmdSubnetAdminRemove,
|
|
)
|
|
|
|
// add all client managing commands to corresponding command section
|
|
cmdSubnetClient.AddCommand(
|
|
cmdSubnetClientAdd,
|
|
cmdSubnetClientRemove,
|
|
)
|
|
|
|
// subnet global flags
|
|
cmdSubnetFlags := cmdSubnet.Flags()
|
|
cmdSubnetFlags.StringP(flagSubnetEndpoint, "r", "", "N3 RPC node endpoint")
|
|
_ = cmdSubnet.MarkFlagRequired(flagSubnetEndpoint)
|
|
cmdSubnetFlags.StringP(flagSubnetKey, "k", "", "Path to file with private key")
|
|
_ = cmdSubnet.MarkFlagRequired(flagSubnetKey)
|
|
cmdSubnetFlags.StringP(flagSubnetContract, "a", "", "Subnet contract address (string LE)")
|
|
_ = cmdSubnet.MarkFlagRequired(flagSubnetContract)
|
|
cmdSubnetFlags.Bool(flagSubnetNonNotary, false, "Flag to work in non-notary environment")
|
|
|
|
// add all subnet commands to corresponding command section
|
|
cmdSubnet.AddCommand(
|
|
cmdSubnetCreate,
|
|
cmdSubnetRemove,
|
|
cmdSubnetGet,
|
|
cmdSubnetAdmin,
|
|
cmdSubnetClient,
|
|
)
|
|
}
|