Edit Zone API

glusterd2/commands/peers/addpeer.go

@@ -3,6 +3,7 @@ package peercommands
 import (
 	"fmt"
 	"net/http"
+	"strings"
 
 	"github.com/gluster/glusterd2/glusterd2/events"
 	"github.com/gluster/glusterd2/glusterd2/gdctx"
@@ -25,6 +26,14 @@ func addPeerHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	for key := range req.Metadata {
+		if strings.HasPrefix(key, "_") {
+			logger.WithField("metadata-key", key).Error("Key names starting with '_' are restricted in metadata field")
+			restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, "Key names starting with '_' are restricted in metadata field")
+			return
+		}
+	}
+
 	if len(req.Addresses) < 1 {
 		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, errors.ErrNoHostnamesPresent)
 		return
@@ -84,7 +93,13 @@ func addPeerHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	newpeer.MetaData = req.MetaData
+	if req.Zone != "" {
+		newpeer.Metadata["_zone"] = req.Zone
+	}
+	for key, value := range req.Metadata {
+		newpeer.Metadata[key] = value
+	}
+
 	err = peer.AddOrUpdatePeer(newpeer)
 	if err != nil {
 		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, "Fail to add metadata to peer")
@@ -104,6 +119,6 @@ func createPeerAddResp(p *peer.Peer) *api.PeerAddResp {
 		Name:            p.Name,
 		PeerAddresses:   p.PeerAddresses,
 		ClientAddresses: p.ClientAddresses,
-		MetaData:        p.MetaData,
+		Metadata:        p.Metadata,
 	}
 }

glusterd2/commands/peers/editpeer.go

