// Join an existing cluster
func (s *Server) Join(primary string) error {
join := &Join{Self: s.cluster.self}
b := util.JSONEncode(join)
cs, err := transport.Encode(primary)
if err != nil {
return err
}
for {
body, err := s.client.SafePost(cs, "/join", b)
if err != nil {
log.Printf("Unable to join cluster: %s", err)
time.Sleep(1 * time.Second)
continue
}
resp := &JoinResponse{}
if err = util.JSONDecode(body, &resp); err != nil {
return err
}
s.cluster.Join(resp.Self, resp.Members)
return nil
}
}
// Server handlers
func (s *Server) joinHandler(w http.ResponseWriter, req *http.Request) {
log.Printf("handling /join %v", req)
j := &raft.DefaultJoinCommand{}
if err := util.JSONDecode(req.Body, j); err != nil {
log.Printf("Invalid join request: %s", err)
return
}
go func() {
log.Printf("Handling join request: %#v", j)
// Add node to the cluster
if _, err := s.raftServer.Do(j); err != nil {
return
}
}()
}
func (s *Server) replicationHandler(w http.ResponseWriter, req *http.Request) {
r := &Replicate{}
if err := util.JSONDecode(req.Body, r); err != nil {
log.Printf("Invalid replication request: %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
log.Printf("Handling replication request from %v", r.Self)
_, err := s.execute(r.Query)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
}
resp := &ReplicateResponse{
s.cluster.self,
}
b := util.JSONEncode(resp)
w.Write(b.Bytes())
}
// Server handlers
func (s *Server) joinHandler(w http.ResponseWriter, req *http.Request) {
j := &Join{}
if err := util.JSONDecode(req.Body, j); err != nil {
log.Printf("Invalid join request: %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
log.Printf("Handling join request: %#v", j)
// Add node to the cluster
if err := s.cluster.AddMember(j.Self); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
// Respond with the current cluster description
resp := &JoinResponse{
s.cluster.self,
s.cluster.members,
}
b := util.JSONEncode(resp)
w.Write(b.Bytes())
}