Adding glustercli command to get options of all volumes

e2e/cluster_test.go

@@ -0,0 +1,48 @@
+package e2e
+
+import (
+	"testing"
+
+	"github.com/gluster/glusterd2/pkg/api"
+
+	"github.com/stretchr/testify/require"
+)
+
+func testGetClusterOptions(t *testing.T) {
+	r := require.New(t)
+	clusterOps, err := client.GetClusterOption()
+	r.Nil(err)
+	r.NotNil(clusterOps)
+}
+
+func ClusterOptionsSet(t *testing.T) {
+	r := require.New(t)
+	optReq := api.ClusterOptionReq{
+		Options: map[string]string{"cluster.brick-multiplex": "on"},
+	}
+	err := client.ClusterOptionSet(optReq)
+	r.Nil(err)
+	clusterOps, err := client.GetClusterOption()
+	for _, ops := range clusterOps {
+		if ops.Key == "cluster.brick-multiplex" {
+			r.Equal(ops.Value, "on")
+		}
+	}
+}
+
+// TestClusterOption creates a cluster
+func TestClusterOption(t *testing.T) {
+	var err error
+
+	r := require.New(t)
+
+	tc, err := setupCluster(t, "./config/1.toml", "./config/2.toml", "./config/3.toml")
+	r.Nil(err)
+	defer teardownCluster(tc)
+
+	client, err = initRestclient(tc.gds[0])
+	r.Nil(err)
+	r.NotNil(client)
+
+	t.Run("Get Cluster Options", testGetClusterOptions)
+}

e2e/smartvol_ops_test.go

@@ -181,6 +181,15 @@ func testSmartVolumeDistribute(t *testing.T) {
 	r.NotNil(err)
 
 	r.Nil(client.VolumeDelete(smartvolname))
+
+	createReq = api.VolCreateReq{
+		Name:            "volume",
+		Size:            60 * gutils.MiB,
+		DistributeCount: 3,
+	}
+	volinfo, err = client.VolumeCreate(createReq)
+	r.NotNil(err)
+
 	checkZeroLvs(r)
 }
 

glustercli/cmd/cluster-options.go

@@ -0,0 +1,96 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/gluster/glusterd2/pkg/api"
+
+	"github.com/olekukonko/tablewriter"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+const (
+	helpClusterOptionCmd    = "Gluster Cluster Option Management"
+	helpClusterOptionSetCmd = "Set Cluster Option"
+	helpClusterOptionGetCmd = "Get Cluster Option"
+)
+
+func init() {
+	clusterCmd.AddCommand(clusterOptionGetCmd)
+	clusterCmd.AddCommand(clusterOptionSetCmd)
+}
+
+var clusterCmd = &cobra.Command{
+	Use:   "cluster",
+	Short: helpClusterOptionCmd,
+}
+
+var clusterOptionSetCmd = &cobra.Command{
+	Use:   "set <option> <value> [<option> <value>]...",
+	Short: helpClusterOptionSetCmd,
+	Args:  clusterSetCmdArgs,
+	Run:   clusterSetCmdRun,
+}
+
+func clusterSetCmdArgs(cmd *cobra.Command, args []string) error {
+	// Ensure we have enough arguments for the command
+	if len(args) < 2 {
+		return errors.New("need at least 2 arguments")
+	}
+
+	// Ensure we have a proper option-value pairs
+	if (len(args) % 2) != 0 {
+		return errors.New("needs '<option> <value>' to be in pairs")
+	}
+
+	return nil
+}
+
+func clusterSetCmdRun(cmd *cobra.Command, args []string) {
+	options := args[:]
+	if err := clusterOptionJSONHandler(cmd, options); err != nil {
+		if GlobalFlag.Verbose {
+			log.WithError(err).Error("cluster option set failed")
+		}
+		failure("Cluster option set failed", err, 1)
+	} else {
+		fmt.Println("Options set successfully")
+	}
+}
+
+func clusterOptionJSONHandler(cmd *cobra.Command, options []string) error {
+	copt := make(map[string]string)
+	for op, val := range options {
+		if op%2 == 0 {
+			copt[val] = options[op+1]
+		}
+	}
+
+	err := client.ClusterOptionSet(api.ClusterOptionReq{
+		Options: copt})
+	return err
+}
+
+var clusterOptionGetCmd = &cobra.Command{
+	Use:   "get",
+	Short: helpClusterOptionGetCmd,
+	Run: func(cmd *cobra.Command, args []string) {
+		table := tablewriter.NewWriter(os.Stdout)
+		opts, err := client.GetClusterOption()
+		if err != nil {
+			if GlobalFlag.Verbose {
+				log.WithError(err).Error("error getting cluster options")
+			}
+			failure("Error getting cluster options", err, 1)
+		}
+		table.SetHeader([]string{"Name", "Modified", "Value", "Default Value"})
+		table.SetAlignment(tablewriter.ALIGN_LEFT)
+		for _, opt := range opts {
+			table.Append([]string{opt.Key, formatBoolYesNo(opt.Modified), opt.Value, opt.DefaultValue})
+		}
+		table.Render()
+	},
+}