@@ -32,7 +32,7 @@ func editPeer(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	for key := range req.MetaData {
+	for key := range req.Metadata {
 		if strings.HasPrefix(key, "_") {
 			logger.WithField("metadata-key", key).Error("Key names starting with '_' are restricted in metadata field")
 			restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, "Key names starting with '_' are restricted in metadata field")
@@ -58,7 +58,7 @@ func editPeer(w http.ResponseWriter, r *http.Request) {
 	}
 	err = txn.Ctx.Set("peerid", peerID)
 	if err != nil {
-		logger.WithError(err).WithField("key", peerID).Error("Failed to set key in transaction context")
+		logger.WithError(err).WithField("key", "peerid").WithField("value", peerID).Error("Failed to set key in transaction context")
 		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
 		return
 	}
@@ -102,13 +102,13 @@ func txnPeerEdit(c transaction.TxnCtx) error {
 		c.Logger().WithError(err).WithField("peerid", peerID).Error("Peer ID not found in store")
 		return err
 	}
-	for k, v := range req.MetaData {
-		if peerInfo.MetaData != nil {
-			peerInfo.MetaData[k] = v
-		} else {
-			peerInfo.MetaData = make(map[string]string)
-			peerInfo.MetaData[k] = v
-		}
+
+	for k, v := range req.Metadata {
+		peerInfo.Metadata[k] = v
+	}
+
+	if req.Zone != "" {
+		peerInfo.Metadata["_zone"] = req.Zone
 	}
 	err = peer.AddOrUpdatePeer(peerInfo)
 	if err != nil {
@@ -141,6 +141,6 @@ func createPeerEditResp(p *peer.Peer) *api.PeerEditResp {
 		Name:            p.Name,
 		PeerAddresses:   p.PeerAddresses,
 		ClientAddresses: p.ClientAddresses,
-		MetaData:        p.MetaData,
+		Metadata:        p.Metadata,
 	}
 }

glusterd2/commands/peers/getpeer.go

@@ -38,6 +38,6 @@ func createPeerGetResp(p *peer.Peer) *api.PeerGetResp {
 		PeerAddresses:   p.PeerAddresses,
 		ClientAddresses: p.ClientAddresses,
 		Online:          store.Store.IsNodeAlive(p.ID),
-		MetaData:        p.MetaData,
+		Metadata:        p.Metadata,
 	}
 }

glusterd2/commands/peers/getpeers.go

@@ -32,7 +32,7 @@ func createPeerListResp(peers []*peer.Peer) *api.PeerListResp {
 			PeerAddresses:   p.PeerAddresses,
 			ClientAddresses: p.ClientAddresses,
 			Online:          store.Store.IsNodeAlive(p.ID),
-			MetaData:        p.MetaData,
+			Metadata:        p.Metadata,
 		})
 	}
 

glusterd2/peer/peer.go

@@ -11,7 +11,7 @@ type Peer struct {
 	Name            string
 	PeerAddresses   []string
 	ClientAddresses []string
-	MetaData        map[string]string
+	Metadata        map[string]string
 }
 
 // ETCDConfig represents the structure which holds the ETCD env variables &

glusterd2/peer/self.go

@@ -5,6 +5,7 @@ import (
 	"net"
 
 	"github.com/gluster/glusterd2/glusterd2/gdctx"
+	"github.com/gluster/glusterd2/pkg/errors"
 
 	config "github.com/spf13/viper"
 )
@@ -39,18 +40,27 @@ func normalizeAddrs() ([]string, error) {
 
 // AddSelfDetails results in the peer adding its own details into etcd
 func AddSelfDetails() error {
-	var err error
 
+	var err error
 	p := &Peer{
 		ID:            gdctx.MyUUID,
 		Name:          gdctx.HostName,
 		PeerAddresses: []string{config.GetString("peeraddress")},
 	}
-
 	p.ClientAddresses, err = normalizeAddrs()
 	if err != nil {
 		return err
 	}
 
+	peerInfo, err := GetPeer(gdctx.MyUUID.String())
+	if err == errors.ErrPeerNotFound {
+		p.Metadata = make(map[string]string)
+		p.Metadata["_zone"] = p.ID.String()
+	} else if err == nil && peerInfo != nil {
+		p.Metadata = peerInfo.Metadata
+	} else {
+		return err
+	}
+
 	return AddOrUpdatePeer(p)
 }

pkg/api/peer_req_resp.go

@@ -9,24 +9,26 @@ type Peer struct {
 	PeerAddresses   []string          `json:"peer-addresses"`
 	ClientAddresses []string          `json:"client-addresses"`
 	Online          bool              `json:"online"`
-	MetaData        map[string]string `json:"metadata"`
+	Metadata        map[string]string `json:"metadata"`
 }
 
 // PeerAddReq represents an incoming request to add a peer to the cluster
 type PeerAddReq struct {
 	Addresses []string          `json:"addresses"`
-	MetaData  map[string]string `json:"metadata"`
+	Zone      string            `json:"zone,omitempty"`
+	Metadata  map[string]string `json:"metadata,omitempty"`
 }
 
 // PeerEditReq represents an incoming request to edit metadata of peer
 type PeerEditReq struct {
-	MetaData map[string]string `json:"metadata"`
+	Zone     string            `json:"zone"`
+	Metadata map[string]string `json:"metadata"`
 }
 
 // PeerAddResp is the success response sent to a PeerAddReq request
 type PeerAddResp Peer
 
-// PeerEditResp is the success response sent to a MetaDataEditReq request
+// PeerEditResp is the success response sent to a PeerEditReq request
 type PeerEditResp Peer
 
 // PeerGetResp is the response sent for a peer get request

plugins/device/api/resp.go

@@ -4,7 +4,7 @@ import (
 	"github.com/gluster/glusterd2/pkg/api"
 )
 
-// Info represents structure in which devices are to be store in Peer MetaData
+// Info represents structure in which devices are to be store in Peer Metadata
 type Info struct {
 	Name  string `json:"name"`
 	State string `json:"state"`

plugins/device/cmdexec/device.go

@@ -0,0 +1,51 @@
+package cmdexec
+
+import (
+	"os/exec"
+	"strings"
+
+	"github.com/gluster/glusterd2/glusterd2/transaction"
+)
+
+func createVgName(device string) string {
+	vgName := strings.Replace("vg"+device, "/", "-", -1)
+	return vgName
+}
+
+// DeviceSetup is used to prepare device before using devices.
+func DeviceSetup(c transaction.TxnCtx, device string) error {
+
+	var err error
+	defer func() {
+		if err != nil {
+			DeviceCleanup(c, device)
+		}
+	}()
+	pvcreateCmd := exec.Command("pvcreate", "--metadatasize=128M", "--dataalignment=256K", device)
+	if err := pvcreateCmd.Run(); err != nil {
+		c.Logger().WithError(err).WithField("device", device).Error("pvcreate failed for device")
+		return err
+	}
+	vgName := createVgName(device)
+	vgcreateCmd := exec.Command("vgcreate", vgName, device)
+	if err = vgcreateCmd.Run(); err != nil {
+		c.Logger().WithError(err).WithField("device", device).Error("vgcreate failed for device")
+		return err
+	}
+
+	return nil
+
+}
+
+// DeviceCleanup is used to clean up devices.
+func DeviceCleanup(c transaction.TxnCtx, device string) {
+	vgName := createVgName(device)
+	vgremoveCmd := exec.Command("vgremove", vgName)
+	if err := vgremoveCmd.Run(); err != nil {
+		c.Logger().WithError(err).WithField("device", device).Error("vgremove failed for device")
+	}
+	pvremoveCmd := exec.Command("pvremove", device)
+	if err := pvremoveCmd.Run(); err != nil {
+		c.Logger().WithError(err).WithField("device", device).Error("pvremove failed for device")
+	}
+}

plugins/device/init.go

@@ -26,7 +26,8 @@ func (p *Plugin) RestRoutes() route.Routes {
 			Version:      1,
 			RequestType:  utils.GetTypeString((*deviceapi.AddDeviceReq)(nil)),
 			ResponseType: utils.GetTypeString((*deviceapi.AddDeviceResp)(nil)),
-			HandlerFunc:  deviceAddHandler},
+			HandlerFunc:  deviceAddHandler,
+		},
 	}
 }
 

plugins/device/rest.go

