diff --git a/cmd/neofs-adm/internal/modules/morph/internal/types.go b/cmd/neofs-adm/internal/modules/morph/internal/types.go new file mode 100644 index 0000000000..501625be9d --- /dev/null +++ b/cmd/neofs-adm/internal/modules/morph/internal/types.go @@ -0,0 +1,65 @@ +package internal + +import ( + "fmt" + "strconv" + + "google.golang.org/protobuf/proto" +) + +// StringifySubnetClientGroupID returns string representation of SubnetClientGroupID using MarshalText. +// Returns string with message on error. +func StringifySubnetClientGroupID(id *SubnetClientGroupID) string { + text, err := id.MarshalText() + if err != nil { + return fmt.Sprintf(" %v", err) + } + + return string(text) +} + +// MarshalText encodes SubnetClientGroupID into text format according to NeoFS API V2 protocol: +// value in base-10 integer string format. +// +// Implements encoding.TextMarshaler. +func (x *SubnetClientGroupID) MarshalText() ([]byte, error) { + num := x.GetValue() // NPE safe, returns zero on nil + + return []byte(strconv.FormatUint(uint64(num), 10)), nil +} + +// UnmarshalText decodes SubnetID from the text according to NeoFS API V2 protocol: +// should be base-10 integer string format with bitsize = 32. +// +// Returns strconv.ErrRange if integer overflows uint32. +// +// Must not be called on nil. +// +// Implements encoding.TextUnmarshaler. +func (x *SubnetClientGroupID) UnmarshalText(txt []byte) error { + num, err := strconv.ParseUint(string(txt), 10, 32) + if err != nil { + return fmt.Errorf("invalid numeric value: %w", err) + } + + x.SetNumber(uint32(num)) + + return nil +} + +// Marshal encodes SubnetClientGroupID into a binary format of NeoFS API V2 protocol +// (Protocol Buffers with direct field order). +func (x *SubnetClientGroupID) Marshal() ([]byte, error) { + return proto.Marshal(x) +} + +// Unmarshal decodes SubnetClientGroupID from NeoFS API V2 binary format (see Marshal). Must not be called on nil. +func (x *SubnetClientGroupID) Unmarshal(data []byte) error { + return proto.Unmarshal(data, x) +} + +// SetNumber sets SubnetClientGroupID value in uint32 format. Must not be called on nil. +// By default, number is 0. +func (x *SubnetClientGroupID) SetNumber(num uint32) { + x.Value = num +} diff --git a/cmd/neofs-adm/internal/modules/morph/internal/types.pb.go b/cmd/neofs-adm/internal/modules/morph/internal/types.pb.go new file mode 100644 index 0000000000..03c1838773 Binary files /dev/null and b/cmd/neofs-adm/internal/modules/morph/internal/types.pb.go differ diff --git a/cmd/neofs-adm/internal/modules/morph/internal/types.proto b/cmd/neofs-adm/internal/modules/morph/internal/types.proto new file mode 100644 index 0000000000..c610eb7aa4 --- /dev/null +++ b/cmd/neofs-adm/internal/modules/morph/internal/types.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package neo.fs.v2.refs; + +option go_package = "github.com/nspcc-dev/neofs-node/cmd/neofs-adm/internal/modules/morph/internal"; + +// Client group identifier in the NeoFS subnet. +// +// String representation of a value is base-10 integer. +// +// JSON representation is an object containing single `value` number field. +message SubnetClientGroupID { + // 4-byte integer identifier of the subnet client group. + fixed32 value = 1 [json_name = "value"]; +} diff --git a/cmd/neofs-adm/internal/modules/morph/root.go b/cmd/neofs-adm/internal/modules/morph/root.go index f05f9c4583..418c7f68ce 100644 --- a/cmd/neofs-adm/internal/modules/morph/root.go +++ b/cmd/neofs-adm/internal/modules/morph/root.go @@ -205,4 +205,6 @@ func init() { refillGasCmd.Flags().StringP(endpointFlag, "r", "", "N3 RPC node endpoint") refillGasCmd.Flags().String(storageWalletFlag, "", "path to storage node wallet") refillGasCmd.Flags().String(refillGasAmountFlag, "", "additional amount of GAS to transfer") + + RootCmd.AddCommand(cmdSubnet) } diff --git a/cmd/neofs-adm/internal/modules/morph/subnet.go b/cmd/neofs-adm/internal/modules/morph/subnet.go new file mode 100644 index 0000000000..38fdc66eab --- /dev/null +++ b/cmd/neofs-adm/internal/modules/morph/subnet.go @@ -0,0 +1,711 @@ +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, + ) +} diff --git a/pkg/morph/client/subnet/admin.go b/pkg/morph/client/subnet/admin.go new file mode 100644 index 0000000000..f2f9b9c635 --- /dev/null +++ b/pkg/morph/client/subnet/admin.go @@ -0,0 +1,87 @@ +package morphsubnet + +import "github.com/nspcc-dev/neofs-node/pkg/morph/client" + +// ManageAdminsPrm groups parameters of administer methods of Subnet contract. +// +// Zero value adds node admin. Subnet, key and group must be specified via setters. +type ManageAdminsPrm struct { + // remove or add admin + rm bool + + // client or node admin + client bool + + subnet []byte + + admin []byte + + group []byte +} + +// SetRemove marks admin to be removed. By default, admin is added. +func (x *ManageAdminsPrm) SetRemove() { + x.rm = true +} + +// SetClient switches to client admin. By default, node admin is modified. +func (x *ManageAdminsPrm) SetClient() { + x.client = true +} + +// SetSubnet sets identifier of the subnet in a binary NeoFS API protocol format. +func (x *ManageAdminsPrm) SetSubnet(id []byte) { + x.subnet = id +} + +// SetAdmin sets admin's public key in a binary format. +func (x *ManageAdminsPrm) SetAdmin(key []byte) { + x.admin = key +} + +// SetGroup sets identifier of the client group in a binary NeoFS API protocol format. +// Makes sense only for client admins (see ManageAdminsPrm.SetClient). +func (x *ManageAdminsPrm) SetGroup(id []byte) { + x.group = id +} + +// ManageAdminsRes groups resulting values of node administer methods of Subnet contract. +type ManageAdminsRes struct{} + +// ManageAdmins manages admin list of the NeoFS subnet through Subnet contract calls. +func (x Client) ManageAdmins(prm ManageAdminsPrm) (*ManageAdminsPrm, error) { + var method string + + args := make([]interface{}, 1, 3) + args[0] = prm.subnet + + if prm.client { + args = append(args, prm.group, prm.admin) + + if prm.rm { + method = "removeClientAdmin" + } else { + method = "addClientAdmin" + } + } else { + args = append(args, prm.admin) + + if prm.rm { + method = "removeNodeAdmin" + } else { + method = "addNodeAdmin" + } + } + + var prmInvoke client.InvokePrm + + prmInvoke.SetMethod(method) + prmInvoke.SetArgs(args...) + + err := x.client.Invoke(prmInvoke) + if err != nil { + return nil, err + } + + return new(ManageAdminsPrm), nil +} diff --git a/pkg/morph/client/subnet/clients.go b/pkg/morph/client/subnet/clients.go index e7ff8494a5..335bb52107 100644 --- a/pkg/morph/client/subnet/clients.go +++ b/pkg/morph/client/subnet/clients.go @@ -56,3 +56,59 @@ func (x *Client) UserAllowed(prm UserAllowedPrm) (*UserAllowedRes, error) { result: result, }, nil } + +// ManageClientsPrm groups parameters of client management in Subnet contract. +// +// Zero value adds subnet client. Subnet, group and client ID must be specified via setters. +type ManageClientsPrm struct { + // remove or add client + rm bool + + args [3]interface{} +} + +// SetRemove marks client to be removed. By default, client is added. +func (x *ManageClientsPrm) SetRemove() { + x.rm = true +} + +// SetSubnet sets identifier of the subnet in a binary NeoFS API protocol format. +func (x *ManageClientsPrm) SetSubnet(id []byte) { + x.args[0] = id +} + +// SetGroup sets identifier of the client group in a binary NeoFS API protocol format. +func (x *ManageClientsPrm) SetGroup(id []byte) { + x.args[1] = id +} + +// SetClient sets client's user ID in a binary NeoFS API protocol format. +func (x *ManageClientsPrm) SetClient(id []byte) { + x.args[2] = id +} + +// ManageClientsRes groups resulting values of client management methods of Subnet contract. +type ManageClientsRes struct{} + +// ManageClients manages client list of the NeoFS subnet through Subnet contract calls. +func (x Client) ManageClients(prm ManageClientsPrm) (*ManageClientsRes, error) { + var method string + + if prm.rm { + method = "removeUser" + } else { + method = "addUser" + } + + var prmInvoke client.InvokePrm + + prmInvoke.SetMethod(method) + prmInvoke.SetArgs(prm.args[:]...) + + err := x.client.Invoke(prmInvoke) + if err != nil { + return nil, err + } + + return new(ManageClientsRes), nil +} diff --git a/pkg/services/control/ir/service.pb.go b/pkg/services/control/ir/service.pb.go index cbf3cf2da0..26a6120d02 100644 Binary files a/pkg/services/control/ir/service.pb.go and b/pkg/services/control/ir/service.pb.go differ diff --git a/pkg/services/control/ir/types.pb.go b/pkg/services/control/ir/types.pb.go index e7be9d4965..4795b092c1 100644 Binary files a/pkg/services/control/ir/types.pb.go and b/pkg/services/control/ir/types.pb.go differ diff --git a/pkg/services/control/service.pb.go b/pkg/services/control/service.pb.go index 44ee54a8cd..e5da57108b 100644 Binary files a/pkg/services/control/service.pb.go and b/pkg/services/control/service.pb.go differ diff --git a/pkg/services/control/types.pb.go b/pkg/services/control/types.pb.go index 56331f3554..b87a7f8f3d 100644 Binary files a/pkg/services/control/types.pb.go and b/pkg/services/control/types.pb.go differ