// 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) }
// 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) { query, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("Couldn't read body: %s", err) http.Error(w, err.Error(), http.StatusBadRequest) return } log.Debugf("[%s] Received query: %#v", s.raftServer.State(), string(query)) // Execute the command against the Raft server. leader := s.raftServer.Leader() for leader == "" { time.Sleep(50 * time.Millisecond) leader = s.raftServer.Leader() } if s.name != leader { my_partial_name := strings.TrimSuffix(strings.TrimPrefix(s.name, ".-"), ".sock") leader_partial_name := strings.TrimSuffix(strings.TrimPrefix(leader, ".-"), ".sock") redirect_url := "http://" + strings.Replace(req.Host, my_partial_name, leader_partial_name, -1) + "/forward?query=" + encodeQuery(query) log.Printf("Redirecting to %s", redirect_url) http.Redirect(w, req, redirect_url, 302) return } resp, err := s.raftServer.Do(NewSqlCommand(string(query))) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } resp_frd := resp.([]byte) log.Debugf("[%s] Returning response to %#v: %#v", s.raftServer.State(), string(query), string(resp_frd)) w.Write(resp_frd) }
// 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() query, err := ioutil.ReadAll(req.Body) if state != "primary" { log.Printf("I AM NOT THE PRIMARY, NEED TO FORWARD THIS REQUEST TO MASTER") //cs, err := transport.Encode(primary) response, err := s.client.SafePost(s.cluster.primary.ConnectionString, "/sql", bytes.NewReader(query)) if response == nil || err != nil { http.Error(w, "", http.StatusBadRequest) return } else { r, _ := ioutil.ReadAll(response) w.Write(r) } //http.Error(w, "Only the primary can service queries, but this is a "+state, http.StatusBadRequest) return } if err != nil { log.Printf("Couldn't read body: %s", err) http.Error(w, "", http.StatusBadRequest) } log.Debugf("[%s] Received query: %#v", s.cluster.State(), string(query)) resp, err := s.execute(query) if err != nil { http.Error(w, "", 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) }
// 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) { if s.block { time.Sleep(1000000 * time.Second) } query, err := ioutil.ReadAll(req.Body) if err != nil { log.Printf("Couldn't read body: %s", err) http.Error(w, err.Error(), http.StatusBadRequest) } if s.leader != s.listen { cs, errLeader := transport.Encode(s.leader) if errLeader != nil { http.Error(w, "Only the primary can service queries, but this is a secondary", http.StatusBadRequest) log.Printf("Leader ain't present?: %s", errLeader) return } //_, errLeaderHealthCheck := s.client.SafeGet(cs, "/healthcheck") //if errLeaderHealthCheck != nil { // http.Error(w, "Primary is down", http.StatusBadRequest) // return //} body, errLResp := s.client.SafePost(cs, "/sql", bytes.NewBufferString(string(query))) if errLResp != nil { s.block = true http.Error(w, "Can't forward request to primary, gotta block now", http.StatusBadRequest) return // log.Printf("Didn't get reply from leader: %s", errLResp) } formatted := fmt.Sprintf("%s", body) resp := []byte(formatted) w.Write(resp) return } else { log.Debugf("Primary Received query: %#v", string(query)) resp, err := s.execute(query) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) } w.Write(resp) return } }
func (s *Server) forwardHandler(w http.ResponseWriter, req *http.Request) { query := req.URL.Query() encoded_query := query["query"][0] decoded_query, err := decodeQuery(encoded_query) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } resp, err := s.raftServer.Do(NewSqlCommand(string(decoded_query))) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } resp_frd := resp.([]byte) log.Debugf("[%s] Returning response to %#v: %#v", s.raftServer.State(), string(decoded_query), string(resp_frd)) w.Write(resp_frd) }
// 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) { // Read the value from the POST body. b, err := ioutil.ReadAll(req.Body) if err != nil { w.WriteHeader(http.StatusBadRequest) return } value := string(b) var output *sql.Output for { if s.raftServer.State() == raft.Candidate { time.Sleep(time.Millisecond * 100) } else { break } } /* if s.raftServer.State() != raft.Leader { cmd := &ExecCommand{ Data: *raft.NewExecuteCommand("", value), Reply: make(chan *raft.ExecuteCommandReply), } s.execCommand <- cmd reply := <-cmd.Reply output = &reply.Output err = reply.Error } else { */ if s.raftServer.State() == raft.Leader { resp, err := s.raftServer.Do(raft.NewExecuteCommand(s.raftServer.Leader(), value)) if err == nil { output = resp.(*sql.Output) } formatted := "" // Execute the command against the Raft server. if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) formatted = err.Error() } else { formatted = fmt.Sprintf("SequenceNumber: %d\n%s", output.SequenceNumber, output.Stdout) } log.Debugf("[%s] Returning response to %#v: %#v", s.raftServer.Leader(), value, formatted) w.Write([]byte(formatted)) } else { /* cmd := &ExecCommand{ Data: *raft.NewExecuteCommand("", value), Reply: make(chan *raft.ExecuteCommandReply), } s.execCommand <- cmd reply := <-cmd.Reply output = &reply.Output err = reply.Error formatted := "" // Execute the command against the Raft server. if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) formatted = err.Error() } else { formatted = fmt.Sprintf("SequenceNumber: %d\n%s", output.SequenceNumber, output.Stdout) } log.Debugf("[%s] Returning response to %#v: %#v", s.raftServer.Leader(), value, formatted) w.Write([]byte(formatted)) */ for { p, ok := s.raftServer.Peers()[s.raftServer.Leader()] if ok { r, e := s.client.SafePost(p.ConnectionString, "/sql", bytes.NewBuffer(b)) if e == nil { rb, e := ioutil.ReadAll(r) if e == nil { w.Write(rb) return } } } time.Sleep(100 * time.Millisecond) } } }