Mirroristas/etcd
2
0
Fork 0
mirror of https://github.com/etcd-io/etcd.git synced 2024-09-27 06:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Signed-off-by: Gyuho Lee <gyuhox@gmail.com>
This commit is contained in:
Gyuho Lee 2018-02-26 11:36:56 -08:00
parent b24d81c30d
commit 69f7e11506
21 changed files with 228 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
etcdctl/ctlv3/command/migrate_command.go
View File

@ -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)
}

4
etcdserver/api/etcdhttp/base.go
View File

@ -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 {

82
etcdserver/api/v2http/client.go
View File

@ -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

74
etcdserver/api/v2http/client_test.go
View File

@ -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,

6
etcdserver/api/v2http/http_test.go
View File

@ -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",
},

6
etcdserver/api/v2http/metrics.go
View File

@ -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:

52
etcdserver/api/v2v3/store.go
View File

@ -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 {

4
etcdserver/api/v2v3/watcher.go
View File

@ -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{})

6
etcdserver/membership/errors.go
View File

@ -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
}

42
etcdserver/v2auth/auth.go
View File

@ -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)
}
}

14
etcdserver/v2auth/auth_requests.go
View File

@ -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
}
}

10
etcdserver/v2auth/auth_test.go
View File

@ -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++

5
error/error.go → etcdserver/v2error/error.go
View File

@ -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"

2
error/error_test.go → etcdserver/v2error/error_test.go
View File

@ -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"

6
etcdserver/v2store/event_history.go
View File

@ -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)
}

6
etcdserver/v2store/event_test.go
View File

@ -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)
}
}

30
etcdserver/v2store/node.go
View File

@ -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

58
etcdserver/v2store/store.go
View File

@ -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)

34
etcdserver/v2store/store_test.go
View File

@ -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)

6
etcdserver/v2store/store_ttl_test.go
View File

@ -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.

4
etcdserver/v2store/watcher_hub.go
View File

@ -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)