cluster: add command 'roles add'

@TarantoolBot document
Title: `tt cluster rs roles add` adds role in config scope provided by flags.

This patch introduces new command for the cluster replicaset module:

```
tt cluster replicaset roles add <URI> <ROLE_NAME> [flags]
```

URI is a target configuration source (etcd/tcs). ROLE_NAME is a role for
adding to a Tarantool config storage. It is necessary to provide flag
with destination in config for role addition. It can be one or more
roles.

Command supports following flags:
- Flags for the destination of role addition:
  - `--global (-G)` for a global scope to add a role;
  - `--instance (-i) string` for an application name target to specify
    an instance to add a role;
  - `--replicaset (-r) string` for an application name target to specify
    a replicaset to add a role;
  - `--group (-g) string` for an application name target to specify a group.
- Common flag to interact with config storages (etcd / tarantool config
  storage):
  - `--force (-f)` to skip selecting a key for patching;
  - `--username (-u)` is a username (used as etcd/tarantool config
    storage credentials);
  - `--password (-p)` is a password (used as etcd/tarantool config
    storage credentials).

Closes #915

Author: themilchenko

CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- `tt cluster replicaset roles add`: command to add roles in config scope provided by flags.
+
+### Fixed
+
+### Changed
+
 ## [2.4.0] - 2024-08-07
 
 ### Added

cli/cluster/cluster.go

@@ -138,7 +138,8 @@ func collectTarantoolConfig(collectors libcluster.CollectorFactory,
 				time.Duration(tarantoolConfig.Timeout*float64(time.Second)))
 			if err != nil {
 				connectionErrors = append(connectionErrors,
-					fmt.Errorf("error when creating a colletor for endpoint %q: %w", opt.addr, err))
+					fmt.Errorf("error when creating a collector for endpoint %q: %w",
+						opt.addr, err))
 				continue
 			}
 

cli/cluster/cmd/replicaset.go

@@ -271,3 +271,62 @@ func Expel(uri *url.URL, ctx ExpelCtx) error {
 	}
 	return err
 }
+
+// RolesAddCtx describes the context to add role of instance.
+type RolesAddCtx struct {
+	// InstName is an instance name in which add or remove role.
+	InstName string
+	// GroupName is an replicaset name in which add or remove role.
+	GroupName string
+	// ReplicasetName is an replicaset name in which add or remove role.
+	ReplicasetName string
+	// IsGlobal is an boolean value if role needs to add in global scope.
+	IsGlobal bool
+	// RoleName is a name of role to add.
+	RoleName string
+	// Publishers is data publisher factory.
+	Publishers libcluster.DataPublisherFactory
+	// Collectors is data collector factory.
+	Collectors libcluster.DataCollectorFactory
+	// Username defines a username for connection.
+	Username string
+	// Password defines a password for connection.
+	Password string
+	// Force true if the key selection for patching the config
+	// should be skipped.
+	Force bool
+}
+
+// AddRole adds a role by patching the cluster config.
+func AddRole(uri *url.URL, ctx RolesAddCtx) error {
+	opts, err := ParseUriOpts(uri)
+	if err != nil {
+		return fmt.Errorf("invalid URL %q: %w", uri, err)
+	}
+	connOpts := connectOpts{
+		Username: ctx.Username,
+		Password: ctx.Password,
+	}
+
+	collector, publisher, closeFunc, err := createDataCollectorAndKeyPublisher(
+		ctx.Collectors, ctx.Publishers, opts, connOpts)
+	if err != nil {
+		return err
+	}
+	defer closeFunc()
+
+	source := replicaset.NewCConfigSource(collector, publisher,
+		replicaset.KeyPicker(pickPatchKey))
+	err = source.AddRole(replicaset.RolesAddCtx{
+		InstName:       ctx.InstName,
+		GroupName:      ctx.GroupName,
+		ReplicasetName: ctx.ReplicasetName,
+		IsGlobal:       ctx.IsGlobal,
+		RoleName:       ctx.RoleName,
+		Force:          ctx.Force,
+	})
+	if err == nil {
+		log.Info("Done.")
+	}
+	return err
+}