@@ -1,6 +1,7 @@
 package device
 
 import (
+	"encoding/json"
 	"net/http"
 
 	"github.com/gluster/glusterd2/glusterd2/gdctx"
@@ -18,18 +19,30 @@ func deviceAddHandler(w http.ResponseWriter, r *http.Request) {
 
 	ctx := r.Context()
 	logger := gdctx.GetReqLogger(ctx)
+	peerID := mux.Vars(r)["peerid"]
+	if uuid.Parse(peerID) == nil {
+		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, "Invalid peer-id passed in url")
+		return
+	}
 
 	req := new(deviceapi.AddDeviceReq)
 	if err := restutils.UnmarshalRequest(r, req); err != nil {
 		logger.WithError(err).Error("Failed to Unmarshal request")
 		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, errors.ErrJSONParsingFailed)
 		return
 	}
-	peerID := mux.Vars(r)["peerid"]
-	if peerID == "" {
-		restutils.SendHTTPError(ctx, w, http.StatusBadRequest, "peerid not present in request")
+
+	lock, unlock := transaction.CreateLockFuncs(peerID)
+	if err := lock(ctx); err != nil {
+		if err == transaction.ErrLockTimeout {
+			restutils.SendHTTPError(ctx, w, http.StatusConflict, err)
+		} else {
+			restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		}
 		return
 	}
+	defer unlock(ctx)
+
 	peerInfo, err := peer.GetPeer(peerID)
 	if err != nil {
 		logger.WithError(err).WithField("peerid", peerID).Error("Peer ID not found in store")
@@ -40,27 +53,39 @@ func deviceAddHandler(w http.ResponseWriter, r *http.Request) {
 		}
 		return
 	}
+
+	var devices []deviceapi.Info
+	err = json.Unmarshal([]byte(peerInfo.Metadata["_"]), &devices)
+	if err != nil {
+		logger.WithError(err).WithField("peerid", peerID).Error(err)
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
+		return
+	}
+	if !CheckIfDeviceExist(req.Devices, devices) {
+		logger.WithError(err).WithField("device", req.Devices).Error(" One or more devices already exists")
+		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, " One or more devices already exists")
+		return
+	}
+
 	txn := transaction.NewTxn(ctx)
 	defer txn.Cleanup()
-	lock, unlock, err := transaction.CreateLockSteps(peerInfo.ID.String())
+
 	txn.Nodes = []uuid.UUID{peerInfo.ID}
 	txn.Steps = []*transaction.Step{
-		lock,
 		{
 			DoFunc: "prepare-device",
 			Nodes:  txn.Nodes,
 		},
-		unlock,
 	}
-	err = txn.Ctx.Set("peerid", peerID)
+	err = txn.Ctx.Set("peerid", &peerID)
 	if err != nil {
-		logger.WithError(err).Error("Failed to set data for transaction")
+		logger.WithError(err).WithField("key", "peerid").WithField("value", peerID).Error("Failed to set key in transaction context")
 		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
 		return
 	}
-	err = txn.Ctx.Set("req", req)
+	err = txn.Ctx.Set("", &req.Devices)
 	if err != nil {
-		logger.WithError(err).Error("Failed to set data for transaction")
+		logger.WithError(err).WithField("key", "").Error("Failed to set key in transaction context")
 		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, err)
 		return
 	}
@@ -72,7 +97,7 @@ func deviceAddHandler(w http.ResponseWriter, r *http.Request) {
 	}
 	peerInfo, err = peer.GetPeer(peerID)
 	if err != nil {
-		logger.WithError(err).Error("Failed to get peer from store")
+		logger.WithError(err).WithField("peerid", peerID).Error("Failed to get peer from store")
 		restutils.SendHTTPError(ctx, w, http.StatusInternalServerError, "Failed to get peer from store")
 		return
 	}

plugins/device/store-utils.go

@@ -13,16 +13,29 @@ func GetDevices(peerID string) ([]deviceapi.Info, error) {
 	if err != nil {
 		return nil, err
 	}
-	if len(peerInfo.MetaData["devices"]) > 0 {
+	if len(peerInfo.Metadata["_devices"]) > 0 {
 		var deviceInfo []deviceapi.Info
-		if err := json.Unmarshal([]byte(peerInfo.MetaData["devices"]), &deviceInfo); err != nil {
+		if err := json.Unmarshal([]byte(peerInfo.Metadata["_devices"]), &deviceInfo); err != nil {
 			return nil, err
 		}
 		return deviceInfo, nil
 	}
 	return nil, nil
 }
 
+//CheckIfDeviceExist returns error if all devices already exist or returns list of devices to be added
+func CheckIfDeviceExist(reqDevices []string, devices []deviceapi.Info) bool {
+
+	for _, key := range reqDevices {
+		for _, reqKey := range devices {
+			if key == reqKey.Name {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 // AddDevices adds device to specific peer
 func AddDevices(devices []deviceapi.Info, peerID string) error {
 	deviceDetails, err := GetDevices(peerID)
@@ -40,7 +53,7 @@ func AddDevices(devices []deviceapi.Info, peerID string) error {
 	if err != nil {
 		return err
 	}
-	peerInfo.MetaData["devices"] = string(deviceJSON)
+	peerInfo.Metadata["_devices"] = string(deviceJSON)
 	err = peer.AddOrUpdatePeer(peerInfo)
 	if err != nil {
 		return err