glustercli/cmd/root.go

@@ -54,6 +54,7 @@ func addSubCommands(rootCmd *cobra.Command) {
 	rootCmd.AddCommand(georepCmd)
 	rootCmd.AddCommand(snapshotCmd)
 	rootCmd.AddCommand(volumeCmd)
+	rootCmd.AddCommand(clusterCmd)
 }
 
 // GlustercliOption will have all global flags set during run time

glustercli/cmd/volume.go

@@ -233,39 +233,55 @@ var volumeDeleteCmd = &cobra.Command{
 }
 
 var volumeGetCmd = &cobra.Command{
-	Use:   "get",
+	Use:   "get <VOLNAME|all> <key|all>",
 	Short: helpVolumeGetCmd,
 	Args:  cobra.ExactArgs(2),
 	Run: func(cmd *cobra.Command, args []string) {
-
 		volname := args[0]
 		optname := args[1]
-
-		opts, err := client.VolumeGet(volname, optname)
-		if err != nil {
-			log.WithError(err).Error("error getting volume options")
-			failure("Error getting volume options", err, 1)
-		}
-
 		table := tablewriter.NewWriter(os.Stdout)
-		table.SetHeader([]string{"Name", "Modified", "Value", "Default Value", "Option Level"})
-		table.SetAlignment(tablewriter.ALIGN_LEFT)
 
-		for _, opt := range opts {
-			//if modified flag is set, discard unmodified options
-			if flagGetMdf && !opt.Modified {
-				continue
+		var volList []string
+		if volname == "all" {
+			volInfoList, err := client.Volumes("")
+			if len(volInfoList) <= 0 {
+				failure("No volumes found", err, 1)
+			}
+			for _, volInfo := range volInfoList {
+				volList = append(volList, volInfo.Name)
 			}
-			if flagGetBsc && opt.OptionLevel == "Basic" {
-				table.Append([]string{opt.OptName, formatBoolYesNo(opt.Modified), opt.Value, opt.DefaultValue, opt.OptionLevel})
+		} else {
+			volList = append(volList, volname)
+		}
+		for _, volume := range volList {
+
+			fmt.Println("Volume :", volume)
+			opts, err := client.VolumeGet(volume, optname)
+			if err != nil {
+				log.WithError(err).Error("error getting volume options")
+				failure("Error getting volume options", err, 1)
 			}
-			if flagGetAdv && opt.OptionLevel == "Advanced" {
-				table.Append([]string{opt.OptName, formatBoolYesNo(opt.Modified), opt.Value, opt.DefaultValue, opt.OptionLevel})
+			table = tablewriter.NewWriter(os.Stdout)
+			table.SetHeader([]string{"Name", "Modified", "Value", "Default Value", "Option Level"})
+			table.SetAlignment(tablewriter.ALIGN_LEFT)
+
+			for _, opt := range opts {
+				//if modified flag is set, discard unmodified options
+				if flagGetMdf && !opt.Modified {
+					continue
+				}
+				if flagGetBsc && opt.OptionLevel == "Basic" {
+					table.Append([]string{opt.OptName, formatBoolYesNo(opt.Modified), opt.Value, opt.DefaultValue, opt.OptionLevel})
+				}
+				if flagGetAdv && opt.OptionLevel == "Advanced" {
+					table.Append([]string{opt.OptName, formatBoolYesNo(opt.Modified), opt.Value, opt.DefaultValue, opt.OptionLevel})
 
+				}
 			}
-		}
-		table.Render()
+			table.Render()
+			fmt.Println("")
 
+		}
 	},
 }
 

glusterd2/commands/volumes/volume-create.go

@@ -2,6 +2,7 @@ package volumecommands
 
 import (
 	"errors"
+	"fmt"
 	"net/http"
 	"path/filepath"
 	"strconv"
@@ -42,6 +43,10 @@ func validateVolCreateReq(req *api.VolCreateReq) error {
 		return gderrors.ErrInvalidVolName
 	}
 
+	if gutils.IsReservedKeyword(req.Name) {
+		return fmt.Errorf("invalid name, volume name cannot be among reserved keywords:%v", gutils.ReservedKeywords)
+	}
+
 	if req.Transport != "" && req.Transport != "tcp" && req.Transport != "rdma" {
 		return errors.New("invalid transport. Supported values: tcp or rdma")
 	}

glusterd2/options/cluster.go

@@ -27,12 +27,10 @@ type validateFunc func(string, string) error
 
 // ClusterOptMap contains list of supported cluster-wide options, default values and value types
 var ClusterOptMap = map[string]*ClusterOption{
-	"cluster.shared-storage":         {"cluster.shared-storage", "off", OptionTypeBool, nil},
 	"cluster.op-version":             {"cluster.op-version", strconv.Itoa(gdctx.OpVersion), OptionTypeInt, nil},
 	"cluster.max-op-version":         {"cluster.max-op-version", strconv.Itoa(gdctx.OpVersion), OptionTypeInt, nil},
 	"cluster.brick-multiplex":        {"cluster.brick-multiplex", "off", OptionTypeBool, nil},
 	"cluster.max-bricks-per-process": {"cluster.max-bricks-per-process", "250", OptionTypeInt, nil},
-	"cluster.localtime-logging":      {"cluster.localtime-logging", "off", OptionTypeBool, nil},
 }
 
 // RegisterClusterOpValidationFunc registers a validation function for provided

pkg/restclient/cluster.go

@@ -0,0 +1,22 @@
+package restclient
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gluster/glusterd2/pkg/api"
+)
+
+// GetClusterOption gets cluster level options
+func (c *Client) GetClusterOption() ([]api.ClusterOptionsResp, error) {
+	url := fmt.Sprintf("/v1/cluster/options")
+	var resp []api.ClusterOptionsResp
+	err := c.get(url, nil, http.StatusOK, &resp)
+	return resp, err
+}
+
+// ClusterOptionSet sets cluster level options
+func (c *Client) ClusterOptionSet(req api.ClusterOptionReq) error {
+	url := fmt.Sprintf("/v1/cluster/options")
+	return c.post(url, req, http.StatusOK, nil)
+}

pkg/restclient/volume.go

@@ -117,14 +117,8 @@ func (c *Client) VolumeSet(volname string, req api.VolOptionReq) error {
 	return err
 }
 
-// ClusterOptionSet sets cluster level options
-func (c *Client) ClusterOptionSet(req api.ClusterOptionReq) error {
-	url := fmt.Sprintf("/v1/cluster/options")
-	return c.post(url, req, http.StatusOK, nil)
-}
-
 // VolumeGet gets volume options for a Gluster Volume
-func (c *Client) VolumeGet(volname string, optname string) (api.VolumeOptionsGetResp, error) {
+func (c *Client) VolumeGet(volname, optname string) (api.VolumeOptionsGetResp, error) {
 	if optname == "all" {
 		var opts api.VolumeOptionsGetResp
 		url := fmt.Sprintf("/v1/volumes/%s/options", volname)

pkg/utils/utils.go

@@ -31,6 +31,18 @@ const (
 	TiB = 1024 * GiB
 )
 
+var (
+	// ReservedKeywords are Glusterd2 reserved keywords and must not be used as
+	// resource(volume, peer etc) name to avoid conflict in glustercli.
+	ReservedKeywords = []string{"all", "volume", "status", "list", "cluster", "gluster", "brick"}
+)
+
+// IsReservedKeyword returns true if the resource name is one of the
+// GD2 Reserved Keyword
+func IsReservedKeyword(resourceName string) bool {
+	return StringInSlice(resourceName, ReservedKeywords)
+}
+
 // IsLocalAddress checks whether a given host/IP is local
 // Does lookup only after string matching IP addresses
 func IsLocalAddress(address string) (bool, error) {