cli/cmd/cluster.go

@@ -64,6 +64,8 @@ var switchStatusCtx = clustercmd.SwitchStatusCtx{
 	TaskID: "",
 }
 
+var rolesAddCtx = clustercmd.RolesAddCtx{}
+
 var (
 	defaultSwitchTimeout       uint64 = 30
 	clusterIntegrityPrivateKey string
@@ -201,9 +203,49 @@ func newClusterReplicasetCmd() *cobra.Command {
 		"skip selecting a key for patching")
 	integrity.RegisterWithIntegrityFlag(expelCmd.Flags(), &clusterIntegrityPrivateKey)
 
+	rolesCmd := &cobra.Command{
+		Use:   "roles",
+		Short: "Add or remove roles in cluster replicaset",
+	}
+
+	addRolesCmd := &cobra.Command{
+		Use:   "add <URI> <ROLE_NAME> [flags]",
+		Short: "Add role to an instance, group or instance",
+		Long:  "Add role to an instance, group or instance\n\n" + clusterUriHelp,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdCtx.CommandName = cmd.Name()
+			err := modules.RunCmd(&cmdCtx, cmd.CommandPath(), &modulesInfo,
+				internalClusterReplicasetRolesAddModule, args)
+			util.HandleCmdErr(cmd, err)
+		},
+		Example: "tt cluster replicaset roles add http://user:pass@localhost:3301" +
+			" roles.metrics-export --instance_name master",
+		Args: cobra.ExactArgs(2),
+	}
+
+	addRolesCmd.Flags().StringVarP(&rolesAddCtx.ReplicasetName, "replicaset", "r", "",
+		"name of a target replicaset")
+	addRolesCmd.Flags().StringVarP(&rolesAddCtx.GroupName, "group", "g", "",
+		"name of a target group")
+	addRolesCmd.Flags().StringVarP(&rolesAddCtx.InstName, "instance", "i", "",
+		"name of a target instance")
+	addRolesCmd.Flags().BoolVarP(&rolesAddCtx.IsGlobal, "global", "G", false,
+		"global config context")
+
+	addRolesCmd.Flags().StringVarP(&rolesAddCtx.Username, "username", "u", "",
+		"username (used as etcd/tarantool config storage credentials)")
+	addRolesCmd.Flags().StringVarP(&rolesAddCtx.Password, "password", "p", "",
+		"password (used as etcd/tarantool config storage credentials)")
+	addRolesCmd.Flags().BoolVarP(&rolesAddCtx.Force, "force", "f", false,
+		"skip selecting a key for patching")
+	integrity.RegisterWithIntegrityFlag(addRolesCmd.Flags(), &clusterIntegrityPrivateKey)
+
+	rolesCmd.AddCommand(addRolesCmd)
+
 	cmd.AddCommand(promoteCmd)
 	cmd.AddCommand(demoteCmd)
 	cmd.AddCommand(expelCmd)
+	cmd.AddCommand(rolesCmd)
 
 	return cmd
 }
@@ -479,6 +521,27 @@ func internalClusterReplicasetExpelModule(cmdCtx *cmdcontext.CmdCtx, args []stri
 	return clustercmd.Expel(uri, expelCtx)
 }
 
