*: move "error" to "etcdserver/v2error"

Signed-off-by: Gyuho Lee <gyuhox@gmail.com>

etcdctl/ctlv3/command/migrate_command.go

@@ -25,11 +25,11 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/client"
-	etcdErr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/etcdserver/membership"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/etcdserver/v2store"
 	"github.com/coreos/etcd/mvcc"
 	"github.com/coreos/etcd/mvcc/backend"
@@ -241,7 +241,7 @@ func applyRequest(req *pb.Request, applyV2 etcdserver.ApplierV2) {
 func writeStore(w io.Writer, st v2store.Store) uint64 {
 	all, err := st.Get("/1", true, true)
 	if err != nil {
-		if eerr, ok := err.(*etcdErr.Error); ok && eerr.ErrorCode == etcdErr.EcodeKeyNotFound {
+		if eerr, ok := err.(*v2error.Error); ok && eerr.ErrorCode == v2error.EcodeKeyNotFound {
 			fmt.Println("no v2 keys to migrate")
 			os.Exit(0)
 		}

etcdserver/api/etcdhttp/base.go

@@ -21,10 +21,10 @@ import (
 	"net/http"
 	"strings"
 
-	etcdErr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api"
 	"github.com/coreos/etcd/etcdserver/api/v2http/httptypes"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/pkg/logutil"
 	"github.com/coreos/etcd/version"
 
@@ -138,7 +138,7 @@ func WriteError(w http.ResponseWriter, r *http.Request, err error) {
 		return
 	}
 	switch e := err.(type) {
-	case *etcdErr.Error:
+	case *v2error.Error:
 		e.WriteTo(w)
 	case *httptypes.HTTPError:
 		if et := e.WriteTo(w); et != nil {

etcdserver/api/v2http/client.go

@@ -27,7 +27,6 @@ import (
 	"strings"
 	"time"
 
-	etcdErr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api"
 	"github.com/coreos/etcd/etcdserver/api/etcdhttp"
@@ -36,6 +35,7 @@ import (
 	"github.com/coreos/etcd/etcdserver/membership"
 	"github.com/coreos/etcd/etcdserver/stats"
 	"github.com/coreos/etcd/etcdserver/v2auth"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/etcdserver/v2store"
 	"github.com/coreos/etcd/pkg/types"
 
@@ -322,15 +322,15 @@ func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Reque
 
 	err := r.ParseForm()
 	if err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidForm,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidForm,
 			err.Error(),
 		)
 	}
 
 	if !strings.HasPrefix(r.URL.Path, keysPrefix) {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidForm,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidForm,
 			"incorrect key prefix",
 		)
 	}
@@ -338,75 +338,75 @@ func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Reque
 
 	var pIdx, wIdx uint64
 	if pIdx, err = getUint64(r.Form, "prevIndex"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeIndexNaN,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeIndexNaN,
 			`invalid value for "prevIndex"`,
 		)
 	}
 	if wIdx, err = getUint64(r.Form, "waitIndex"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeIndexNaN,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeIndexNaN,
 			`invalid value for "waitIndex"`,
 		)
 	}
 
 	var rec, sort, wait, dir, quorum, stream bool
 	if rec, err = getBool(r.Form, "recursive"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`invalid value for "recursive"`,
 		)
 	}
 	if sort, err = getBool(r.Form, "sorted"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`invalid value for "sorted"`,
 		)
 	}
 	if wait, err = getBool(r.Form, "wait"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`invalid value for "wait"`,
 		)
 	}
 	// TODO(jonboulle): define what parameters dir is/isn't compatible with?
 	if dir, err = getBool(r.Form, "dir"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`invalid value for "dir"`,
 		)
 	}
 	if quorum, err = getBool(r.Form, "quorum"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`invalid value for "quorum"`,
 		)
 	}
 	if stream, err = getBool(r.Form, "stream"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`invalid value for "stream"`,
 		)
 	}
 
 	if wait && r.Method != "GET" {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`"wait" can only be used with GET requests`,
 		)
 	}
 
 	pV := r.FormValue("prevValue")
 	if _, ok := r.Form["prevValue"]; ok && pV == "" {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodePrevValueRequired,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodePrevValueRequired,
 			`"prevValue" cannot be empty`,
 		)
 	}
 
 	if noValueOnSuccess, err = getBool(r.Form, "noValueOnSuccess"); err != nil {
-		return emptyReq, false, etcdErr.NewRequestError(
-			etcdErr.EcodeInvalidField,
+		return emptyReq, false, v2error.NewRequestError(
+			v2error.EcodeInvalidField,
 			`invalid value for "noValueOnSuccess"`,
 		)
 	}
@@ -417,8 +417,8 @@ func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Reque
 	if len(r.FormValue("ttl")) > 0 {
 		i, err := getUint64(r.Form, "ttl")
 		if err != nil {
-			return emptyReq, false, etcdErr.NewRequestError(
-				etcdErr.EcodeTTLNaN,
+			return emptyReq, false, v2error.NewRequestError(
+				v2error.EcodeTTLNaN,
 				`invalid value for "ttl"`,
 			)
 		}
@@ -430,8 +430,8 @@ func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Reque
 	if _, ok := r.Form["prevExist"]; ok {
 		bv, err := getBool(r.Form, "prevExist")
 		if err != nil {
-			return emptyReq, false, etcdErr.NewRequestError(
-				etcdErr.EcodeInvalidField,
+			return emptyReq, false, v2error.NewRequestError(
+				v2error.EcodeInvalidField,
 				"invalid value for prevExist",
 			)
 		}
@@ -443,8 +443,8 @@ func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Reque
 	if _, ok := r.Form["refresh"]; ok {
 		bv, err := getBool(r.Form, "refresh")
 		if err != nil {
-			return emptyReq, false, etcdErr.NewRequestError(
-				etcdErr.EcodeInvalidField,
+			return emptyReq, false, v2error.NewRequestError(
+				v2error.EcodeInvalidField,
 				"invalid value for refresh",
 			)
 		}
@@ -452,14 +452,14 @@ func parseKeyRequest(r *http.Request, clock clockwork.Clock) (etcdserverpb.Reque
 		if refresh != nil && *refresh {
 			val := r.FormValue("value")
 			if _, ok := r.Form["value"]; ok && val != "" {
-				return emptyReq, false, etcdErr.NewRequestError(
-					etcdErr.EcodeRefreshValue,
+				return emptyReq, false, v2error.NewRequestError(
+					v2error.EcodeRefreshValue,
 					`A value was provided on a refresh`,
 				)
 			}
 			if ttl == nil {
-				return emptyReq, false, etcdErr.NewRequestError(
-					etcdErr.EcodeRefreshTTLRequired,
+				return emptyReq, false, v2error.NewRequestError(
+					v2error.EcodeRefreshTTLRequired,
 					`No TTL value set`,
 				)
 			}
@@ -527,7 +527,7 @@ func writeKeyEvent(w http.ResponseWriter, resp etcdserver.Response, noValueOnSuc
 }
 
 func writeKeyNoAuth(w http.ResponseWriter) {
-	e := etcdErr.NewError(etcdErr.EcodeUnauthorized, "Insufficient credentials", 0)
+	e := v2error.NewError(v2error.EcodeUnauthorized, "Insufficient credentials", 0)
 	e.WriteTo(w)
 }
 
@@ -538,7 +538,7 @@ func writeKeyError(w http.ResponseWriter, err error) {
 		return
 	}
 	switch e := err.(type) {
-	case *etcdErr.Error:
+	case *v2error.Error:
 		e.WriteTo(w)
 	default:
 		switch err {
@@ -547,7 +547,7 @@ func writeKeyError(w http.ResponseWriter, err error) {
 		default:
 			mlog.MergeErrorf("got unexpected response error (%v)", err)
 		}
-		ee := etcdErr.NewError(etcdErr.EcodeRaftInternal, err.Error(), 0)
+		ee := v2error.NewError(v2error.EcodeRaftInternal, err.Error(), 0)
 		ee.WriteTo(w)
 	}
 }
@@ -622,7 +622,7 @@ func trimNodeExternPrefix(n *v2store.NodeExtern, prefix string) {
 }
 
 func trimErrorPrefix(err error, prefix string) error {
-	if e, ok := err.(*etcdErr.Error); ok {
+	if e, ok := err.(*v2error.Error); ok {
 		e.Cause = strings.TrimPrefix(e.Cause, prefix)
 	}
 	return err

etcdserver/api/v2http/client_test.go

@@ -29,12 +29,12 @@ import (
 	"testing"
 	"time"
 
-	etcdErr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api"
 	"github.com/coreos/etcd/etcdserver/api/v2http/httptypes"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/etcdserver/membership"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/etcdserver/v2store"
 	"github.com/coreos/etcd/pkg/testutil"
 	"github.com/coreos/etcd/pkg/types"
@@ -193,19 +193,19 @@ func TestBadRefreshRequest(t *testing.T) {
 	}{
 		{
 			mustNewRequest(t, "foo?refresh=true&value=test"),
-			etcdErr.EcodeRefreshValue,
+			v2error.EcodeRefreshValue,
 		},
 		{
 			mustNewRequest(t, "foo?refresh=true&value=10"),
-			etcdErr.EcodeRefreshValue,
+			v2error.EcodeRefreshValue,
 		},
 		{
 			mustNewRequest(t, "foo?refresh=true"),
-			etcdErr.EcodeRefreshTTLRequired,
+			v2error.EcodeRefreshTTLRequired,
 		},
 		{
 			mustNewRequest(t, "foo?refresh=true&ttl="),
-			etcdErr.EcodeRefreshTTLRequired,
+			v2error.EcodeRefreshTTLRequired,
 		},
 	}
 	for i, tt := range tests {
@@ -214,7 +214,7 @@ func TestBadRefreshRequest(t *testing.T) {
 			t.Errorf("#%d: unexpected nil error!", i)
 			continue
 		}
-		ee, ok := err.(*etcdErr.Error)
+		ee, ok := err.(*v2error.Error)
 		if !ok {
 			t.Errorf("#%d: err is not etcd.Error!", i)
 			continue
@@ -240,119 +240,119 @@ func TestBadParseRequest(t *testing.T) {
 				Body:   nil,
 				Method: "PUT",
 			},
-			etcdErr.EcodeInvalidForm,
+			v2error.EcodeInvalidForm,
 		},
 		{
 			// bad key prefix
 			&http.Request{
 				URL: testutil.MustNewURL(t, "/badprefix/"),
 			},
-			etcdErr.EcodeInvalidForm,
+			v2error.EcodeInvalidForm,
 		},
 		// bad values for prevIndex, waitIndex, ttl
 		{
 			mustNewForm(t, "foo", url.Values{"prevIndex": []string{"garbage"}}),
-			etcdErr.EcodeIndexNaN,
+			v2error.EcodeIndexNaN,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"prevIndex": []string{"1.5"}}),
-			etcdErr.EcodeIndexNaN,
+			v2error.EcodeIndexNaN,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"prevIndex": []string{"-1"}}),
-			etcdErr.EcodeIndexNaN,
+			v2error.EcodeIndexNaN,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"waitIndex": []string{"garbage"}}),
-			etcdErr.EcodeIndexNaN,
+			v2error.EcodeIndexNaN,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"waitIndex": []string{"??"}}),
-			etcdErr.EcodeIndexNaN,
+			v2error.EcodeIndexNaN,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"ttl": []string{"-1"}}),
-			etcdErr.EcodeTTLNaN,
+			v2error.EcodeTTLNaN,
 		},
 		// bad values for recursive, sorted, wait, prevExist, dir, stream
 		{
 			mustNewForm(t, "foo", url.Values{"recursive": []string{"hahaha"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"recursive": []string{"1234"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"recursive": []string{"?"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"sorted": []string{"?"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"sorted": []string{"x"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"wait": []string{"?!"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"wait": []string{"yes"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"prevExist": []string{"yes"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"prevExist": []string{"#2"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"dir": []string{"no"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"dir": []string{"file"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"quorum": []string{"no"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"quorum": []string{"file"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"stream": []string{"zzz"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewForm(t, "foo", url.Values{"stream": []string{"something"}}),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		// prevValue cannot be empty
 		{
 			mustNewForm(t, "foo", url.Values{"prevValue": []string{""}}),
-			etcdErr.EcodePrevValueRequired,
+			v2error.EcodePrevValueRequired,
 		},
 		// wait is only valid with GET requests
 		{
 			mustNewMethodRequest(t, "HEAD", "foo?wait=true"),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		// query values are considered
 		{
 			mustNewRequest(t, "foo?prevExist=wrong"),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 		{
 			mustNewRequest(t, "foo?ttl=wrong"),
-			etcdErr.EcodeTTLNaN,
+			v2error.EcodeTTLNaN,
 		},
 		// but body takes precedence if both are specified
 		{
@@ -361,7 +361,7 @@ func TestBadParseRequest(t *testing.T) {
 				"foo?ttl=12",
 				url.Values{"ttl": []string{"garbage"}},
 			),
-			etcdErr.EcodeTTLNaN,
+			v2error.EcodeTTLNaN,
 		},
 		{
 			mustNewForm(
@@ -369,7 +369,7 @@ func TestBadParseRequest(t *testing.T) {
 				"foo?prevExist=false",
 				url.Values{"prevExist": []string{"yes"}},
 			),
-			etcdErr.EcodeInvalidField,
+			v2error.EcodeInvalidField,
 		},
 	}
 	for i, tt := range tests {
@@ -378,7 +378,7 @@ func TestBadParseRequest(t *testing.T) {
 			t.Errorf("#%d: unexpected nil error!", i)
 			continue
 		}
-		ee, ok := err.(*etcdErr.Error)
+		ee, ok := err.(*v2error.Error)
 		if !ok {
 			t.Errorf("#%d: err is not etcd.Error!", i)
 			continue
@@ -1470,7 +1470,7 @@ func TestBadServeKeys(t *testing.T) {
 			// etcdserver.Server etcd error
 			mustNewRequest(t, "foo"),
 			&errServer{
-				err: etcdErr.NewError(etcdErr.EcodeKeyNotFound, "/1/pant", 0),
+				err: v2error.NewError(v2error.EcodeKeyNotFound, "/1/pant", 0),
 			},
 
 			http.StatusNotFound,

etcdserver/api/v2http/http_test.go

@@ -22,10 +22,10 @@ import (
 	"sort"
 	"testing"
 
-	etcdErr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/etcdserver/membership"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/etcd/raft/raftpb"
 
@@ -94,12 +94,12 @@ func TestWriteError(t *testing.T) {
 		wi    string
 	}{
 		{
-			etcdErr.NewError(etcdErr.EcodeKeyNotFound, "/foo/bar", 123),
+			v2error.NewError(v2error.EcodeKeyNotFound, "/foo/bar", 123),
 			http.StatusNotFound,
 			"123",
 		},
 		{
-			etcdErr.NewError(etcdErr.EcodeTestFailed, "/foo/bar", 456),
+			v2error.NewError(v2error.EcodeTestFailed, "/foo/bar", 456),
 			http.StatusPreconditionFailed,
 			"456",
 		},

etcdserver/api/v2http/metrics.go

@@ -20,10 +20,10 @@ import (
 
 	"net/http"
 
-	etcdErr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v2http/httptypes"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
@@ -86,8 +86,8 @@ func codeFromError(err error) int {
 		return http.StatusInternalServerError
 	}
 	switch e := err.(type) {
-	case *etcdErr.Error:
-		return (*etcdErr.Error)(e).StatusCode()
+	case *v2error.Error:
+		return (*v2error.Error)(e).StatusCode()
 	case *httptypes.HTTPError:
 		return (*httptypes.HTTPError)(e).Code
 	default:

etcdserver/api/v2v3/store.go

@@ -23,7 +23,7 @@ import (
 
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/clientv3/concurrency"
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/etcdserver/v2store"
 	"github.com/coreos/etcd/mvcc/mvccpb"
 )
@@ -81,7 +81,7 @@ func (s *v2v3Store) Get(nodePath string, recursive, sorted bool) (*v2store.Event
 
 	kvs := resp.Responses[1].GetResponseRange().Kvs
 	if len(kvs) == 0 {
-		return nil, etcdErr.NewError(etcdErr.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(v2error.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 
 	return &v2store.Event{
@@ -138,14 +138,14 @@ func (s *v2v3Store) Set(
 	}
 
 	if isRoot(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, nodePath, 0)
 	}
 
 	ecode := 0
 	applyf := func(stm concurrency.STM) error {
 		parent := path.Dir(nodePath)
 		if !isRoot(parent) && stm.Rev(s.mkPath(parent)+"/") == 0 {
-			ecode = etcdErr.EcodeKeyNotFound
+			ecode = v2error.EcodeKeyNotFound
 			return nil
 		}
 
@@ -153,12 +153,12 @@ func (s *v2v3Store) Set(
 		if dir {
 			if stm.Rev(key) != 0 {
 				// exists as non-dir
-				ecode = etcdErr.EcodeNotDir
+				ecode = v2error.EcodeNotDir
 				return nil
 			}
 			key = key + "/"
 		} else if stm.Rev(key+"/") != 0 {
-			ecode = etcdErr.EcodeNotFile
+			ecode = v2error.EcodeNotFile
 			return nil
 		}
 		stm.Put(key, value, clientv3.WithPrevKV())
@@ -171,7 +171,7 @@ func (s *v2v3Store) Set(
 		return nil, err
 	}
 	if ecode != 0 {
-		return nil, etcdErr.NewError(ecode, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(ecode, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 
 	createRev := resp.Header.Revision
@@ -201,7 +201,7 @@ func (s *v2v3Store) Set(
 
 func (s *v2v3Store) Update(nodePath, newValue string, expireOpts v2store.TTLOptionSet) (*v2store.Event, error) {
 	if isRoot(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, nodePath, 0)
 	}
 
 	if expireOpts.Refresh || !expireOpts.ExpireTime.IsZero() {
@@ -212,11 +212,11 @@ func (s *v2v3Store) Update(nodePath, newValue string, expireOpts v2store.TTLOpti
 	ecode := 0
 	applyf := func(stm concurrency.STM) error {
 		if rev := stm.Rev(key + "/"); rev != 0 {
-			ecode = etcdErr.EcodeNotFile
+			ecode = v2error.EcodeNotFile
 			return nil
 		}
 		if rev := stm.Rev(key); rev == 0 {
-			ecode = etcdErr.EcodeKeyNotFound
+			ecode = v2error.EcodeKeyNotFound
 			return nil
 		}
 		stm.Put(key, newValue, clientv3.WithPrevKV())
@@ -229,7 +229,7 @@ func (s *v2v3Store) Update(nodePath, newValue string, expireOpts v2store.TTLOpti
 		return nil, err
 	}
 	if ecode != 0 {
-		return nil, etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(v2error.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 
 	pkv := prevKeyFromPuts(resp)
@@ -254,7 +254,7 @@ func (s *v2v3Store) Create(
 	expireOpts v2store.TTLOptionSet,
 ) (*v2store.Event, error) {
 	if isRoot(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, nodePath, 0)
 	}
 	if expireOpts.Refresh || !expireOpts.ExpireTime.IsZero() {
 		return nil, errUnsupported
@@ -275,7 +275,7 @@ func (s *v2v3Store) Create(
 			}
 		}
 		if stm.Rev(key) > 0 || stm.Rev(key+"/") > 0 {
-			ecode = etcdErr.EcodeNodeExist
+			ecode = v2error.EcodeNodeExist
 			return nil
 		}
 		// build path if any directories in path do not exist
@@ -283,7 +283,7 @@ func (s *v2v3Store) Create(
 		for p := path.Dir(nodePath); !isRoot(p); p = path.Dir(p) {
 			pp := s.mkPath(p)
 			if stm.Rev(pp) > 0 {
-				ecode = etcdErr.EcodeNotDir
+				ecode = v2error.EcodeNotDir
 				return nil
 			}
 			if stm.Rev(pp+"/") == 0 {
@@ -308,7 +308,7 @@ func (s *v2v3Store) Create(
 		return nil, err
 	}
 	if ecode != 0 {
-		return nil, etcdErr.NewError(ecode, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(ecode, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 
 	var v *string
@@ -337,7 +337,7 @@ func (s *v2v3Store) CompareAndSwap(
 	expireOpts v2store.TTLOptionSet,
 ) (*v2store.Event, error) {
 	if isRoot(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, nodePath, 0)
 	}
 	if expireOpts.Refresh || !expireOpts.ExpireTime.IsZero() {
 		return nil, errUnsupported
@@ -377,7 +377,7 @@ func (s *v2v3Store) CompareAndSwap(
 
 func (s *v2v3Store) Delete(nodePath string, dir, recursive bool) (*v2store.Event, error) {
 	if isRoot(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, nodePath, 0)
 	}
 	if !dir && !recursive {
 		return s.deleteNode(nodePath)
@@ -403,7 +403,7 @@ func (s *v2v3Store) Delete(nodePath string, dir, recursive bool) (*v2store.Event
 		return nil, err
 	}
 	if !resp.Succeeded {
-		return nil, etcdErr.NewError(etcdErr.EcodeNodeExist, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(v2error.EcodeNodeExist, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 	dresp := resp.Responses[0].GetResponseDeleteRange()
 	return &v2store.Event{
@@ -424,11 +424,11 @@ func (s *v2v3Store) deleteEmptyDir(nodePath string) (*v2store.Event, error) {
 		return nil, err
 	}
 	if !resp.Succeeded {
-		return nil, etcdErr.NewError(etcdErr.EcodeDirNotEmpty, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(v2error.EcodeDirNotEmpty, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 	dresp := resp.Responses[0].GetResponseDeleteRange()
 	if len(dresp.PrevKvs) == 0 {
-		return nil, etcdErr.NewError(etcdErr.EcodeNodeExist, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(v2error.EcodeNodeExist, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 	return &v2store.Event{
 		Action:    v2store.Delete,
@@ -448,11 +448,11 @@ func (s *v2v3Store) deleteNode(nodePath string) (*v2store.Event, error) {
 		return nil, err
 	}
 	if !resp.Succeeded {
-		return nil, etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(v2error.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 	pkvs := resp.Responses[0].GetResponseDeleteRange().PrevKvs
 	if len(pkvs) == 0 {
-		return nil, etcdErr.NewError(etcdErr.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
+		return nil, v2error.NewError(v2error.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 	pkv := pkvs[0]
 	return &v2store.Event{
@@ -469,7 +469,7 @@ func (s *v2v3Store) deleteNode(nodePath string) (*v2store.Event, error) {
 
 func (s *v2v3Store) CompareAndDelete(nodePath, prevValue string, prevIndex uint64) (*v2store.Event, error) {
 	if isRoot(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, nodePath, 0)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, nodePath, 0)
 	}
 
 	key := s.mkPath(nodePath)
@@ -506,11 +506,11 @@ func (s *v2v3Store) CompareAndDelete(nodePath, prevValue string, prevIndex uint6
 
 func compareFail(nodePath, prevValue string, prevIndex uint64, resp *clientv3.TxnResponse) error {
 	if dkvs := resp.Responses[1].GetResponseRange().Kvs; len(dkvs) > 0 {
-		return etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
+		return v2error.NewError(v2error.EcodeNotFile, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 	kvs := resp.Responses[0].GetResponseRange().Kvs
 	if len(kvs) == 0 {
-		return etcdErr.NewError(etcdErr.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
+		return v2error.NewError(v2error.EcodeKeyNotFound, nodePath, mkV2Rev(resp.Header.Revision))
 	}
 	kv := kvs[0]
 	indexMatch := (prevIndex == 0 || kv.ModRevision == int64(prevIndex))
@@ -524,7 +524,7 @@ func compareFail(nodePath, prevValue string, prevIndex uint64, resp *clientv3.Tx
 	default:
 		cause = fmt.Sprintf("[%v != %v] [%v != %v]", prevValue, string(kv.Value), prevIndex, kv.ModRevision)
 	}
-	return etcdErr.NewError(etcdErr.EcodeTestFailed, cause, mkV2Rev(resp.Header.Revision))
+	return v2error.NewError(v2error.EcodeTestFailed, cause, mkV2Rev(resp.Header.Revision))
 }
 
 func (s *v2v3Store) mkCompare(nodePath, prevValue string, prevIndex uint64) []clientv3.Cmp {

etcdserver/api/v2v3/watcher.go

@@ -19,7 +19,7 @@ import (
 	"strings"
 
 	"github.com/coreos/etcd/clientv3"
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/etcdserver/v2store"
 )
 
@@ -36,7 +36,7 @@ func (s *v2v3Store) Watch(prefix string, recursive, stream bool, sinceIndex uint
 	resp, ok := <-wch
 	if err := resp.Err(); err != nil || !ok {
 		cancel()
-		return nil, etcdErr.NewError(etcdErr.EcodeRaftInternal, prefix, 0)
+		return nil, v2error.NewError(v2error.EcodeRaftInternal, prefix, 0)
 	}
 
 	evc, donec := make(chan *v2store.Event), make(chan struct{})

etcdserver/membership/errors.go

@@ -17,7 +17,7 @@ package membership
 import (
 	"errors"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 )
 
 var (
@@ -28,6 +28,6 @@ var (
 )
 
 func isKeyNotFound(err error) bool {
-	e, ok := err.(*etcdErr.Error)
-	return ok && e.ErrorCode == etcdErr.EcodeKeyNotFound
+	e, ok := err.(*v2error.Error)
+	return ok && e.ErrorCode == v2error.EcodeKeyNotFound
 }

etcdserver/v2auth/auth.go

@@ -26,9 +26,9 @@ import (
 	"strings"
 	"time"
 
-	etcderr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/pkg/capnslog"
 
@@ -170,8 +170,8 @@ func (_ passwordStore) HashPassword(password string) (string, error) {
 func (s *store) AllUsers() ([]string, error) {
 	resp, err := s.requestResource("/users/", false, false)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return []string{}, nil
 			}
 		}
@@ -225,8 +225,8 @@ func (s *store) createUserInternal(user User) (User, error) {
 
 	_, err = s.createResource("/users/"+user.User, user)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeNodeExist {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeNodeExist {
 				return user, authErr(http.StatusConflict, "User %s already exists.", user.User)
 			}
 		}
@@ -240,8 +240,8 @@ func (s *store) DeleteUser(name string) error {
 	}
 	_, err := s.deleteResource("/users/" + name)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return authErr(http.StatusNotFound, "User %s does not exist", name)
 			}
 		}
@@ -254,8 +254,8 @@ func (s *store) DeleteUser(name string) error {
 func (s *store) UpdateUser(user User) (User, error) {
 	old, err := s.getUser(user.User, true)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return user, authErr(http.StatusNotFound, "User %s doesn't exist.", user.User)
 			}
 		}
@@ -280,8 +280,8 @@ func (s *store) AllRoles() ([]string, error) {
 	nodes := []string{RootRoleName}
 	resp, err := s.requestResource("/roles/", false, false)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return nodes, nil
 			}
 		}
@@ -303,8 +303,8 @@ func (s *store) CreateRole(role Role) error {
 	}
 	_, err := s.createResource("/roles/"+role.Role, role)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeNodeExist {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeNodeExist {
 				return authErr(http.StatusConflict, "Role %s already exists.", role.Role)
 			}
 		}
@@ -321,8 +321,8 @@ func (s *store) DeleteRole(name string) error {
 	}
 	_, err := s.deleteResource("/roles/" + name)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return authErr(http.StatusNotFound, "Role %s doesn't exist.", name)
 			}
 		}
@@ -339,8 +339,8 @@ func (s *store) UpdateRole(role Role) (Role, error) {
 	}
 	old, err := s.getRole(role.Role, true)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return role, authErr(http.StatusNotFound, "Role %s doesn't exist.", role.Role)
 			}
 		}
@@ -610,8 +610,8 @@ func attachRootRole(u User) User {
 func (s *store) getUser(name string, quorum bool) (User, error) {
 	resp, err := s.requestResource("/users/"+name, false, quorum)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return User{}, authErr(http.StatusNotFound, "User %s does not exist.", name)
 			}
 		}
@@ -635,8 +635,8 @@ func (s *store) getRole(name string, quorum bool) (Role, error) {
 	}
 	resp, err := s.requestResource("/roles/"+name, false, quorum)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return Role{}, authErr(http.StatusNotFound, "Role %s does not exist.", name)
 			}
 		}

etcdserver/v2auth/auth_requests.go

@@ -19,9 +19,9 @@ import (
 	"encoding/json"
 	"path"
 
-	etcderr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/etcdserver/v2error"
 )
 
 func (s *store) ensureAuthDirectories() error {
@@ -40,8 +40,8 @@ func (s *store) ensureAuthDirectories() error {
 		}
 		_, err := s.server.Do(ctx, rr)
 		if err != nil {
-			if e, ok := err.(*etcderr.Error); ok {
-				if e.ErrorCode == etcderr.EcodeNodeExist {
+			if e, ok := err.(*v2error.Error); ok {
+				if e.ErrorCode == v2error.EcodeNodeExist {
 					continue
 				}
 			}
@@ -60,8 +60,8 @@ func (s *store) ensureAuthDirectories() error {
 	}
 	_, err := s.server.Do(ctx, rr)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeNodeExist {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeNodeExist {
 				s.ensuredOnce = true
 				return nil
 			}
@@ -87,8 +87,8 @@ func (s *store) detectAuth() bool {
 	}
 	value, err := s.requestResource("/enabled", false, false)
 	if err != nil {
-		if e, ok := err.(*etcderr.Error); ok {
-			if e.ErrorCode == etcderr.EcodeKeyNotFound {
+		if e, ok := err.(*v2error.Error); ok {
+			if e.ErrorCode == v2error.EcodeKeyNotFound {
 				return false
 			}
 		}

etcdserver/v2auth/auth_test.go

@@ -20,9 +20,9 @@ import (
 	"testing"
 	"time"
 
-	etcderr "github.com/coreos/etcd/error"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/etcdserver/v2store"
 )
 
@@ -177,8 +177,8 @@ func (td *testDoer) Do(_ context.Context, req etcdserverpb.Request) (etcdserver.
 		res := td.get[td.getindex]
 		if res.Event == nil {
 			td.getindex++
-			return etcdserver.Response{}, &etcderr.Error{
-				ErrorCode: etcderr.EcodeKeyNotFound,
+			return etcdserver.Response{}, &v2error.Error{
+				ErrorCode: v2error.EcodeKeyNotFound,
 			}
 		}
 		td.getindex++
@@ -188,8 +188,8 @@ func (td *testDoer) Do(_ context.Context, req etcdserverpb.Request) (etcdserver.
 		res := td.put[td.putindex]
 		if res.Event == nil {
 			td.putindex++
-			return etcdserver.Response{}, &etcderr.Error{
-				ErrorCode: etcderr.EcodeNodeExist,
+			return etcdserver.Response{}, &v2error.Error{
+				ErrorCode: v2error.EcodeNodeExist,
 			}
 		}
 		td.putindex++

error/error.go → etcdserver/v2error/error.go

@@ -12,9 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package error describes errors in etcd project. When any change happens,
+// Package v2error describes errors in etcd project. When any change happens,
 // Documentation/v2/errorcode.md needs to be updated correspondingly.
-package error
+// To be deprecated in favor of v3 APIs.
+package v2error
 
 import (
 	"encoding/json"

error/error_test.go → etcdserver/v2error/error_test.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package error
+package v2error
 
 import (
 	"net/http"

etcdserver/v2store/event_history.go

@@ -20,7 +20,7 @@ import (
 	"strings"
 	"sync"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 )
 
 type EventHistory struct {
@@ -55,14 +55,14 @@ func (eh *EventHistory) addEvent(e *Event) *Event {
 
 // scan enumerates events from the index history and stops at the first point
 // where the key matches.
-func (eh *EventHistory) scan(key string, recursive bool, index uint64) (*Event, *etcdErr.Error) {
+func (eh *EventHistory) scan(key string, recursive bool, index uint64) (*Event, *v2error.Error) {
 	eh.rwl.RLock()
 	defer eh.rwl.RUnlock()
 
 	// index should be after the event history's StartIndex
 	if index < eh.StartIndex {
 		return nil,
-			etcdErr.NewError(etcdErr.EcodeEventIndexCleared,
+			v2error.NewError(v2error.EcodeEventIndexCleared,
 				fmt.Sprintf("the requested history has been cleared [%v/%v]",
 					eh.StartIndex, index), 0)
 	}

etcdserver/v2store/event_test.go

@@ -17,7 +17,7 @@ package v2store
 import (
 	"testing"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 )
 
 // TestEventQueue tests a queue with capacity = 100
@@ -105,8 +105,8 @@ func TestEventIndexHistoryCleared(t *testing.T) {
 
 	// test for the event which has been replaced.
 	_, err := eh.scan("/foo", false, 1)
-	if err == nil || err.ErrorCode != etcdErr.EcodeEventIndexCleared {
-		t.Fatalf("scan error cleared index should return err with %d got (%v)", etcdErr.EcodeEventIndexCleared, err)
+	if err == nil || err.ErrorCode != v2error.EcodeEventIndexCleared {
+		t.Fatalf("scan error cleared index should return err with %d got (%v)", v2error.EcodeEventIndexCleared, err)
 	}
 }
 

etcdserver/v2store/node.go

@@ -19,7 +19,7 @@ import (
 	"sort"
 	"time"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 
 	"github.com/jonboulle/clockwork"
 )
@@ -107,9 +107,9 @@ func (n *node) IsDir() bool {
 
 // Read function gets the value of the node.
 // If the receiver node is not a key-value pair, a "Not A File" error will be returned.
-func (n *node) Read() (string, *etcdErr.Error) {
+func (n *node) Read() (string, *v2error.Error) {
 	if n.IsDir() {
-		return "", etcdErr.NewError(etcdErr.EcodeNotFile, "", n.store.CurrentIndex)
+		return "", v2error.NewError(v2error.EcodeNotFile, "", n.store.CurrentIndex)
 	}
 
 	return n.Value, nil
@@ -117,9 +117,9 @@ func (n *node) Read() (string, *etcdErr.Error) {
 
 // Write function set the value of the node to the given value.
 // If the receiver node is a directory, a "Not A File" error will be returned.
-func (n *node) Write(value string, index uint64) *etcdErr.Error {
+func (n *node) Write(value string, index uint64) *v2error.Error {
 	if n.IsDir() {
-		return etcdErr.NewError(etcdErr.EcodeNotFile, "", n.store.CurrentIndex)
+		return v2error.NewError(v2error.EcodeNotFile, "", n.store.CurrentIndex)
 	}
 
 	n.Value = value
@@ -150,9 +150,9 @@ func (n *node) expirationAndTTL(clock clockwork.Clock) (*time.Time, int64) {
 
 // List function return a slice of nodes under the receiver node.
 // If the receiver node is not a directory, a "Not A Directory" error will be returned.
-func (n *node) List() ([]*node, *etcdErr.Error) {
+func (n *node) List() ([]*node, *v2error.Error) {
 	if !n.IsDir() {
-		return nil, etcdErr.NewError(etcdErr.EcodeNotDir, "", n.store.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeNotDir, "", n.store.CurrentIndex)
 	}
 
 	nodes := make([]*node, len(n.Children))
@@ -168,9 +168,9 @@ func (n *node) List() ([]*node, *etcdErr.Error) {
 
 // GetChild function returns the child node under the directory node.
 // On success, it returns the file node
-func (n *node) GetChild(name string) (*node, *etcdErr.Error) {
+func (n *node) GetChild(name string) (*node, *v2error.Error) {
 	if !n.IsDir() {
-		return nil, etcdErr.NewError(etcdErr.EcodeNotDir, n.Path, n.store.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeNotDir, n.Path, n.store.CurrentIndex)
 	}
 
 	child, ok := n.Children[name]
@@ -186,15 +186,15 @@ func (n *node) GetChild(name string) (*node, *etcdErr.Error) {
 // If the receiver is not a directory, a "Not A Directory" error will be returned.
 // If there is an existing node with the same name under the directory, a "Already Exist"
 // error will be returned
-func (n *node) Add(child *node) *etcdErr.Error {
+func (n *node) Add(child *node) *v2error.Error {
 	if !n.IsDir() {
-		return etcdErr.NewError(etcdErr.EcodeNotDir, "", n.store.CurrentIndex)
+		return v2error.NewError(v2error.EcodeNotDir, "", n.store.CurrentIndex)
 	}
 
 	_, name := path.Split(child.Path)
 
 	if _, ok := n.Children[name]; ok {
-		return etcdErr.NewError(etcdErr.EcodeNodeExist, "", n.store.CurrentIndex)
+		return v2error.NewError(v2error.EcodeNodeExist, "", n.store.CurrentIndex)
 	}
 
 	n.Children[name] = child
@@ -203,7 +203,7 @@ func (n *node) Add(child *node) *etcdErr.Error {
 }
 
 // Remove function remove the node.
-func (n *node) Remove(dir, recursive bool, callback func(path string)) *etcdErr.Error {
+func (n *node) Remove(dir, recursive bool, callback func(path string)) *v2error.Error {
 	if !n.IsDir() { // key-value pair
 		_, name := path.Split(n.Path)
 
@@ -225,13 +225,13 @@ func (n *node) Remove(dir, recursive bool, callback func(path string)) *etcdErr.
 
 	if !dir {
 		// cannot delete a directory without dir set to true
-		return etcdErr.NewError(etcdErr.EcodeNotFile, n.Path, n.store.CurrentIndex)
+		return v2error.NewError(v2error.EcodeNotFile, n.Path, n.store.CurrentIndex)
 	}
 
 	if len(n.Children) != 0 && !recursive {
 		// cannot delete a directory if it is not empty and the operation
 		// is not recursive
-		return etcdErr.NewError(etcdErr.EcodeDirNotEmpty, n.Path, n.store.CurrentIndex)
+		return v2error.NewError(v2error.EcodeDirNotEmpty, n.Path, n.store.CurrentIndex)
 	}
 
 	for _, child := range n.Children { // delete all children

etcdserver/v2store/store.go

@@ -23,7 +23,7 @@ import (
 	"sync"
 	"time"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/pkg/types"
 
 	"github.com/jonboulle/clockwork"
@@ -120,7 +120,7 @@ func (s *store) Index() uint64 {
 // If recursive is true, it will return all the content under the node path.
 // If sorted is true, it will sort the content by keys.
 func (s *store) Get(nodePath string, recursive, sorted bool) (*Event, error) {
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	s.worldLock.RLock()
 	defer s.worldLock.RUnlock()
@@ -160,7 +160,7 @@ func (s *store) Get(nodePath string, recursive, sorted bool) (*Event, error) {
 // If the node has already existed, create will fail.
 // If any node on the path is a file, create will fail.
 func (s *store) Create(nodePath string, dir bool, value string, unique bool, expireOpts TTLOptionSet) (*Event, error) {
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	s.worldLock.Lock()
 	defer s.worldLock.Unlock()
@@ -189,7 +189,7 @@ func (s *store) Create(nodePath string, dir bool, value string, unique bool, exp
 
 // Set creates or replace the node at nodePath.
 func (s *store) Set(nodePath string, dir bool, value string, expireOpts TTLOptionSet) (*Event, error) {
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	s.worldLock.Lock()
 	defer s.worldLock.Unlock()
@@ -207,7 +207,7 @@ func (s *store) Set(nodePath string, dir bool, value string, expireOpts TTLOptio
 
 	// Get prevNode value
 	n, getErr := s.internalGet(nodePath)
-	if getErr != nil && getErr.ErrorCode != etcdErr.EcodeKeyNotFound {
+	if getErr != nil && getErr.ErrorCode != v2error.EcodeKeyNotFound {
 		err = getErr
 		return nil, err
 	}
@@ -260,7 +260,7 @@ func getCompareFailCause(n *node, which int, prevValue string, prevIndex uint64)
 func (s *store) CompareAndSwap(nodePath string, prevValue string, prevIndex uint64,
 	value string, expireOpts TTLOptionSet) (*Event, error) {
 
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	s.worldLock.Lock()
 	defer s.worldLock.Unlock()
@@ -279,7 +279,7 @@ func (s *store) CompareAndSwap(nodePath string, prevValue string, prevIndex uint
 	nodePath = path.Clean(path.Join("/", nodePath))
 	// we do not allow the user to change "/"
 	if s.readonlySet.Contains(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, "/", s.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, "/", s.CurrentIndex)
 	}
 
 	n, err := s.internalGet(nodePath)
@@ -287,7 +287,7 @@ func (s *store) CompareAndSwap(nodePath string, prevValue string, prevIndex uint
 		return nil, err
 	}
 	if n.IsDir() { // can only compare and swap file
-		err = etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, s.CurrentIndex)
+		err = v2error.NewError(v2error.EcodeNotFile, nodePath, s.CurrentIndex)
 		return nil, err
 	}
 
@@ -295,7 +295,7 @@ func (s *store) CompareAndSwap(nodePath string, prevValue string, prevIndex uint
 	// Command will be executed, only if both of the tests are successful.
 	if ok, which := n.Compare(prevValue, prevIndex); !ok {
 		cause := getCompareFailCause(n, which, prevValue, prevIndex)
-		err = etcdErr.NewError(etcdErr.EcodeTestFailed, cause, s.CurrentIndex)
+		err = v2error.NewError(v2error.EcodeTestFailed, cause, s.CurrentIndex)
 		return nil, err
 	}
 
@@ -333,7 +333,7 @@ func (s *store) CompareAndSwap(nodePath string, prevValue string, prevIndex uint
 // Delete deletes the node at the given path.
 // If the node is a directory, recursive must be true to delete it.
 func (s *store) Delete(nodePath string, dir, recursive bool) (*Event, error) {
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	s.worldLock.Lock()
 	defer s.worldLock.Unlock()
@@ -352,7 +352,7 @@ func (s *store) Delete(nodePath string, dir, recursive bool) (*Event, error) {
 	nodePath = path.Clean(path.Join("/", nodePath))
 	// we do not allow the user to change "/"
 	if s.readonlySet.Contains(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, "/", s.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, "/", s.CurrentIndex)
 	}
 
 	// recursive implies dir
@@ -394,7 +394,7 @@ func (s *store) Delete(nodePath string, dir, recursive bool) (*Event, error) {
 }
 
 func (s *store) CompareAndDelete(nodePath string, prevValue string, prevIndex uint64) (*Event, error) {
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	s.worldLock.Lock()
 	defer s.worldLock.Unlock()
@@ -417,14 +417,14 @@ func (s *store) CompareAndDelete(nodePath string, prevValue string, prevIndex ui
 		return nil, err
 	}
 	if n.IsDir() { // can only compare and delete file
-		return nil, etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, s.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeNotFile, nodePath, s.CurrentIndex)
 	}
 
 	// If both of the prevValue and prevIndex are given, we will test both of them.
 	// Command will be executed, only if both of the tests are successful.
 	if ok, which := n.Compare(prevValue, prevIndex); !ok {
 		cause := getCompareFailCause(n, which, prevValue, prevIndex)
-		return nil, etcdErr.NewError(etcdErr.EcodeTestFailed, cause, s.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeTestFailed, cause, s.CurrentIndex)
 	}
 
 	// update etcd index
@@ -467,11 +467,11 @@ func (s *store) Watch(key string, recursive, stream bool, sinceIndex uint64) (Wa
 }
 
 // walk walks all the nodePath and apply the walkFunc on each directory
-func (s *store) walk(nodePath string, walkFunc func(prev *node, component string) (*node, *etcdErr.Error)) (*node, *etcdErr.Error) {
+func (s *store) walk(nodePath string, walkFunc func(prev *node, component string) (*node, *v2error.Error)) (*node, *v2error.Error) {
 	components := strings.Split(nodePath, "/")
 
 	curr := s.Root
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	for i := 1; i < len(components); i++ {
 		if len(components[i]) == 0 { // ignore empty string
@@ -491,7 +491,7 @@ func (s *store) walk(nodePath string, walkFunc func(prev *node, component string
 // If the node is a file, the value and the ttl can be updated.
 // If the node is a directory, only the ttl can be updated.
 func (s *store) Update(nodePath string, newValue string, expireOpts TTLOptionSet) (*Event, error) {
-	var err *etcdErr.Error
+	var err *v2error.Error
 
 	s.worldLock.Lock()
 	defer s.worldLock.Unlock()
@@ -510,7 +510,7 @@ func (s *store) Update(nodePath string, newValue string, expireOpts TTLOptionSet
 	nodePath = path.Clean(path.Join("/", nodePath))
 	// we do not allow the user to change "/"
 	if s.readonlySet.Contains(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, "/", s.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, "/", s.CurrentIndex)
 	}
 
 	currIndex, nextIndex := s.CurrentIndex, s.CurrentIndex+1
@@ -521,7 +521,7 @@ func (s *store) Update(nodePath string, newValue string, expireOpts TTLOptionSet
 	}
 	if n.IsDir() && len(newValue) != 0 {
 		// if the node is a directory, we cannot update value to non-empty
-		return nil, etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, currIndex)
+		return nil, v2error.NewError(v2error.EcodeNotFile, nodePath, currIndex)
 	}
 
 	if expireOpts.Refresh {
@@ -561,7 +561,7 @@ func (s *store) Update(nodePath string, newValue string, expireOpts TTLOptionSet
 }
 
 func (s *store) internalCreate(nodePath string, dir bool, value string, unique, replace bool,
-	expireTime time.Time, action string) (*Event, *etcdErr.Error) {
+	expireTime time.Time, action string) (*Event, *v2error.Error) {
 
 	currIndex, nextIndex := s.CurrentIndex, s.CurrentIndex+1
 
@@ -573,7 +573,7 @@ func (s *store) internalCreate(nodePath string, dir bool, value string, unique,
 
 	// we do not allow the user to change "/"
 	if s.readonlySet.Contains(nodePath) {
-		return nil, etcdErr.NewError(etcdErr.EcodeRootROnly, "/", currIndex)
+		return nil, v2error.NewError(v2error.EcodeRootROnly, "/", currIndex)
 	}
 
 	// Assume expire times that are way in the past are
@@ -603,13 +603,13 @@ func (s *store) internalCreate(nodePath string, dir bool, value string, unique,
 	if n != nil {
 		if replace {
 			if n.IsDir() {
-				return nil, etcdErr.NewError(etcdErr.EcodeNotFile, nodePath, currIndex)
+				return nil, v2error.NewError(v2error.EcodeNotFile, nodePath, currIndex)
 			}
 			e.PrevNode = n.Repr(false, false, s.clock)
 
 			n.Remove(false, false, nil)
 		} else {
-			return nil, etcdErr.NewError(etcdErr.EcodeNodeExist, nodePath, currIndex)
+			return nil, v2error.NewError(v2error.EcodeNodeExist, nodePath, currIndex)
 		}
 	}
 
@@ -642,13 +642,13 @@ func (s *store) internalCreate(nodePath string, dir bool, value string, unique,
 }
 
 // InternalGet gets the node of the given nodePath.
-func (s *store) internalGet(nodePath string) (*node, *etcdErr.Error) {
+func (s *store) internalGet(nodePath string) (*node, *v2error.Error) {
 	nodePath = path.Clean(path.Join("/", nodePath))
 
-	walkFunc := func(parent *node, name string) (*node, *etcdErr.Error) {
+	walkFunc := func(parent *node, name string) (*node, *v2error.Error) {
 
 		if !parent.IsDir() {
-			err := etcdErr.NewError(etcdErr.EcodeNotDir, parent.Path, s.CurrentIndex)
+			err := v2error.NewError(v2error.EcodeNotDir, parent.Path, s.CurrentIndex)
 			return nil, err
 		}
 
@@ -657,7 +657,7 @@ func (s *store) internalGet(nodePath string) (*node, *etcdErr.Error) {
 			return child, nil
 		}
 
-		return nil, etcdErr.NewError(etcdErr.EcodeKeyNotFound, path.Join(parent.Path, name), s.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeKeyNotFound, path.Join(parent.Path, name), s.CurrentIndex)
 	}
 
 	f, err := s.walk(nodePath, walkFunc)
@@ -707,7 +707,7 @@ func (s *store) DeleteExpiredKeys(cutoff time.Time) {
 // If it is a directory, this function will return the pointer to that node.
 // If it does not exist, this function will create a new directory and return the pointer to that node.
 // If it is a file, this function will return error.
-func (s *store) checkDir(parent *node, dirName string) (*node, *etcdErr.Error) {
+func (s *store) checkDir(parent *node, dirName string) (*node, *v2error.Error) {
 	node, ok := parent.Children[dirName]
 
 	if ok {
@@ -715,7 +715,7 @@ func (s *store) checkDir(parent *node, dirName string) (*node, *etcdErr.Error) {
 			return node, nil
 		}
 
-		return nil, etcdErr.NewError(etcdErr.EcodeNotDir, node.Path, s.CurrentIndex)
+		return nil, v2error.NewError(v2error.EcodeNotDir, node.Path, s.CurrentIndex)
 	}
 
 	n := newDir(s, path.Join(parent.Path, dirName), s.CurrentIndex+1, parent, Permanent)

etcdserver/v2store/store_test.go

@@ -18,7 +18,7 @@ import (
 	"testing"
 	"time"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/etcdserver/v2store"
 	"github.com/coreos/etcd/pkg/testutil"
 )
@@ -219,8 +219,8 @@ func TestStoreCreateFailsIfExists(t *testing.T) {
 
 	// create /foo as dir again
 	e, _err := s.Create("/foo", true, "", false, v2store.TTLOptionSet{ExpireTime:v2 store.Permanent})
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeNodeExist)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeNodeExist)
 	testutil.AssertEqual(t, err.Message, "Key already exists")
 	testutil.AssertEqual(t, err.Cause, "/foo")
 	testutil.AssertEqual(t, err.Index, uint64(1))
@@ -284,8 +284,8 @@ func TestStoreUpdateFailsIfDirectory(t *testing.T) {
 
 	s.Create("/foo", true, "", false, v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
 	e, _err := s.Update("/foo", "baz", v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeNotFile)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeNotFile)
 	testutil.AssertEqual(t, err.Message, "Not a file")
 	testutil.AssertEqual(t, err.Cause, "/foo")
 	testutil.AssertNil(t, e)
@@ -353,8 +353,8 @@ func TestStoreDeleteDirectoryFailsIfNonRecursiveAndDir(t *testing.T) {
 
 	s.Create("/foo", true, "", false, v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
 	e, _err := s.Delete("/foo", false, false)
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeNotFile)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeNotFile)
 	testutil.AssertEqual(t, err.Message, "Not a file")
 	testutil.AssertNil(t, e)
 }
@@ -408,8 +408,8 @@ func TestStoreCompareAndDeletePrevValueFailsIfNotMatch(t *testing.T) {
 	var eidx uint64 = 1
 	s.Create("/foo", false, "bar", false, v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
 	e, _err := s.CompareAndDelete("/foo", "baz", 0)
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeTestFailed)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeTestFailed)
 	testutil.AssertEqual(t, err.Message, "Compare failed")
 	testutil.AssertNil(t, e)
 	e, _ = s.Get("/foo", false, false)
@@ -443,8 +443,8 @@ func TestStoreCompareAndDeletePrevIndexFailsIfNotMatch(t *testing.T) {
 	s.Create("/foo", false, "bar", false, v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
 	e, _err := s.CompareAndDelete("/foo", "", 100)
 	testutil.AssertNotNil(t, _err)
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeTestFailed)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeTestFailed)
 	testutil.AssertEqual(t, err.Message, "Compare failed")
 	testutil.AssertNil(t, e)
 	e, _ = s.Get("/foo", false, false)
@@ -460,8 +460,8 @@ func TestStoreCompareAndDeleteDirectoryFail(t *testing.T) {
 	s.Create("/foo", true, "", false, v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
 	_, _err := s.CompareAndDelete("/foo", "", 0)
 	testutil.AssertNotNil(t, _err)
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeNotFile)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeNotFile)
 }
 
 // Ensure that the store can conditionally update a key if it has a previous value.
@@ -494,8 +494,8 @@ func TestStoreCompareAndSwapPrevValueFailsIfNotMatch(t *testing.T) {
 	var eidx uint64 = 1
 	s.Create("/foo", false, "bar", false, v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
 	e, _err := s.CompareAndSwap("/foo", "wrong_value", 0, "baz", v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeTestFailed)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeTestFailed)
 	testutil.AssertEqual(t, err.Message, "Compare failed")
 	testutil.AssertNil(t, e)
 	e, _ = s.Get("/foo", false, false)
@@ -533,8 +533,8 @@ func TestStoreCompareAndSwapPrevIndexFailsIfNotMatch(t *testing.T) {
 	var eidx uint64 = 1
 	s.Create("/foo", false, "bar", false, v2store.TTLOptionSet{ExpireTime: v2store.Permanent})
 	e, _err := s.CompareAndSwap("/foo", "", 100, "baz", v2store.TTLOptionSet{ExpireTime:v2 store.Permanent})
-	err := _err.(*etcdErr.Error)
-	testutil.AssertEqual(t, err.ErrorCode, etcdErr.EcodeTestFailed)
+	err := _err.(*v2error.Error)
+	testutil.AssertEqual(t, err.ErrorCode, v2error.EcodeTestFailed)
 	testutil.AssertEqual(t, err.Message, "Compare failed")
 	testutil.AssertNil(t, e)
 	e, _ = s.Get("/foo", false, false)

etcdserver/v2store/store_ttl_test.go

@@ -18,7 +18,7 @@ import (
 	"testing"
 	"time"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 	"github.com/coreos/etcd/pkg/testutil"
 
 	"github.com/jonboulle/clockwork"
@@ -110,7 +110,7 @@ func TestStoreUpdateValueTTL(t *testing.T) {
 	s.DeleteExpiredKeys(fc.Now())
 	e, err = s.Get("/foo", false, false)
 	testutil.AssertNil(t, e)
-	testutil.AssertEqual(t, err.(*etcdErr.Error).ErrorCode, etcdErr.EcodeKeyNotFound)
+	testutil.AssertEqual(t, err.(*v2error.Error).ErrorCode, v2error.EcodeKeyNotFound)
 }
 
 // Ensure that the store can update the TTL on a directory.
@@ -134,7 +134,7 @@ func TestStoreUpdateDirTTL(t *testing.T) {
 	s.DeleteExpiredKeys(fc.Now())
 	e, err = s.Get("/foo/bar", false, false)
 	testutil.AssertNil(t, e)
-	testutil.AssertEqual(t, err.(*etcdErr.Error).ErrorCode, etcdErr.EcodeKeyNotFound)
+	testutil.AssertEqual(t, err.(*v2error.Error).ErrorCode, v2error.EcodeKeyNotFound)
 }
 
 // Ensure that the store can watch for key expiration.

etcdserver/v2store/watcher_hub.go

@@ -21,7 +21,7 @@ import (
 	"sync"
 	"sync/atomic"
 
-	etcdErr "github.com/coreos/etcd/error"
+	"github.com/coreos/etcd/etcdserver/v2error"
 )
 
 // A watcherHub contains all subscribed watchers
@@ -56,7 +56,7 @@ func newWatchHub(capacity int) *watcherHub {
 // If recursive is true, the first change after index under key will be sent to the event channel of the watcher.
 // If recursive is false, the first change after index at key will be sent to the event channel of the watcher.
 // If index is zero, watch will start from the current index + 1.
-func (wh *watcherHub) watch(key string, recursive, stream bool, index, storeIndex uint64) (Watcher, *etcdErr.Error) {
+func (wh *watcherHub) watch(key string, recursive, stream bool, index, storeIndex uint64) (Watcher, *v2error.Error) {
 	reportWatchRequest()
 	event, err := wh.EventHistory.scan(key, recursive, index)