// This is the only user-facing function, and accordingly the body is
// a raw string rather than JSON.
func (s *Server) sqlHandler(w http.ResponseWriter, req *http.Request) {
state := s.cluster.State()
if state != "primary" {
http.Error(w, "Only the primary can service queries, but this is a "+state, http.StatusBadRequest)
return
}
query, err := ioutil.ReadAll(req.Body)
if err != nil {
log.Printf("Couldn't read body: %s", err)
http.Error(w, err.Error(), http.StatusBadRequest)
}
log.Debugf("[%s] Received query: %#v", s.cluster.State(), string(query))
resp, err := s.execute(query)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
}
r := &Replicate{
Self: s.cluster.self,
Query: query,
}
for _, member := range s.cluster.members {
b := util.JSONEncode(r)
_, err := s.client.SafePost(member.ConnectionString, "/replicate", b)
if err != nil {
log.Printf("Couldn't replicate query to %v: %s", member, err)
}
}
log.Debugf("[%s] Returning response to %#v: %#v", s.cluster.State(), string(query), string(resp))
w.Write(resp)
}
// 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
}
}
// Join an existing cluster
func (s *Server) Join(primary string) error {
cs, err := transport.Encode(s.listen)
if err != nil {
return err
}
//log.Printf("My listen is: " + cs)
csPrimary, err := transport.Encode(primary)
if err != nil {
return err
}
//log.Printf("My listen is: " + s.listen)
//log.Printf("Attempting to Join: " + csPrimary)
command := &raft.DefaultJoinCommand{
Name: s.raftServer.Name(),
ConnectionString: cs,
}
b := util.JSONEncode(command)
for {
_, err := s.client.SafePost(csPrimary, "/join", "application/json", b)
return err
}
}
// Join an existing cluster
func (s *Server) ForwardJoin(command *raft.DefaultJoinCommand) error {
//log.Printf("Fowarding Join Request: %v", command)
csPrimary, err := s.GetLeaderCS()
if err != nil {
return err
}
b := util.JSONEncode(command)
for {
_, err := s.client.SafePost(csPrimary, "/join", "application/json", b)
return err
}
}
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())
}
// Join an existing cluster
func (s *Server) Join(primary string) error {
cs, err := transport.Encode(primary)
if err != nil {
return err
}
command := &raft.DefaultJoinCommand{
Name: s.raftServer.Name(),
ConnectionString: s.connectionString(),
}
for {
b := util.JSONEncode(command)
_, err = s.client.SafePost(cs, "/join", b)
if err != nil {
log.Printf("Unable to join cluster: %s", err)
time.Sleep(1 * time.Second)
continue
}
return nil
}
return nil
}
// Join an existing cluster
func (s *Server) Join(primary string) error {
command := &raft.DefaultJoinCommand{
Name: s.raftServer.Name(),
ConnectionString: s.connectionString,
}
b := util.JSONEncode(command)
log.Printf("Joining Cluster: %s", primary)
cs, err := transport.Encode(primary)
if err != nil {
return err
}
for i := 0; i < 5; i += 1 {
log.Printf("Join -> %s Command: %s", cs, command)
_, err = s.client.SafePost(cs, "/join", b)
if err != nil {
log.Printf("Unable to join cluster: %s", err)
} else {
break
}
}
return err
}