+// internalClusterReplicasetRolesAddModule is a "cluster replicaset roles add" command.
+func internalClusterReplicasetRolesAddModule(cmdCtx *cmdcontext.CmdCtx, args []string) error {
+	if err := checkRolesAddFlags(); err != nil {
+		return err
+	}
+
+	uri, err := parseUrl(args[0])
+	if err != nil {
+		return fmt.Errorf("failed to parse config source URI: %w", err)
+	}
+
+	rolesAddCtx.Collectors, rolesAddCtx.Publishers, err = createDataCollectorsAndDataPublishers(
+		cmdCtx.Integrity, clusterIntegrityPrivateKey)
+	if err != nil {
+		return err
+	}
+
+	rolesAddCtx.RoleName = args[1]
+	return clustercmd.AddRole(uri, rolesAddCtx)
+}
+
 // internalClusterFailoverSwitchModule is as "cluster failover switch" command
 func internalClusterFailoverSwitchModule(cmdCtx *cmdcontext.CmdCtx, args []string) error {
 	uri, err := parseUrl(args[0])
@@ -564,3 +627,13 @@ func parseAppStr(cmdCtx *cmdcontext.CmdCtx, appStr string) (string, string, stri
 
 	return configPath, appName, instName, nil
 }
+
+// checkRolesAddFlags checks that flags from 'cluster rs roles add' command
+// have correct values.
+func checkRolesAddFlags() error {
+	if rolesAddCtx.IsGlobal == false && rolesAddCtx.GroupName == "" &&
+		rolesAddCtx.ReplicasetName == "" && rolesAddCtx.InstName == "" {
+		return util.NewArgError("need to provide flag(s) with scope roles will added")
+	}
+	return nil
+}

cli/init/init.go

@@ -21,7 +21,7 @@ const (
 // InitCtx contains information for tt config creation.
 type InitCtx struct {
 	// SkipConfig - if set, disables cartridge & tarantoolctl config analysis,
-	// so init does not try to get directories information from exitsting config files.
+	// so init does not try to get directories information from existing config files.
 	SkipConfig bool
 	// ForceMode, if set, tt config is re-written without a question.
 	ForceMode bool

cli/replicaset/cconfig.go

@@ -853,6 +853,14 @@ func patchCConfigElectionMode(config *libcluster.Config,
 	return config, nil
 }
 
+func patchCConfigAddRole(config *libcluster.Config, path []string,
+	roleNames []string) (*libcluster.Config, error) {
+	if err := config.Set(path, roleNames); err != nil {
+		return nil, err
+	}
+	return config, nil
+}
+
 // getCConfigInstance extracts an instance from the cluster config.
 func getCConfigInstance(
 	config *libcluster.ClusterConfig, instName string) (cconfigInstance, error) {

cli/replicaset/configsource.go

@@ -3,6 +3,7 @@ package replicaset
 import (
 	"errors"
 	"fmt"
+	"slices"
 	"sort"
 	"strings"
 
@@ -12,6 +13,12 @@ import (
 // KeyPicker picks a key to patch.
 type KeyPicker func([]string, bool, string) (int, error)
 
+// path describes a path of target with its depth level in config.
+type path struct {
+	path  []string
+	depth int
+}
+
 // CConfigSource describes the cluster config source.
 type CConfigSource struct {
 	collector libcluster.DataCollector
@@ -108,6 +115,74 @@ func (c *CConfigSource) patchInstanceConfig(instanceName string, force bool,
 	return nil
 }
 
+// patchConfigWithRoles runs an config patching pipeline with adding roles.
+func (c *CConfigSource) patchConfigWithRoles(ctx RolesAddCtx,
+	getPathFunc func(clusterConfig libcluster.ClusterConfig,
+		ctx RolesAddCtx) (paths []path, err error),
+	patchFunc func(config *libcluster.Config, path []string,
+		roleNames []string) (*libcluster.Config, error),
+) error {
+	configData, clusterConfig, err := collectCConfig(c.collector)
+	if err != nil {
+		return err
+	}
+	paths, err := getPathFunc(clusterConfig, ctx)
+	if err != nil {
+		return err
+	}
+
+	var (
+		target  patchTarget
+		patched *libcluster.Config
+	)
+
+	for _, path := range paths {
+		value, err := clusterConfig.RawConfig.Get(path.path)
+		var notExistErr libcluster.NotExistError
+		if err != nil && !errors.As(err, &notExistErr) {
+			return err
+		}
+		var existingRoles []string
+		if value != nil {
+			existingRoles, err = parseRoles(value)
+			if err != nil {
+				return err
+			}
+		}
+		if len(existingRoles) > 0 && slices.Index(existingRoles, ctx.RoleName) != -1 {
+			return fmt.Errorf("role %q already exists in %s",
+				ctx.RoleName, strings.Join(path.path, "/"))
+		}
+		// If role is not existing in requested path, append it.
+		existingRoles = append(existingRoles, ctx.RoleName)
+
+		targets, err := getCConfigPatchTargets(configData, path.path, path.depth)
+		if err != nil {
+			return err
+		}
+		target, err = c.pickTarget(targets, ctx.Force, strings.Join(path.path, "/"))
+		if err != nil {
+			return err
+		}
+
+		curPatched, err := patchFunc(target.config, path.path, existingRoles)
+		if err != nil {
+			return err
+		}
+
+		if patched != nil {
+			patched.Merge(curPatched)
+			continue
+		}
+		patched = curPatched
+	}
+	err = c.publisher.Publish(target.key, target.revision, []byte(patched.String()))
+	if err != nil {
+		return fmt.Errorf("failed to publish the config: %w", err)
+	}
+	return nil
+}
+
 // Promote patches a config to promote an instance.
 func (c *CConfigSource) Promote(ctx PromoteCtx) error {
 	return c.patchInstanceConfig(
@@ -144,6 +219,63 @@ func (c *CConfigSource) Expel(ctx ExpelCtx) error {
 	)
 }
 
+// AddRole patches a config to add role to a config.
+func (c *CConfigSource) AddRole(ctx RolesAddCtx) error {
+	return c.patchConfigWithRoles(ctx, getCConfigRolesPath, patchCConfigAddRole)
+}
+
+// getCConfigRolesPath returns a path and it's minimum interesting depth
+// to patch the config for role addition.
+func getCConfigRolesPath(clusterConfig libcluster.ClusterConfig, ctx RolesAddCtx) ([]path, error) {
+	var paths []path
+	if ctx.IsGlobal {
+		paths = append(paths, path{
+			path:  []string{"roles"},
+			depth: 0,
+		})
+	}
+	if ctx.GroupName != "" {
+		p := []string{"groups", ctx.GroupName}
+		if _, err := clusterConfig.RawConfig.Get(p); err != nil {
+			var notExistErr libcluster.NotExistError
+			if errors.As(err, &notExistErr) {
+				return []path{}, fmt.Errorf("cannot find group %q", ctx.GroupName)
+			}
+			return []path{}, fmt.Errorf("failed to build a group path: %w", err)
+		}
+		paths = append(paths, path{
+			path:  append(p, "roles"),
+			depth: len(p),
+		})
+	}
+	if ctx.ReplicasetName != "" {
+		var group string
+		var ok bool
+		if group, ok = libcluster.FindGroupByReplicaset(clusterConfig, ctx.ReplicasetName); !ok {
+			return []path{}, fmt.Errorf("cannot find replicaset %q above group", ctx.ReplicasetName)
+		}
+		p := []string{"groups", group, "replicasets", ctx.ReplicasetName}
+		paths = append(paths, path{
+			path:  append(p, "roles"),
+			depth: len(p),
+		})
+	}
+	if ctx.InstName != "" {
+		var group, replicaset string
+		var ok bool
+		if group, replicaset, ok = libcluster.FindInstance(clusterConfig, ctx.InstName); !ok {
+			return []path{}, fmt.Errorf("cannot find instance %q above group and/or replicaset",
+				ctx.InstName)
+		}
+		p := []string{"groups", group, "replicasets", replicaset, "instances", ctx.InstName}
+		paths = append(paths, path{
+			path:  append(p, "roles"),
+			depth: len(p),
+		})
+	}
+	return paths, nil
+}
+
 // getCConfigPromotePath returns a path and it's minimum interesting depth
 // to patch the config for instance promoting.
 // For example, if we have the path "/groups/g/replicasets/r/leader" then