Refactor v1 API into server/v1.

server/v1/delete_key_handler.go

@@ -0,0 +1,13 @@
+package v1
+
+func deleteKeyHandler(w http.ResponseWriter, req *http.Request, e *etcdServer) error {
+	key := req.URL.Path[len("/v1/keys/"):]
+
+	debugf("[recv] DELETE %v/v1/keys/%s [%s]", e.url, key, req.RemoteAddr)
+
+	command := &DeleteCommand{
+		Key: key,
+	}
+
+	return dispatchEtcdCommandV1(command, w, req)
+}

server/v1/dispatch.go

@@ -0,0 +1,42 @@
+package v1
+
+// Dispatch the command to leader.
+func dispatchCommand(c Command, w http.ResponseWriter, req *http.Request) error {
+	return dispatch(c, w, req, nameToEtcdURL)
+}
+
+// Dispatches a command to a given URL.
+func dispatch(c Command, w http.ResponseWriter, req *http.Request, toURL func(name string) (string, bool)) error {
+	r := e.raftServer
+	if r.State() == raft.Leader {
+		if event, err := r.Do(c); err != nil {
+			return err
+		} else {
+			if event == nil {
+				return etcdErr.NewError(300, "Empty result from raft", store.UndefIndex, store.UndefTerm)
+			}
+
+			event, _ := event.(*store.Event)
+
+			response := eventToResponse(event)
+			bytes, _ := json.Marshal(response)
+
+			w.WriteHeader(http.StatusOK)
+			w.Write(bytes)
+			return nil
+
+		}
+
+	} else {
+		leader := r.Leader()
+		// current no leader
+		if leader == "" {
+			return etcdErr.NewError(300, "", store.UndefIndex, store.UndefTerm)
+		}
+		url, _ := toURL(leader)
+
+		redirect(url, w, req)
+
+		return nil
+	}
+}

server/v1/get_key_handler.go

@@ -0,0 +1,31 @@
+package v1
+
+import (
+	"encoding/json"
+	"github.com/coreos/etcd/store"
+	"net/http"
+)
+
+// Retrieves the value for a given key.
+func getKeyHandler(w http.ResponseWriter, req *http.Request, e *etcdServer) error {
+	vars := mux.Vars(req)
+	key := "/" + vars["key"]
+
+	debugf("[recv] GET %s/v1/keys/%s [%s]", e.url, key, req.RemoteAddr)
+
+	// Execute the command.
+	command := &GetCommand{Key: key}
+	event, err := command.Apply(e.raftServer.Server)
+	if err != nil {
+		return err
+	}
+
+	// Convert event to a response and write to client.
+	event, _ := event.(*store.Event)
+	response := eventToResponse(event)
+	b, _ := json.Marshal(response)
+	w.WriteHeader(http.StatusOK)
+	w.Write(b)
+
+	return nil
+}

server/v1/install.go

@@ -0,0 +1,15 @@
+package v1
+
+import (
+	"github.com/coreos/etcd/server"
+	"github.com/gorilla/mux"
+)
+
+// Installs the routes for version 1 of the API on to a server.
+func Install(s *server.Server) {
+	s.HandleFunc("/v1/keys/{key:.*}", getKeyHandler).Methods("GET")
+	s.HandleFunc("/v1/keys/{key:.*}", setKeyHandler).Methods("POST", "PUT")
+	s.HandleFunc("/v1/keys/{key:.*}", deleteKeyHandler).Methods("DELETE")
+
+	s.HandleFunc("/v1/watch/{key:.*}", watchKeyHandler).Methods("GET", "POST")
+}

server/v1/set_key_handler.go

