mirror of
https://github.com/etcd-io/etcd.git
synced 2024-09-27 06:25:44 +00:00
358 lines
8.5 KiB
Go
358 lines
8.5 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
etcdErr "github.com/coreos/etcd/error"
|
|
"github.com/coreos/etcd/store"
|
|
"github.com/coreos/go-raft"
|
|
)
|
|
|
|
//-------------------------------------------------------------------
|
|
// Handlers to handle etcd-store related request via etcd url
|
|
//-------------------------------------------------------------------
|
|
|
|
func NewEtcdMuxer() *http.ServeMux {
|
|
// external commands
|
|
etcdMux := http.NewServeMux()
|
|
etcdMux.Handle("/"+version+"/keys/", errorHandler(Multiplexer))
|
|
etcdMux.Handle("/"+version+"/leader", errorHandler(LeaderHttpHandler))
|
|
etcdMux.Handle("/"+version+"/machines", errorHandler(MachinesHttpHandler))
|
|
etcdMux.Handle("/"+version+"/stats/", errorHandler(StatsHttpHandler))
|
|
etcdMux.Handle("/version", errorHandler(VersionHttpHandler))
|
|
etcdMux.HandleFunc("/test/", TestHttpHandler)
|
|
|
|
// backward support
|
|
etcdMux.Handle("/v1/keys/", errorHandler(MultiplexerV1))
|
|
etcdMux.Handle("/v1/leader", errorHandler(LeaderHttpHandler))
|
|
etcdMux.Handle("/v1/machines", errorHandler(MachinesHttpHandler))
|
|
etcdMux.Handle("/v1/stats/", errorHandler(StatsHttpHandler))
|
|
|
|
return etcdMux
|
|
}
|
|
|
|
type errorHandler func(http.ResponseWriter, *http.Request) error
|
|
|
|
// addCorsHeader parses the request Origin header and loops through the user
|
|
// provided allowed origins and sets the Access-Control-Allow-Origin header if
|
|
// there is a match.
|
|
func addCorsHeader(w http.ResponseWriter, r *http.Request) {
|
|
val, ok := corsList["*"]
|
|
if val && ok {
|
|
w.Header().Add("Access-Control-Allow-Origin", "*")
|
|
return
|
|
}
|
|
|
|
requestOrigin := r.Header.Get("Origin")
|
|
val, ok = corsList[requestOrigin]
|
|
if val && ok {
|
|
w.Header().Add("Access-Control-Allow-Origin", requestOrigin)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (fn errorHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
addCorsHeader(w, r)
|
|
if e := fn(w, r); e != nil {
|
|
if etcdErr, ok := e.(*etcdErr.Error); ok {
|
|
debug("Return error: ", (*etcdErr).Error())
|
|
etcdErr.Write(w)
|
|
} else {
|
|
http.Error(w, e.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Multiplex GET/POST/DELETE request to corresponding handlers
|
|
func Multiplexer(w http.ResponseWriter, req *http.Request) error {
|
|
|
|
switch req.Method {
|
|
case "GET":
|
|
return GetHttpHandler(w, req)
|
|
case "POST":
|
|
return CreateHttpHandler(w, req)
|
|
case "PUT":
|
|
return UpdateHttpHandler(w, req)
|
|
case "DELETE":
|
|
return DeleteHttpHandler(w, req)
|
|
default:
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
return nil
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
//--------------------------------------
|
|
// State sensitive handlers
|
|
// Set/Delete will dispatch to leader
|
|
//--------------------------------------
|
|
|
|
func CreateHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
key := getNodePath(req.URL.Path)
|
|
|
|
debugf("recv.post[%v] [%v%v]\n", req.RemoteAddr, req.Host, req.URL)
|
|
|
|
value := req.FormValue("value")
|
|
|
|
expireTime, err := durationToExpireTime(req.FormValue("ttl"))
|
|
|
|
if err != nil {
|
|
return etcdErr.NewError(etcdErr.EcodeTTLNaN, "Create", store.UndefIndex, store.UndefTerm)
|
|
}
|
|
|
|
command := &CreateCommand{
|
|
Key: key,
|
|
Value: value,
|
|
ExpireTime: expireTime,
|
|
}
|
|
|
|
if req.FormValue("incremental") == "true" {
|
|
command.IncrementalSuffix = true
|
|
}
|
|
|
|
return dispatchEtcdCommand(command, w, req)
|
|
|
|
}
|
|
|
|
func UpdateHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
key := getNodePath(req.URL.Path)
|
|
|
|
debugf("recv.put[%v] [%v%v]\n", req.RemoteAddr, req.Host, req.URL)
|
|
|
|
req.ParseForm()
|
|
|
|
value := req.Form.Get("value")
|
|
|
|
expireTime, err := durationToExpireTime(req.Form.Get("ttl"))
|
|
|
|
if err != nil {
|
|
return etcdErr.NewError(etcdErr.EcodeTTLNaN, "Update", store.UndefIndex, store.UndefTerm)
|
|
}
|
|
|
|
// update should give at least one option
|
|
if value == "" && expireTime.Sub(store.Permanent) == 0 {
|
|
return etcdErr.NewError(etcdErr.EcodeValueOrTTLRequired, "Update", store.UndefIndex, store.UndefTerm)
|
|
}
|
|
|
|
prevValue, valueOk := req.Form["prevValue"]
|
|
|
|
prevIndexStr, indexOk := req.Form["prevIndex"]
|
|
|
|
if !valueOk && !indexOk { // update without test
|
|
command := &UpdateCommand{
|
|
Key: key,
|
|
Value: value,
|
|
ExpireTime: expireTime,
|
|
}
|
|
|
|
return dispatchEtcdCommand(command, w, req)
|
|
|
|
} else { // update with test
|
|
var prevIndex uint64
|
|
|
|
if indexOk {
|
|
prevIndex, err = strconv.ParseUint(prevIndexStr[0], 10, 64)
|
|
|
|
// bad previous index
|
|
if err != nil {
|
|
return etcdErr.NewError(etcdErr.EcodeIndexNaN, "Update", store.UndefIndex, store.UndefTerm)
|
|
}
|
|
} else {
|
|
prevIndex = 0
|
|
}
|
|
|
|
command := &TestAndSetCommand{
|
|
Key: key,
|
|
Value: value,
|
|
PrevValue: prevValue[0],
|
|
PrevIndex: prevIndex,
|
|
}
|
|
|
|
return dispatchEtcdCommand(command, w, req)
|
|
}
|
|
|
|
}
|
|
|
|
// Delete Handler
|
|
func DeleteHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
key := getNodePath(req.URL.Path)
|
|
|
|
debugf("recv.delete[%v] [%v%v]\n", req.RemoteAddr, req.Host, req.URL)
|
|
|
|
command := &DeleteCommand{
|
|
Key: key,
|
|
}
|
|
|
|
if req.FormValue("recursive") == "true" {
|
|
command.Recursive = true
|
|
}
|
|
|
|
return dispatchEtcdCommand(command, w, req)
|
|
}
|
|
|
|
// Dispatch the command to leader
|
|
func dispatchEtcdCommand(c Command, w http.ResponseWriter, req *http.Request) error {
|
|
return dispatch(c, w, req, nameToEtcdURL)
|
|
}
|
|
|
|
//--------------------------------------
|
|
// State non-sensitive handlers
|
|
// command with consistent option will
|
|
// still dispatch to the leader
|
|
//--------------------------------------
|
|
|
|
// Handler to return the current leader's raft address
|
|
func LeaderHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
leader := r.Leader()
|
|
|
|
if leader != "" {
|
|
w.WriteHeader(http.StatusOK)
|
|
raftURL, _ := nameToRaftURL(leader)
|
|
w.Write([]byte(raftURL))
|
|
|
|
return nil
|
|
} else {
|
|
return etcdErr.NewError(etcdErr.EcodeLeaderElect, "", store.UndefIndex, store.UndefTerm)
|
|
}
|
|
}
|
|
|
|
// Handler to return all the known machines in the current cluster
|
|
func MachinesHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
machines := getMachines(nameToEtcdURL)
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte(strings.Join(machines, ", ")))
|
|
|
|
return nil
|
|
}
|
|
|
|
// Handler to return the current version of etcd
|
|
func VersionHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
w.WriteHeader(http.StatusOK)
|
|
fmt.Fprintf(w, "etcd %s", releaseVersion)
|
|
|
|
return nil
|
|
}
|
|
|
|
// Handler to return the basic stats of etcd
|
|
func StatsHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
option := req.URL.Path[len("/v1/stats/"):]
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
switch option {
|
|
case "self":
|
|
w.Write(r.Stats())
|
|
case "leader":
|
|
if r.State() == raft.Leader {
|
|
w.Write(r.PeerStats())
|
|
} else {
|
|
leader := r.Leader()
|
|
// current no leader
|
|
if leader == "" {
|
|
return etcdErr.NewError(300, "", store.UndefIndex, store.UndefTerm)
|
|
}
|
|
hostname, _ := nameToEtcdURL(leader)
|
|
redirect(hostname, w, req)
|
|
}
|
|
case "store":
|
|
w.Write(etcdStore.JsonStats())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func GetHttpHandler(w http.ResponseWriter, req *http.Request) error {
|
|
var err error
|
|
var event interface{}
|
|
debugf("recv.get[%v] [%v%v]\n", req.RemoteAddr, req.Host, req.URL)
|
|
|
|
if req.FormValue("consistent") == "true" && r.State() != raft.Leader {
|
|
// help client to redirect the request to the current leader
|
|
leader := r.Leader()
|
|
hostname, _ := nameToEtcdURL(leader)
|
|
redirect(hostname, w, req)
|
|
return nil
|
|
}
|
|
|
|
key := getNodePath(req.URL.Path)
|
|
|
|
recursive := req.FormValue("recursive")
|
|
|
|
if req.FormValue("wait") == "true" { // watch
|
|
command := &WatchCommand{
|
|
Key: key,
|
|
}
|
|
|
|
if recursive == "true" {
|
|
command.Recursive = true
|
|
}
|
|
|
|
indexStr := req.FormValue("wait_index")
|
|
if indexStr != "" {
|
|
sinceIndex, err := strconv.ParseUint(indexStr, 10, 64)
|
|
|
|
if err != nil {
|
|
return etcdErr.NewError(etcdErr.EcodeIndexNaN, "Watch From Index", store.UndefIndex, store.UndefTerm)
|
|
}
|
|
|
|
command.SinceIndex = sinceIndex
|
|
}
|
|
|
|
event, err = command.Apply(r.Server)
|
|
|
|
} else { //get
|
|
|
|
command := &GetCommand{
|
|
Key: key,
|
|
}
|
|
|
|
sorted := req.FormValue("sorted")
|
|
if sorted == "true" {
|
|
command.Sorted = true
|
|
}
|
|
|
|
if recursive == "true" {
|
|
command.Recursive = true
|
|
}
|
|
|
|
event, err = command.Apply(r.Server)
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
|
|
} else {
|
|
event, _ := event.(*store.Event)
|
|
bytes, _ := json.Marshal(event)
|
|
|
|
w.Header().Add("X-Etcd-Index", fmt.Sprint(event.Index))
|
|
w.Header().Add("X-Etcd-Term", fmt.Sprint(event.Term))
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
w.Write(bytes)
|
|
|
|
return nil
|
|
}
|
|
|
|
}
|
|
|
|
// TestHandler
|
|
func TestHttpHandler(w http.ResponseWriter, req *http.Request) {
|
|
testType := req.URL.Path[len("/test/"):]
|
|
|
|
if testType == "speed" {
|
|
directSet()
|
|
w.WriteHeader(http.StatusOK)
|
|
w.Write([]byte("speed test success"))
|
|
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
}
|