probaly fixes #2

src/rbmd/http.go

@@ -18,66 +18,91 @@ type ServerConf struct {
 
 //MountHandler /mount location
 func (wr wrr) MountHandler (w http.ResponseWriter, r *http.Request) {
-		decoder := json.NewDecoder(r.Body)
-		var m RBDDevice
-		err := decoder.Decode(&m)
-		log.Print("[DEBUG] ", m)
-		var msE []byte
-		if err != nil {
-			msE, _ = json.Marshal(MountState{"FAIL", "JSON parse failure"})
-			w.Write(msE)
-			return
-		}
+	decoder := json.NewDecoder(r.Body)
+	var m RBDDevice
+	err := decoder.Decode(&m)
+	log.Print("[DEBUG] ", m)
+	var msE []byte
+	if err != nil {
+		msE, _ = json.Marshal(MountState{"FAIL", "JSON parse failure"})
+		w.Write(msE)
+		return
+	}
 
-		// var wCh chan MountState
-		wCh := make(chan MountState, 1)
-		go func() { wCh <- wr.z.WatchAnswer(m.Node, "mount") }()
-		err = wr.z.MountRequest(m)
-		if err != nil {
-			w.Write(msE)
-		}
+	// var wCh chan MountState
+	wCh := make(chan MountState, 1)
+	go func() { wCh <- wr.z.WatchAnswer(m.Node, "mount") }()
+	err = wr.z.MountRequest(m)
+	if err != nil {
+		w.Write(msE)
+	}
 
-		answerState := <-wCh
-		log.Print(answerState)
-		wr.z.RMR(strings.Join([]string{wr.z.Path, "cluster", wr.Fqdn, "answers", "mount"}, "/"))
-		state, err := json.Marshal(answerState)
-		if err != nil {
-			log.Print("[ERROR] ", err)
-			w.Write(msE)
-		}
-		w.Write(state)
+	answerState := <-wCh
+	log.Print(answerState)
+	wr.z.RMR(strings.Join([]string{wr.z.Path, "cluster", wr.Fqdn, "answers", "mount"}, "/"))
+	state, err := json.Marshal(answerState)
+	if err != nil {
+		log.Print("[ERROR] ", err)
+		w.Write(msE)
+	}
+	w.Write(state)
 }
 
 //UmountHandler /umount location
 func (wr wrr) UmountHandler (w http.ResponseWriter, r *http.Request) {
-		decoder := json.NewDecoder(r.Body)
-		var m RBDDevice
-		err := decoder.Decode(&m)
-		log.Print("[DEBUG] ", m)
-		var msE []byte
-		if err != nil {
-			msE, _ = json.Marshal(MountState{"FAIL", "JSON parse failure"})
-			w.Write(msE)
-			return
-		}
+	decoder := json.NewDecoder(r.Body)
+	var m RBDDevice
+	err := decoder.Decode(&m)
+	log.Print("[DEBUG] ", m)
+	var msE []byte
+	if err != nil {
+		msE, _ = json.Marshal(MountState{"FAIL", "JSON parse failure"})
+		w.Write(msE)
+		return
+	}
 
-		// var wCh chan MountState
-		wCh := make(chan MountState, 1)
-		go func() { wCh <- wr.z.WatchAnswer(m.Node, "umount") }()
-		err = wr.z.UmountRequest(m)
-		if err != nil {
-			w.Write(msE)
-		}
+	// var wCh chan MountState
+	wCh := make(chan MountState, 1)
+	go func() { wCh <- wr.z.WatchAnswer(m.Node, "umount") }()
+	err = wr.z.UmountRequest(m)
+	if err != nil {
+		w.Write(msE)
+	}
 
-		answerState := <-wCh
-		log.Print(answerState)
-		wr.z.RMR(strings.Join([]string{wr.z.Path, "cluster", wr.Fqdn, "answers", "umount"}, "/"))
-		state, err := json.Marshal(answerState)
-		if err != nil {
-			log.Print("[ERROR] ", err)
-			w.Write(msE)
-		}
-		w.Write(state)
+	answerState := <-wCh
+	log.Print(answerState)
+	wr.z.RMR(strings.Join([]string{wr.z.Path, "cluster", wr.Fqdn, "answers", "umount"}, "/"))
+	state, err := json.Marshal(answerState)
+	if err != nil {
+		log.Print("[ERROR] ", err)
+		w.Write(msE)
+	}
+	w.Write(state)
+}
+
+
+//Resolve resolve request
+type Resolve struct {
+	Node string `json:"node"`
+}
+
+//ResolveHandler resolve `deadly.` state. /resolve location
+func (wr wrr) ResoleHandler(w http.ResponseWriter, r *http.Request) {
+	decoder := json.NewDecoder(r.Body)
+	var res Resolve
+	err := decoder.Decode(&res)
+	var msE []byte
+	if err != nil {
+		msE, _ = json.Marshal(MountState{"FAIL", "JSON parse failure"})
+		w.Write(msE)
+		return
+	}
+
+	if err := wr.z.ResolveRequest(res); err != nil {
+		w.WriteHeader(500)
+	}
+
+	w.WriteHeader(200)
 }
 
 //wrr API
@@ -120,6 +145,9 @@ func (s ServerConf) ServeHTTP(z ZooNode, fqdn string) {
 	// Umount volume. Accept JSON. Return JSON.
 	http.HandleFunc("/umount", wr.UmountHandler)
 
+	// Umount volume. Accept JSON. Return JSON.
+	http.HandleFunc("/resolve", wr.ResoleHandler)
+
 	server := &http.Server{
 		Addr: s.Addr,
 	}

src/rbmd/requests.go

@@ -72,8 +72,14 @@ func (z ZooNode) RequestWatch(fqdn string) {
 					break
 				}
 				z.Answer(fqdn, child, std, "OK")
+			} else if child == "resolve" && z.GetLeader() == fqdn {
+				if err := z.Resolve(fqdn); err != nil {
+					log.Print("[ERROR] ", err)
+					z.RMR(p)
+				}
 			} else {
-				log.Print("[DEBUG] Unknown ", child)
+				log.Print("[ERROR] Unknown request: ", child)
+				z.RMR(p)
 			}
 			z.RMR(p)
 		}