@@ -0,0 +1,50 @@
+package v1
+
+import (
+	"encoding/json"
+	"github.com/coreos/etcd/store"
+	"net/http"
+)
+
+// Sets the value for a given key.
+func setKeyHandler(w http.ResponseWriter, req *http.Request, e *etcdServer) error {
+	vars := mux.Vars(req)
+	key := "/" + vars["key"]
+
+	debugf("[recv] POST %v/v1/keys/%s [%s]", e.url, key, req.RemoteAddr)
+
+	req.ParseForm()
+
+	// Parse non-blank value.
+	value := req.Form.Get("value")
+	if len(value) == 0 {
+		return error.NewError(200, "Set", store.UndefIndex, store.UndefTerm)
+	}
+
+	// Convert time-to-live to an expiration time.
+	expireTime, err := durationToExpireTime(req.Form.Get("ttl"))
+	if err != nil {
+		return etcdErr.NewError(202, "Set", store.UndefIndex, store.UndefTerm)
+	}
+
+	// If the "prevValue" is specified then test-and-set. Otherwise create a new key.
+	var c command.Command
+	if prevValueArr, ok := req.Form["prevValue"]; ok && len(prevValueArr) > 0 {
+		c = &TestAndSetCommand{
+			Key:        key,
+			Value:      value,
+			PrevValue:  prevValueArr[0],
+			ExpireTime: expireTime,
+		}
+
+	} else {
+		c = &CreateCommand{
+			Key:        key,
+			Value:      value,
+			ExpireTime: expireTime,
+			Force:      true,
+		}
+	}
+
+	return dispatchEtcdCommand(command, w, req)
+}

server/v1/util.go

@@ -0,0 +1,38 @@
+package v1
+
+// Converts an event object into a response object.
+func eventToResponse(event *store.Event) interface{} {
+	if !event.Dir {
+		response := &store.Response{
+			Action:     event.Action,
+			Key:        event.Key,
+			Value:      event.Value,
+			PrevValue:  event.PrevValue,
+			Index:      event.Index,
+			TTL:        event.TTL,
+			Expiration: event.Expiration,
+		}
+
+		if response.Action == store.Create || response.Action == store.Update {
+			response.Action = "set"
+			if response.PrevValue == "" {
+				response.NewKey = true
+			}
+		}
+
+		return response
+	} else {
+		responses := make([]*store.Response, len(event.KVPairs))
+
+		for i, kv := range event.KVPairs {
+			responses[i] = &store.Response{
+				Action: event.Action,
+				Key:    kv.Key,
+				Value:  kv.Value,
+				Dir:    kv.Dir,
+				Index:  event.Index,
+			}
+		}
+		return responses
+	}
+}

server/v1/watch_key_handler.go

@@ -0,0 +1,39 @@
+package v1
+
+import (
+	"encoding/json"
+	"github.com/coreos/etcd/store"
+	"net/http"
+)
+
+// Watches a given key prefix for changes.
+func watchKeyHandler(w http.ResponseWriter, req *http.Request, e *etcdServer) error {
+	vars := mux.Vars(req)
+	key := "/" + vars["key"]
+
+	debugf("[recv] %s %s/watch/%s [%s]", req.Method, e.url, key, req.RemoteAddr)
+
+	// Create a command to watch from a given index (default 0).
+	command := &WatchCommand{Key: key}
+	if req.Method == "POST" {
+		sinceIndex, err := strconv.ParseUint(string(req.FormValue("index")), 10, 64)
+		if err != nil {
+			return etcdErr.NewError(203, "Watch From Index", store.UndefIndex, store.UndefTerm)
+		}
+		command.SinceIndex = sinceIndex
+	}
+
+	// Apply the command and write the response.
+	event, err := command.Apply(e.raftServer.Server)
+	if err != nil {
+		return etcdErr.NewError(500, key, store.UndefIndex, store.UndefTerm)
+	}
+
+	event, _ := event.(*store.Event)
+	response := eventToResponse(event)
+	b, _ := json.Marshal(response)
+	w.WriteHeader(http.StatusOK)
+	w.Write(b)
+
+	return nil
+}