Merge branch 'master' of https://github.com/gluster/glusterd2 into cluster-wide-options

Author: rishubhjain

e2e/brickmux_test.go

@@ -42,6 +42,7 @@ func TestBrickMux(t *testing.T) {
 	}
 
 	volname1 := formatVolName(t.Name())
+	volname2 := volname1 + strconv.Itoa(2)
 
 	createReq := api.VolCreateReq{
 		Name: volname1,
@@ -84,8 +85,6 @@ func TestBrickMux(t *testing.T) {
 		brickPaths = append(brickPaths, brickPath)
 	}
 
-	volname2 := volname1 + "2"
-
 	createReq = api.VolCreateReq{
 		Name: volname2,
 		Subvols: []api.SubvolReq{
@@ -165,7 +164,7 @@ func TestBrickMux(t *testing.T) {
 	r.Nil(client.VolumeStop(volname2))
 
 	voloptReq := api.VolOptionReq{
-		Options: map[string]string{"write-behind.trickling-writes": "on"},
+		Options: map[string]string{"io-stats.count-fop-hits": "on"},
 	}
 	voloptReq.AllowAdvanced = true
 	err = client.VolumeSet(volname2, voloptReq)
@@ -244,7 +243,7 @@ func TestBrickMux(t *testing.T) {
 	}
 
 	// Stop glusterd2 instance and kill the glusterfsd into
-	// whcih all bricks were multiplexed
+	// which all bricks were multiplexed
 	r.Nil(tc.gds[0].Stop())
 	process, err = os.FindProcess(pid)
 	r.Nil(err, fmt.Sprintf("failed to find brick pid: %s", err))
@@ -276,5 +275,250 @@ func TestBrickMux(t *testing.T) {
 		r.Nil(client.VolumeStop(volname1 + strconv.Itoa(i)))
 		r.Nil(client.VolumeDelete(volname1 + strconv.Itoa(i)))
 	}
+
+	// Turn on brick mux max-bricks-per-process cluster option
+	optReq = api.ClusterOptionReq{
+		Options: map[string]string{"cluster.max-bricks-per-process": "5"},
+	}
+	err = client.ClusterOptionSet(optReq)
+	r.Nil(err)
+
+	for i := 36; i <= 100; i++ {
+		brickPath := testTempDir(t, "brick")
+		brickPaths = append(brickPaths, brickPath)
+	}
+
+	/* Test  for Testing max-bricks-per-process constraint while
+	multiplexing*/
+
+	// Create 10 volumes and start all 10
+	// making all brick multiplexed with the constraint that
+	// max-bricks-per-process is 5
+
+	index = 37
+	for i := 1; i <= 10; i++ {
+
+		createReq := api.VolCreateReq{
+			Name: volname1 + strconv.Itoa(i),
+			Subvols: []api.SubvolReq{
+				{
+					Type: "distribute",
+					Bricks: []api.BrickReq{
+						{PeerID: tc.gds[0].PeerID(), Path: brickPaths[index]},
+						{PeerID: tc.gds[0].PeerID(), Path: brickPaths[index+1]},
+					},
+				},
+			},
+			Force: true,
+		}
+
+		if i%2 != 0 {
+			createReq = api.VolCreateReq{
+				Name: volname1 + strconv.Itoa(i),
+				Subvols: []api.SubvolReq{
+					{
+						ReplicaCount: 2,
+						Type:         "replicate",
+						Bricks: []api.BrickReq{
+							{PeerID: tc.gds[0].PeerID(), Path: brickPaths[index]},
+							{PeerID: tc.gds[0].PeerID(), Path: brickPaths[index+1]},
+						},
+					},
+				},
+				Force: true,
+			}
+
+		}
+		_, err = client.VolumeCreate(createReq)
+		r.Nil(err)
+		// start the volume
+		err = client.VolumeStart(volname1+strconv.Itoa(i), false)
+		r.Nil(err)
+
+		index = index + 2
+	}
+
+	// pidMap and portMap just to mantain count of every pid and port of
+	// bricks from all 5 volumes.
+	pidMap := make(map[int]int)
+	portMap := make(map[int]int)
+	for i := 1; i <= 10; i++ {
+		bstatus, err := client.BricksStatus(volname1 + strconv.Itoa(i))
+		r.Nil(err)
+		for _, b := range bstatus {
+			if _, ok := pidMap[b.Pid]; ok {
+				pidMap[b.Pid]++
+			} else {
+				pidMap[b.Pid] = 1
+			}
+
+			if _, ok := portMap[b.Port]; ok {
+				portMap[b.Port]++
+			} else {
+				portMap[b.Port] = 1
+			}
+
+		}
+	}
+
+	// Check if all pid's and ports's have count = 2 as mentioned in
+	// max-bricks-per-process
+	for _, v := range pidMap {
+		r.Equal(v, 5)
+	}
+
+	for _, v := range portMap {
+		r.Equal(v, 5)
+	}
+
+	r.Nil(gd.Stop())
+	for k := range pidMap {
+		process, err := os.FindProcess(k)
+		r.Nil(err, fmt.Sprintf("failed to find brick pid: %s", err))
+		err = process.Signal(syscall.Signal(15))
+		r.Nil(err, fmt.Sprintf("failed to kill brick: %s", err))
+	}
+
+	// Spawn glusterd2 instance
+	gd, err = spawnGlusterd(t, "./config/1.toml", false)
+	r.Nil(err)
+	r.True(gd.IsRunning())
+
+	time.Sleep(10 * time.Millisecond)
+
+	pidMap = make(map[int]int)
+	portMap = make(map[int]int)
+	for i := 1; i <= 10; i++ {
+		bstatus, err := client.BricksStatus(volname1 + strconv.Itoa(i))
+		r.Nil(err)
+		for _, b := range bstatus {
+			if _, ok := pidMap[b.Pid]; ok {
+				pidMap[b.Pid]++
+			} else {
+				pidMap[b.Pid] = 1
+			}
+
+			if _, ok := portMap[b.Port]; ok {
+				portMap[b.Port]++
+			} else {
+				portMap[b.Port] = 1
+			}
+
+		}
+	}
+
+	// Check if all pid's and ports's have count = 2 as mentioned in
+	// max-bricks-per-process
+	for _, v := range pidMap {
+		r.Equal(v, 5)
+	}
+
+	for _, v := range portMap {
+		r.Equal(v, 5)
+	}
+
+	for i := 1; i <= 10; i++ {
+		r.Nil(client.VolumeStop(volname1 + strconv.Itoa(i)))
+		r.Nil(client.VolumeDelete(volname1 + strconv.Itoa(i)))
+	}
+
+	// Create two volumes with different options, so that bricks from these
+	// two volumes are multiplexed into bricks from their own volume. Also,
+	// check if among three bricks of a volume 2 bricks have same pid and
+	// port while 1 brick has a different pid and port, since num  of bricks
+	// are 3 and max-bricks-per-process is set as 2.
+
+	// Turn on brick mux cluster option
+	optReq = api.ClusterOptionReq{
+		Options: map[string]string{"cluster.max-bricks-per-process": "2"},
+	}
+	err = client.ClusterOptionSet(optReq)
+	r.Nil(err)
+
+	createReq = api.VolCreateReq{
+		Name: volname1,
+		Subvols: []api.SubvolReq{
+			{
+				ReplicaCount: 3,
+				Type:         "replicate",
+				Bricks: []api.BrickReq{
+					{PeerID: tc.gds[0].PeerID(), Path: brickPaths[51]},
+					{PeerID: tc.gds[0].PeerID(), Path: brickPaths[52]},
+					{PeerID: tc.gds[0].PeerID(), Path: brickPaths[53]},
+				},
+			},
+		},
+		Force: true,
+	}
+	_, err = client.VolumeCreate(createReq)
+	r.Nil(err)
+
+	// start the volume
+	err = client.VolumeStart(volname1, false)
+	r.Nil(err)
+
+	createReq = api.VolCreateReq{
+		Name: volname2,
+		Subvols: []api.SubvolReq{
+			{
+				Type: "distribute",
+				Bricks: []api.BrickReq{
+					{PeerID: tc.gds[0].PeerID(), Path: brickPaths[48]},
+					{PeerID: tc.gds[0].PeerID(), Path: brickPaths[49]},
+					{PeerID: tc.gds[0].PeerID(), Path: brickPaths[50]},
+				},
+			},
+		},
+		Force: true,
+	}
+	_, err = client.VolumeCreate(createReq)
+	r.Nil(err)
+
+	// Setting an option in second volume so that  second volume doesn't
+	// multiplex its brick into first volume
+	var optionReq api.VolOptionReq
+	optionReq.Options = map[string]string{"io-stats.count-fop-hits": "on"}
+	optionReq.AllowAdvanced = true
+
+	r.Nil(client.VolumeSet(volname2, optionReq))
+
+	// start the volume
+	err = client.VolumeStart(volname2, false)
+	r.Nil(err)
+
+	bstatus, err = client.BricksStatus(volname1)
+	r.Nil(err)
+
+	// Keep track of used unique pids and ports used in multiplexing bricks
+	// of  volname1 and calculate length length of maps, which should be equal to 2
+	pidMap = make(map[int]int)
+	portMap = make(map[int]int)
+	for _, b := range bstatus {
+		pidMap[b.Pid] = 1
+		portMap[b.Port] = 1
+	}
+	r.Equal(len(pidMap), 2)
+	r.Equal(len(portMap), 2)
+
+	bstatus2, err := client.BricksStatus(volname2)
+	r.Nil(err)
+
+	// Keep track of used unique pids and ports used in multiplexing bricks
+	// of  volname1 and calculate length length of maps, which should be equal to 2
+	pidMap = make(map[int]int)
+	portMap = make(map[int]int)
+	for _, b := range bstatus2 {
+		pidMap[b.Pid] = 1
+		portMap[b.Port] = 1
+	}
+	r.Equal(len(pidMap), 2)
+	r.Equal(len(portMap), 2)
+
+	r.Nil(client.VolumeStop(volname1))
+	r.Nil(client.VolumeDelete(volname1))
+
+	r.Nil(client.VolumeStop(volname2))
+	r.Nil(client.VolumeDelete(volname2))
+
 	r.Nil(gd.Stop())
 }

glustercli/cmd/cluster-options.go

@@ -57,7 +57,7 @@ func clusterSetCmdRun(cmd *cobra.Command, args []string) {
 		}
 		failure("Cluster option set failed", err, 1)
 	} else {
-		fmt.Printf("Options set successfully \n")
+		fmt.Println("Options set successfully")
 	}
 }
 
@@ -71,16 +71,12 @@ func clusterOptionJSONHandler(cmd *cobra.Command, options []string) error {
 
 	err := client.ClusterOptionSet(api.ClusterOptionReq{
 		Options: copt})
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 
 var clusterOptionGetCmd = &cobra.Command{
 	Use:   "get",
 	Short: helpClusterOptionGetCmd,
-	Args:  cobra.RangeArgs(0, 1),
 	Run: func(cmd *cobra.Command, args []string) {
 		table := tablewriter.NewWriter(os.Stdout)
 		opts, err := client.GetClusterOption()