@@ -81,6 +87,49 @@ func (z ZooNode) RequestWatch(fqdn string) {
 	}
 }
 
+//Resolve delete node from quorum
+func (z ZooNode) Resolve(fqdn string) error {
+	resolvePath := strings.Join([]string{z.Path, "cluster", fqdn, "requests", "resolve"}, "/")
+
+	r, _, err := z.Conn.Get(resolvePath)
+	if err != nil {
+		return err
+	}
+	
+	var res Resolve
+	if err := json.Unmarshal(r, &res); err != nil {
+		return err
+	}
+
+	deadlyNodePath := strings.Join([]string{z.Path, "cluster", res.Node}, "/")
+	z.RMR(resolvePath)
+	z.RMR(deadlyNodePath)
+
+	return nil
+}
+
+//ResolveRequest make request for resolve deadly.
+func (z ZooNode) ResolveRequest(r Resolve) error {
+	leader := z.GetLeader()
+	resolvePath := strings.Join([]string{z.Path, "cluster", leader, "requests", "resolve"}, "/")
+
+	jsReq, err := json.Marshal(r)
+	if err != nil {
+		return err
+	}
+
+	_, err = z.Conn.Create(resolvePath, jsReq, 0, zk.WorldACL(zk.PermAll))
+	if err != nil {
+		_, err := z.Conn.Set(resolvePath, jsReq, -1)
+		if err != nil {
+			log.Print("[zk ERROR] ", err)
+			return err
+		}
+	}
+	
+	return nil
+}
+
 //Answer make answer
 func (z ZooNode) Answer(fqdn string, req string, stderr []byte, t string) {
 	answerPath := strings.Join([]string{z.Path, "cluster", fqdn, "answers", req}, "/")

src/rbmd/version.go

@@ -8,6 +8,6 @@ import (
 
 //VersionShow show version and exit
 func VersionShow() {
-	fmt.Println("RBMD 0.0.2", runtime.Version(), runtime.GOARCH)
+	fmt.Println("RBMD 0.0.3", runtime.Version(), runtime.GOARCH)
 	os.Exit(1)
 }