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

Rename etcdserver/etcderrors package to etcdserver/errors.

Browse Source
This commit is contained in:
Piotr Tabor 2022-05-06 13:42:02 +02:00
parent 63b2f63cc1
commit 5097b33ab9
17 changed files with 135 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
server/etcdmain/etcd.go
View File

@ -26,7 +26,7 @@ import (
"go.etcd.io/etcd/pkg/v3/osutil"
"go.etcd.io/etcd/server/v3/embed"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2discovery"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.uber.org/zap"
"google.golang.org/grpc"
)
@ -126,7 +126,7 @@ func startEtcdOrProxyV2(args []string) {
}
if err != nil {
if derr, ok := err.(*etcderrors.DiscoveryError); ok {
if derr, ok := err.(*errors.DiscoveryError); ok {
switch derr.Err {
case v2discovery.ErrDuplicateID:
lg.Warn(

4
server/etcdserver/api/etcdhttp/peer.go
View File

@ -26,7 +26,7 @@ import (
"go.etcd.io/etcd/server/v3/etcdserver/api"
"go.etcd.io/etcd/server/v3/etcdserver/api/membership"
"go.etcd.io/etcd/server/v3/etcdserver/api/rafthttp"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/server/v3/lease/leasehttp"
"go.uber.org/zap"
@ -143,7 +143,7 @@ func (h *peerMemberPromoteHandler) ServeHTTP(w http.ResponseWriter, r *http.Requ
http.Error(w, err.Error(), http.StatusNotFound)
case membership.ErrMemberNotLearner:
http.Error(w, err.Error(), http.StatusPreconditionFailed)
case etcderrors.ErrLearnerNotReady:
case errors.ErrLearnerNotReady:
http.Error(w, err.Error(), http.StatusPreconditionFailed)
default:
writeError(h.lg, w, r, err)

6
server/etcdserver/api/etcdhttp/utils.go
View File

@ -17,9 +17,9 @@ package etcdhttp
import (
"net/http"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
httptypes "go.etcd.io/etcd/server/v3/etcdserver/api/etcdhttp/types"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2error"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.uber.org/zap"
)
@ -57,8 +57,8 @@ func writeError(lg *zap.Logger, w http.ResponseWriter, r *http.Request, err erro
default:
switch err {
case etcderrors.ErrTimeoutDueToLeaderFail, etcderrors.ErrTimeoutDueToConnectionLost, etcderrors.ErrNotEnoughStartedMembers,
etcderrors.ErrUnhealthy:
case errors.ErrTimeoutDueToLeaderFail, errors.ErrTimeoutDueToConnectionLost, errors.ErrNotEnoughStartedMembers,
errors.ErrUnhealthy:
if lg != nil {
lg.Warn(
"v2 response error",

4
server/etcdserver/api/v3rpc/maintenance.go
View File

@ -28,7 +28,7 @@ import (
"go.etcd.io/etcd/server/v3/auth"
"go.etcd.io/etcd/server/v3/etcdserver"
"go.etcd.io/etcd/server/v3/etcdserver/apply"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
serverversion "go.etcd.io/etcd/server/v3/etcdserver/version"
"go.etcd.io/etcd/server/v3/storage/backend"
"go.etcd.io/etcd/server/v3/storage/mvcc"
@ -243,7 +243,7 @@ func (ms *maintenanceServer) Status(ctx context.Context, ar *pb.StatusRequest) (
resp.StorageVersion = storageVersion.String()
}
if resp.Leader == raft.None {
resp.Errors = append(resp.Errors, etcderrors.ErrNoLeader.Error())
resp.Errors = append(resp.Errors, errors.ErrNoLeader.Error())
}
for _, a := range ms.a.Alarms() {
resp.Errors = append(resp.Errors, a.String())

62
server/etcdserver/api/v3rpc/util.go
View File

@ -22,7 +22,7 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/server/v3/auth"
"go.etcd.io/etcd/server/v3/etcdserver/api/membership"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/server/v3/etcdserver/version"
"go.etcd.io/etcd/server/v3/lease"
"go.etcd.io/etcd/server/v3/storage/mvcc"
@ -32,39 +32,39 @@ import (
)
var toGRPCErrorMap = map[error]error{
membership.ErrIDRemoved: rpctypes.ErrGRPCMemberNotFound,
membership.ErrIDNotFound: rpctypes.ErrGRPCMemberNotFound,
membership.ErrIDExists: rpctypes.ErrGRPCMemberExist,
membership.ErrPeerURLexists: rpctypes.ErrGRPCPeerURLExist,
membership.ErrMemberNotLearner: rpctypes.ErrGRPCMemberNotLearner,
membership.ErrTooManyLearners: rpctypes.ErrGRPCTooManyLearners,
etcderrors.ErrNotEnoughStartedMembers: rpctypes.ErrMemberNotEnoughStarted,
etcderrors.ErrLearnerNotReady: rpctypes.ErrGRPCLearnerNotReady,
membership.ErrIDRemoved: rpctypes.ErrGRPCMemberNotFound,
membership.ErrIDNotFound: rpctypes.ErrGRPCMemberNotFound,
membership.ErrIDExists: rpctypes.ErrGRPCMemberExist,
membership.ErrPeerURLexists: rpctypes.ErrGRPCPeerURLExist,
membership.ErrMemberNotLearner: rpctypes.ErrGRPCMemberNotLearner,
membership.ErrTooManyLearners: rpctypes.ErrGRPCTooManyLearners,
errors.ErrNotEnoughStartedMembers: rpctypes.ErrMemberNotEnoughStarted,
errors.ErrLearnerNotReady: rpctypes.ErrGRPCLearnerNotReady,
mvcc.ErrCompacted: rpctypes.ErrGRPCCompacted,
mvcc.ErrFutureRev: rpctypes.ErrGRPCFutureRev,
etcderrors.ErrRequestTooLarge: rpctypes.ErrGRPCRequestTooLarge,
etcderrors.ErrNoSpace: rpctypes.ErrGRPCNoSpace,
etcderrors.ErrTooManyRequests: rpctypes.ErrTooManyRequests,
mvcc.ErrCompacted: rpctypes.ErrGRPCCompacted,
mvcc.ErrFutureRev: rpctypes.ErrGRPCFutureRev,
errors.ErrRequestTooLarge: rpctypes.ErrGRPCRequestTooLarge,
errors.ErrNoSpace: rpctypes.ErrGRPCNoSpace,
errors.ErrTooManyRequests: rpctypes.ErrTooManyRequests,
etcderrors.ErrNoLeader: rpctypes.ErrGRPCNoLeader,
etcderrors.ErrNotLeader: rpctypes.ErrGRPCNotLeader,
etcderrors.ErrLeaderChanged: rpctypes.ErrGRPCLeaderChanged,
etcderrors.ErrStopped: rpctypes.ErrGRPCStopped,
etcderrors.ErrTimeout: rpctypes.ErrGRPCTimeout,
etcderrors.ErrTimeoutDueToLeaderFail: rpctypes.ErrGRPCTimeoutDueToLeaderFail,
etcderrors.ErrTimeoutDueToConnectionLost: rpctypes.ErrGRPCTimeoutDueToConnectionLost,
etcderrors.ErrTimeoutWaitAppliedIndex: rpctypes.ErrGRPCTimeoutWaitAppliedIndex,
etcderrors.ErrUnhealthy: rpctypes.ErrGRPCUnhealthy,
etcderrors.ErrKeyNotFound: rpctypes.ErrGRPCKeyNotFound,
etcderrors.ErrCorrupt: rpctypes.ErrGRPCCorrupt,
etcderrors.ErrBadLeaderTransferee: rpctypes.ErrGRPCBadLeaderTransferee,
errors.ErrNoLeader: rpctypes.ErrGRPCNoLeader,
errors.ErrNotLeader: rpctypes.ErrGRPCNotLeader,
errors.ErrLeaderChanged: rpctypes.ErrGRPCLeaderChanged,
errors.ErrStopped: rpctypes.ErrGRPCStopped,
errors.ErrTimeout: rpctypes.ErrGRPCTimeout,
errors.ErrTimeoutDueToLeaderFail: rpctypes.ErrGRPCTimeoutDueToLeaderFail,
errors.ErrTimeoutDueToConnectionLost: rpctypes.ErrGRPCTimeoutDueToConnectionLost,
errors.ErrTimeoutWaitAppliedIndex: rpctypes.ErrGRPCTimeoutWaitAppliedIndex,
errors.ErrUnhealthy: rpctypes.ErrGRPCUnhealthy,
errors.ErrKeyNotFound: rpctypes.ErrGRPCKeyNotFound,
errors.ErrCorrupt: rpctypes.ErrGRPCCorrupt,
errors.ErrBadLeaderTransferee: rpctypes.ErrGRPCBadLeaderTransferee,
etcderrors.ErrClusterVersionUnavailable: rpctypes.ErrGRPCClusterVersionUnavailable,
etcderrors.ErrWrongDowngradeVersionFormat: rpctypes.ErrGRPCWrongDowngradeVersionFormat,
version.ErrInvalidDowngradeTargetVersion: rpctypes.ErrGRPCInvalidDowngradeTargetVersion,
version.ErrDowngradeInProcess: rpctypes.ErrGRPCDowngradeInProcess,
version.ErrNoInflightDowngrade: rpctypes.ErrGRPCNoInflightDowngrade,
errors.ErrClusterVersionUnavailable: rpctypes.ErrGRPCClusterVersionUnavailable,
errors.ErrWrongDowngradeVersionFormat: rpctypes.ErrGRPCWrongDowngradeVersionFormat,
version.ErrInvalidDowngradeTargetVersion: rpctypes.ErrGRPCInvalidDowngradeTargetVersion,
version.ErrDowngradeInProcess: rpctypes.ErrGRPCDowngradeInProcess,
version.ErrNoInflightDowngrade: rpctypes.ErrGRPCNoInflightDowngrade,
lease.ErrLeaseNotFound: rpctypes.ErrGRPCLeaseNotFound,
lease.ErrLeaseExists: rpctypes.ErrGRPCLeaseExist,

14
server/etcdserver/apply/apply.go
View File

@ -27,7 +27,7 @@ import (
"go.etcd.io/etcd/server/v3/etcdserver/api/membership"
"go.etcd.io/etcd/server/v3/etcdserver/api/v3alarm"
"go.etcd.io/etcd/server/v3/etcdserver/cindex"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
mvcc_txn "go.etcd.io/etcd/server/v3/etcdserver/txn"
"go.etcd.io/etcd/server/v3/etcdserver/version"
"go.etcd.io/etcd/server/v3/lease"
@ -252,18 +252,18 @@ type applierV3Capped struct {
func newApplierV3Capped(base applierV3) applierV3 { return &applierV3Capped{applierV3: base} }
func (a *applierV3Capped) Put(_ context.Context, _ mvcc.TxnWrite, _ *pb.PutRequest) (*pb.PutResponse, *traceutil.Trace, error) {
return nil, nil, etcderrors.ErrNoSpace
return nil, nil, errors.ErrNoSpace
}
func (a *applierV3Capped) Txn(ctx context.Context, r *pb.TxnRequest) (*pb.TxnResponse, *traceutil.Trace, error) {
if a.q.Cost(r) > 0 {
return nil, nil, etcderrors.ErrNoSpace
return nil, nil, errors.ErrNoSpace
}
return a.applierV3.Txn(ctx, r)
}
func (a *applierV3Capped) LeaseGrant(_ *pb.LeaseGrantRequest) (*pb.LeaseGrantResponse, error) {
return nil, etcderrors.ErrNoSpace
return nil, errors.ErrNoSpace
}
func (a *applierV3backend) AuthEnable() (*pb.AuthEnableResponse, error) {
@ -447,7 +447,7 @@ func (a *quotaApplierV3) Put(ctx context.Context, txn mvcc.TxnWrite, p *pb.PutRe
ok := a.q.Available(p)
resp, trace, err := a.applierV3.Put(ctx, txn, p)
if err == nil && !ok {
err = etcderrors.ErrNoSpace
err = errors.ErrNoSpace
}
return resp, trace, err
}
@ -456,7 +456,7 @@ func (a *quotaApplierV3) Txn(ctx context.Context, rt *pb.TxnRequest) (*pb.TxnRes
ok := a.q.Available(rt)
resp, trace, err := a.applierV3.Txn(ctx, rt)
if err == nil && !ok {
err = etcderrors.ErrNoSpace
err = errors.ErrNoSpace
}
return resp, trace, err
}
@ -465,7 +465,7 @@ func (a *quotaApplierV3) LeaseGrant(lc *pb.LeaseGrantRequest) (*pb.LeaseGrantRes
ok := a.q.Available(lc)
resp, err := a.applierV3.LeaseGrant(lc)
if err == nil && !ok {
err = etcderrors.ErrNoSpace
err = errors.ErrNoSpace
}
return resp, err
}

16
server/etcdserver/apply/corrupt.go
View File

@ -19,7 +19,7 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/pkg/v3/traceutil"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/server/v3/storage/mvcc"
)
@ -30,29 +30,29 @@ type applierV3Corrupt struct {
func newApplierV3Corrupt(a applierV3) *applierV3Corrupt { return &applierV3Corrupt{a} }
func (a *applierV3Corrupt) Put(ctx context.Context, txn mvcc.TxnWrite, p *pb.PutRequest) (*pb.PutResponse, *traceutil.Trace, error) {
return nil, nil, etcderrors.ErrCorrupt
return nil, nil, errors.ErrCorrupt
}
func (a *applierV3Corrupt) Range(ctx context.Context, txn mvcc.TxnRead, p *pb.RangeRequest) (*pb.RangeResponse, error) {
return nil, etcderrors.ErrCorrupt
return nil, errors.ErrCorrupt
}
func (a *applierV3Corrupt) DeleteRange(txn mvcc.TxnWrite, p *pb.DeleteRangeRequest) (*pb.DeleteRangeResponse, error) {
return nil, etcderrors.ErrCorrupt
return nil, errors.ErrCorrupt
}
func (a *applierV3Corrupt) Txn(ctx context.Context, rt *pb.TxnRequest) (*pb.TxnResponse, *traceutil.Trace, error) {
return nil, nil, etcderrors.ErrCorrupt
return nil, nil, errors.ErrCorrupt
}
func (a *applierV3Corrupt) Compaction(compaction *pb.CompactionRequest) (*pb.CompactionResponse, <-chan struct{}, *traceutil.Trace, error) {
return nil, nil, nil, etcderrors.ErrCorrupt
return nil, nil, nil, errors.ErrCorrupt
}
func (a *applierV3Corrupt) LeaseGrant(lc *pb.LeaseGrantRequest) (*pb.LeaseGrantResponse, error) {
return nil, etcderrors.ErrCorrupt
return nil, errors.ErrCorrupt
}
func (a *applierV3Corrupt) LeaseRevoke(lc *pb.LeaseRevokeRequest) (*pb.LeaseRevokeResponse, error) {
return nil, etcderrors.ErrCorrupt
return nil, errors.ErrCorrupt
}

4
server/etcdserver/apply_v2.go
View File

@ -26,7 +26,7 @@ import (
"go.etcd.io/etcd/server/v3/etcdserver/api"
"go.etcd.io/etcd/server/v3/etcdserver/api/membership"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2store"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/server/v3/etcdserver/txn"
"go.uber.org/zap"
@ -147,7 +147,7 @@ func (s *EtcdServer) applyV2Request(r *RequestV2, shouldApplyV3 membership.Shoul
return s.applyV2.Sync(r)
default:
// This should never be reached, but just in case:
return Response{Err: etcderrors.ErrUnknownMethod}
return Response{Err: errors.ErrUnknownMethod}
}
}

4
server/etcdserver/bootstrap.go
View File

@ -25,7 +25,7 @@ import (
"github.com/coreos/go-semver/semver"
"github.com/dustin/go-humanize"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.uber.org/zap"
"go.etcd.io/etcd/api/v3/etcdserverpb"
@ -338,7 +338,7 @@ func bootstrapNewClusterNoWAL(cfg config.ServerConfig, prt http.RoundTripper) (*
str, err = v3discovery.JoinCluster(cfg.Logger, &cfg.DiscoveryCfg, m.ID, cfg.InitialPeerURLsMap.String())
}
if err != nil {
return nil, &etcderrors.DiscoveryError{Op: "join", Err: err}
return nil, &errors.DiscoveryError{Op: "join", Err: err}
}
var urlsmap types.URLsMap
urlsmap, err = types.NewURLsMap(str)

10
server/etcdserver/cluster_util.go
View File

@ -28,7 +28,7 @@ import (
"go.etcd.io/etcd/api/v3/version"
"go.etcd.io/etcd/client/pkg/v3/types"
"go.etcd.io/etcd/server/v3/etcdserver/api/membership"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"github.com/coreos/go-semver/semver"
"go.uber.org/zap"
@ -305,12 +305,12 @@ func promoteMemberHTTP(ctx context.Context, url string, id uint64, peerRt http.R
}
if resp.StatusCode == http.StatusRequestTimeout {
return nil, etcderrors.ErrTimeout
return nil, errors.ErrTimeout
}
if resp.StatusCode == http.StatusPreconditionFailed {
// both ErrMemberNotLearner and ErrLearnerNotReady have same http status code
if strings.Contains(string(b), etcderrors.ErrLearnerNotReady.Error()) {
return nil, etcderrors.ErrLearnerNotReady
if strings.Contains(string(b), errors.ErrLearnerNotReady.Error()) {
return nil, errors.ErrLearnerNotReady
}
if strings.Contains(string(b), membership.ErrMemberNotLearner.Error()) {
return nil, membership.ErrMemberNotLearner
@ -409,7 +409,7 @@ func convertToClusterVersion(v string) (*semver.Version, error) {
// allow input version format Major.Minor
ver, err = semver.NewVersion(v + ".0")
if err != nil {
return nil, etcderrors.ErrWrongDowngradeVersionFormat
return nil, errors.ErrWrongDowngradeVersionFormat
}
}
// cluster version only keeps major.minor, remove patch version

2
server/etcdserver/etcderrors/errors.go → server/etcdserver/errors/errors.go
View File

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package etcderrors
package errors
import (
"errors"

60
server/etcdserver/server.go
View File

@ -36,7 +36,7 @@ import (
"go.etcd.io/etcd/pkg/v3/runtime"
"go.etcd.io/etcd/server/v3/config"
"go.etcd.io/etcd/server/v3/etcdserver/apply"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.uber.org/zap"
pb "go.etcd.io/etcd/api/v3/etcdserverpb"
@ -976,7 +976,7 @@ func (s *EtcdServer) applySnapshot(ep *etcdProgress, toApply *toApply) {
// Eventually the new consistent_index value coming from snapshot is overwritten
// by the old value.
s.consistIndex.SetBackend(newbe)
verifySnapshotIndex(apply.snapshot, s.consistIndex.ConsistentIndex())
verifySnapshotIndex(toApply.snapshot, s.consistIndex.ConsistentIndex())
// always recover lessor before kv. When we recover the mvcc.KV it will reattach keys to its leases.
// If we recover mvcc.KV first, it will attach the keys to the wrong lessor before it recovers.
@ -1154,7 +1154,7 @@ func (s *EtcdServer) isLeader() bool {
// MoveLeader transfers the leader to the given transferee.
func (s *EtcdServer) MoveLeader(ctx context.Context, lead, transferee uint64) error {
if !s.cluster.IsMemberExist(types.ID(transferee)) || s.cluster.Member(types.ID(transferee)).IsLearner {
return etcderrors.ErrBadLeaderTransferee
return errors.ErrBadLeaderTransferee
}
now := time.Now()
@ -1172,7 +1172,7 @@ func (s *EtcdServer) MoveLeader(ctx context.Context, lead, transferee uint64) er
for s.Lead() != transferee {
select {
case <-ctx.Done(): // time out
return etcderrors.ErrTimeoutLeaderTransfer
return errors.ErrTimeoutLeaderTransfer
case <-time.After(interval):
}
}
@ -1211,7 +1211,7 @@ func (s *EtcdServer) TransferLeadership() error {
transferee, ok := longestConnected(s.r.transport, s.cluster.VotingMemberIDs())
if !ok {
return etcderrors.ErrUnhealthy
return errors.ErrUnhealthy
}
tm := s.Cfg.ReqTimeout()
@ -1330,9 +1330,9 @@ func (s *EtcdServer) mayAddMember(memb membership.Member) error {
"rejecting member add request; not enough healthy members",
zap.String("local-member-id", s.MemberId().String()),
zap.String("requested-member-add", fmt.Sprintf("%+v", memb)),
zap.Error(etcderrors.ErrNotEnoughStartedMembers),
zap.Error(errors.ErrNotEnoughStartedMembers),
)
return etcderrors.ErrNotEnoughStartedMembers
return errors.ErrNotEnoughStartedMembers
}
if !isConnectedFullySince(s.r.transport, time.Now().Add(-HealthInterval), s.MemberId(), s.cluster.VotingMembers()) {
@ -1340,9 +1340,9 @@ func (s *EtcdServer) mayAddMember(memb membership.Member) error {
"rejecting member add request; local member has not been connected to all peers, reconfigure breaks active quorum",
zap.String("local-member-id", s.MemberId().String()),
zap.String("requested-member-add", fmt.Sprintf("%+v", memb)),
zap.Error(etcderrors.ErrUnhealthy),
zap.Error(errors.ErrUnhealthy),
)
return etcderrors.ErrUnhealthy
return errors.ErrUnhealthy
}
return nil
@ -1375,7 +1375,7 @@ func (s *EtcdServer) PromoteMember(ctx context.Context, id uint64) ([]*membershi
learnerPromoteSucceed.Inc()
return resp, nil
}
if err != etcderrors.ErrNotLeader {
if err != errors.ErrNotLeader {
learnerPromoteFailed.WithLabelValues(err.Error()).Inc()
return resp, err
}
@ -1394,16 +1394,16 @@ func (s *EtcdServer) PromoteMember(ctx context.Context, id uint64) ([]*membershi
return resp, nil
}
// If member promotion failed, return early. Otherwise keep retry.
if err == etcderrors.ErrLearnerNotReady || err == membership.ErrIDNotFound || err == membership.ErrMemberNotLearner {
if err == errors.ErrLearnerNotReady || err == membership.ErrIDNotFound || err == membership.ErrMemberNotLearner {
return nil, err
}
}
}
if cctx.Err() == context.DeadlineExceeded {
return nil, etcderrors.ErrTimeout
return nil, errors.ErrTimeout
}
return nil, etcderrors.ErrCanceled
return nil, errors.ErrCanceled
}
// promoteMember checks whether the to-be-promoted learner node is ready before sending the promote
@ -1459,9 +1459,9 @@ func (s *EtcdServer) mayPromoteMember(id types.ID) error {
"rejecting member promote request; not enough healthy members",
zap.String("local-member-id", s.MemberId().String()),
zap.String("requested-member-remove-id", id.String()),
zap.Error(etcderrors.ErrNotEnoughStartedMembers),
zap.Error(errors.ErrNotEnoughStartedMembers),
)
return etcderrors.ErrNotEnoughStartedMembers
return errors.ErrNotEnoughStartedMembers
}
return nil
@ -1475,7 +1475,7 @@ func (s *EtcdServer) isLearnerReady(id uint64) error {
// leader's raftStatus.Progress is not nil
if rs.Progress == nil {
return etcderrors.ErrNotLeader
return errors.ErrNotLeader
}
var learnerMatch uint64
@ -1494,7 +1494,7 @@ func (s *EtcdServer) isLearnerReady(id uint64) error {
leaderMatch := rs.Progress[leaderID].Match
// the learner's Match not caught up with leader yet
if float64(learnerMatch) < float64(leaderMatch)*readyPercent {
return etcderrors.ErrLearnerNotReady
return errors.ErrLearnerNotReady
}
}
@ -1518,9 +1518,9 @@ func (s *EtcdServer) mayRemoveMember(id types.ID) error {
"rejecting member remove request; not enough healthy members",
zap.String("local-member-id", s.MemberId().String()),
zap.String("requested-member-remove-id", id.String()),
zap.Error(etcderrors.ErrNotEnoughStartedMembers),
zap.Error(errors.ErrNotEnoughStartedMembers),
)
return etcderrors.ErrNotEnoughStartedMembers
return errors.ErrNotEnoughStartedMembers
}
// downed member is safe to remove since it's not part of the active quorum
@ -1537,9 +1537,9 @@ func (s *EtcdServer) mayRemoveMember(id types.ID) error {
zap.String("local-member-id", s.MemberId().String()),
zap.String("requested-member-remove", id.String()),
zap.Int("active-peers", active),
zap.Error(etcderrors.ErrUnhealthy),
zap.Error(errors.ErrUnhealthy),
)
return etcderrors.ErrUnhealthy
return errors.ErrUnhealthy
}
return nil
@ -1656,7 +1656,7 @@ func (s *EtcdServer) configure(ctx context.Context, cc raftpb.ConfChange) ([]*me
return nil, s.parseProposeCtxErr(ctx.Err(), start)
case <-s.stopping:
return nil, etcderrors.ErrStopped
return nil, errors.ErrStopped
}
}
@ -1904,7 +1904,7 @@ func (s *EtcdServer) applyEntryNormal(e *raftpb.Entry) {
return
}
if ar.Err != etcderrors.ErrNoSpace || len(s.alarmStore.Get(pb.AlarmType_NOSPACE)) > 0 {
if ar.Err != errors.ErrNoSpace || len(s.alarmStore.Get(pb.AlarmType_NOSPACE)) > 0 {
s.w.Trigger(id, ar)
return
}
@ -2209,7 +2209,7 @@ func (s *EtcdServer) updateClusterVersionV2(ver string) {
lg.Info("cluster version is updated", zap.String("cluster-version", version.Cluster(ver)))
return
case etcderrors.ErrStopped:
case errors.ErrStopped:
lg.Warn("aborting cluster version update; server is stopped", zap.Error(err))
return
@ -2245,7 +2245,7 @@ func (s *EtcdServer) updateClusterVersionV3(ver string) {
lg.Info("cluster version is updated", zap.String("cluster-version", version.Cluster(ver)))
return
case etcderrors.ErrStopped:
case errors.ErrStopped:
lg.Warn("aborting cluster version update; server is stopped", zap.Error(err))
return
@ -2278,7 +2278,7 @@ func (s *EtcdServer) monitorDowngrade() {
func (s *EtcdServer) parseProposeCtxErr(err error, start time.Time) error {
switch err {
case context.Canceled:
return etcderrors.ErrCanceled
return errors.ErrCanceled
case context.DeadlineExceeded:
s.leadTimeMu.RLock()
@ -2286,7 +2286,7 @@ func (s *EtcdServer) parseProposeCtxErr(err error, start time.Time) error {
s.leadTimeMu.RUnlock()
prevLeadLost := curLeadElected.Add(-2 * time.Duration(s.Cfg.ElectionTicks) * time.Duration(s.Cfg.TickMs) * time.Millisecond)
if start.After(prevLeadLost) && start.Before(curLeadElected) {
return etcderrors.ErrTimeoutDueToLeaderFail
return errors.ErrTimeoutDueToLeaderFail
}
lead := types.ID(s.getLead())
switch lead {
@ -2294,14 +2294,14 @@ func (s *EtcdServer) parseProposeCtxErr(err error, start time.Time) error {
// TODO: return error to specify it happens because the cluster does not have leader now
case s.MemberId():
if !isConnectedToQuorumSince(s.r.transport, start, s.MemberId(), s.cluster.Members()) {
return etcderrors.ErrTimeoutDueToConnectionLost
return errors.ErrTimeoutDueToConnectionLost
}
default:
if !isConnectedSince(s.r.transport, start, lead) {
return etcderrors.ErrTimeoutDueToConnectionLost
return errors.ErrTimeoutDueToConnectionLost
}
}
return etcderrors.ErrTimeout
return errors.ErrTimeout
default:
return err

22
server/etcdserver/server_test.go
View File

@ -48,7 +48,7 @@ import (
"go.etcd.io/etcd/server/v3/etcdserver/api/v2store"
apply2 "go.etcd.io/etcd/server/v3/etcdserver/apply"
"go.etcd.io/etcd/server/v3/etcdserver/cindex"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/server/v3/lease"
"go.etcd.io/etcd/server/v3/mock/mockstorage"
"go.etcd.io/etcd/server/v3/mock/mockstore"
@ -97,7 +97,7 @@ func TestDoLocalAction(t *testing.T) {
},
{
pb.Request{Method: "BADMETHOD", ID: 1},
Response{}, etcderrors.ErrUnknownMethod, []testutil.Action{},
Response{}, errors.ErrUnknownMethod, []testutil.Action{},
},
}
for i, tt := range tests {
@ -463,7 +463,7 @@ func TestApplyRequest(t *testing.T) {
// Unknown method - error
{
pb.Request{Method: "BADMETHOD", ID: 1},
Response{Err: etcderrors.ErrUnknownMethod},
Response{Err: errors.ErrUnknownMethod},
[]testutil.Action{},
},
}
@ -830,8 +830,8 @@ func TestDoProposalCancelled(t *testing.T) {
cancel()
_, err := srv.Do(ctx, pb.Request{Method: "PUT"})
if err != etcderrors.ErrCanceled {
t.Fatalf("err = %v, want %v", err, etcderrors.ErrCanceled)
if err != errors.ErrCanceled {
t.Fatalf("err = %v, want %v", err, errors.ErrCanceled)
}
w := []testutil.Action{{Name: "Register"}, {Name: "Trigger"}}
if !reflect.DeepEqual(wt.Action(), w) {
@ -853,8 +853,8 @@ func TestDoProposalTimeout(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 0)
_, err := srv.Do(ctx, pb.Request{Method: "PUT"})
cancel()
if err != etcderrors.ErrTimeout {
t.Fatalf("err = %v, want %v", err, etcderrors.ErrTimeout)
if err != errors.ErrTimeout {
t.Fatalf("err = %v, want %v", err, errors.ErrTimeout)
}
}
@ -872,8 +872,8 @@ func TestDoProposalStopped(t *testing.T) {
srv.stopping = make(chan struct{})
close(srv.stopping)
_, err := srv.Do(context.Background(), pb.Request{Method: "PUT", ID: 1})
if err != etcderrors.ErrStopped {
t.Errorf("err = %v, want %v", err, etcderrors.ErrStopped)
if err != errors.ErrStopped {
t.Errorf("err = %v, want %v", err, errors.ErrStopped)
}
}
@ -1944,14 +1944,14 @@ func TestWaitAppliedIndex(t *testing.T) {
action: func(s *EtcdServer) {
s.stopping <- struct{}{}
},
ExpectedError: etcderrors.ErrStopped,
ExpectedError: errors.ErrStopped,
},
{
name: "Timed out waiting for the applied index",
appliedIndex: 10,
committedIndex: 12,
action: nil,
ExpectedError: etcderrors.ErrTimeoutWaitAppliedIndex,
ExpectedError: errors.ErrTimeoutWaitAppliedIndex,
},
}
for _, tc := range cases {

6
server/etcdserver/txn/txn.go
View File

@ -23,7 +23,7 @@ import (
"go.etcd.io/etcd/api/v3/mvccpb"
"go.etcd.io/etcd/pkg/v3/traceutil"
"go.etcd.io/etcd/server/v3/auth"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/server/v3/lease"
"go.etcd.io/etcd/server/v3/storage/mvcc"
"go.uber.org/zap"
@ -65,7 +65,7 @@ func Put(ctx context.Context, lg *zap.Logger, lessor lease.Lessor, kv mvcc.KV, t
if p.IgnoreValue || p.IgnoreLease {
if rr == nil || len(rr.KVs) == 0 {
// ignore_{lease,value} flag expects previous key-value pair
return nil, nil, etcderrors.ErrKeyNotFound
return nil, nil, errors.ErrKeyNotFound
}
}
if p.IgnoreValue {
@ -378,7 +378,7 @@ func checkRequestPut(rv mvcc.ReadView, lessor lease.Lessor, reqOp *pb.RequestOp)
return err
}
if rr == nil || len(rr.KVs) == 0 {
return etcderrors.ErrKeyNotFound
return errors.ErrKeyNotFound
}
}
if lease.LeaseID(req.Lease) != lease.NoLease {

6
server/etcdserver/v2_server.go
View File

@ -21,7 +21,7 @@ import (
pb "go.etcd.io/etcd/api/v3/etcdserverpb"
"go.etcd.io/etcd/server/v3/etcdserver/api/membership"
"go.etcd.io/etcd/server/v3/etcdserver/api/v2store"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
)
type RequestV2 pb.Request
@ -117,7 +117,7 @@ func (a *reqV2HandlerEtcdServer) processRaftRequest(ctx context.Context, r *Requ
return Response{}, a.s.parseProposeCtxErr(ctx.Err(), start)
case <-a.s.stopping:
}
return Response{}, etcderrors.ErrStopped
return Response{}, errors.ErrStopped
}
func (s *EtcdServer) Do(ctx context.Context, r pb.Request) (Response, error) {
@ -158,7 +158,7 @@ func (r *RequestV2) Handle(ctx context.Context, v2api RequestV2Handler) (Respons
case "HEAD":
return v2api.Head(ctx, r)
}
return Response{}, etcderrors.ErrUnknownMethod
return Response{}, errors.ErrUnknownMethod
}
func (r *RequestV2) String() string {

40
server/etcdserver/v3_server.go
View File

@ -29,7 +29,7 @@ import (
"go.etcd.io/etcd/server/v3/auth"
"go.etcd.io/etcd/server/v3/etcdserver/api/membership"
apply2 "go.etcd.io/etcd/server/v3/etcdserver/apply"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/server/v3/etcdserver/txn"
"go.etcd.io/etcd/server/v3/lease"
"go.etcd.io/etcd/server/v3/lease/leasehttp"
@ -260,9 +260,9 @@ func (s *EtcdServer) waitAppliedIndex() error {
select {
case <-s.ApplyWait():
case <-s.stopping:
return etcderrors.ErrStopped
return errors.ErrStopped
case <-time.After(applyTimeout):
return etcderrors.ErrTimeoutWaitAppliedIndex
return errors.ErrTimeoutWaitAppliedIndex
}
return nil
@ -312,9 +312,9 @@ func (s *EtcdServer) LeaseRenew(ctx context.Context, id lease.LeaseID) (int64, e
}
if cctx.Err() == context.DeadlineExceeded {
return -1, etcderrors.ErrTimeout
return -1, errors.ErrTimeout
}
return -1, etcderrors.ErrCanceled
return -1, errors.ErrCanceled
}
func (s *EtcdServer) LeaseTimeToLive(ctx context.Context, r *pb.LeaseTimeToLiveRequest) (*pb.LeaseTimeToLiveResponse, error) {
@ -362,9 +362,9 @@ func (s *EtcdServer) LeaseTimeToLive(ctx context.Context, r *pb.LeaseTimeToLiveR
}
if cctx.Err() == context.DeadlineExceeded {
return nil, etcderrors.ErrTimeout
return nil, errors.ErrTimeout
}
return nil, etcderrors.ErrCanceled
return nil, errors.ErrCanceled
}
func (s *EtcdServer) newHeader() *pb.ResponseHeader {
@ -395,13 +395,13 @@ func (s *EtcdServer) waitLeader(ctx context.Context) (*membership.Member, error)
case <-time.After(dur):
leader = s.cluster.Member(s.Leader())
case <-s.stopping:
return nil, etcderrors.ErrStopped
return nil, errors.ErrStopped
case <-ctx.Done():
return nil, etcderrors.ErrNoLeader
return nil, errors.ErrNoLeader
}
}
if len(leader.PeerURLs) == 0 {
return nil, etcderrors.ErrNoLeader
return nil, errors.ErrNoLeader
}
return leader, nil
}
@ -660,7 +660,7 @@ func (s *EtcdServer) processInternalRaftRequestOnce(ctx context.Context, r pb.In
ai := s.getAppliedIndex()
ci := s.getCommittedIndex()
if ci > ai+maxGapBetweenApplyAndCommitIndex {
return nil, etcderrors.ErrTooManyRequests
return nil, errors.ErrTooManyRequests
}
r.Header = &pb.RequestHeader{
@ -685,7 +685,7 @@ func (s *EtcdServer) processInternalRaftRequestOnce(ctx context.Context, r pb.In
}
if len(data) > int(s.Cfg.MaxRequestBytes) {
return nil, etcderrors.ErrRequestTooLarge
return nil, errors.ErrRequestTooLarge
}
id := r.ID
@ -715,7 +715,7 @@ func (s *EtcdServer) processInternalRaftRequestOnce(ctx context.Context, r pb.In
s.w.Trigger(id, nil) // GC wait
return nil, s.parseProposeCtxErr(cctx.Err(), start)
case <-s.done:
return nil, etcderrors.ErrStopped
return nil, errors.ErrStopped
}
}
@ -776,7 +776,7 @@ func (s *EtcdServer) linearizableReadLoop() {
}
func isStopped(err error) bool {
return err == raft.ErrStopped || err == etcderrors.ErrStopped
return err == raft.ErrStopped || err == errors.ErrStopped
}
func (s *EtcdServer) requestCurrentIndex(leaderChangedNotifier <-chan struct{}, requestId uint64) (uint64, error) {
@ -817,7 +817,7 @@ func (s *EtcdServer) requestCurrentIndex(leaderChangedNotifier <-chan struct{},
case <-leaderChangedNotifier:
readIndexFailed.Inc()
// return a retryable error.
return 0, etcderrors.ErrLeaderChanged
return 0, errors.ErrLeaderChanged
case <-firstCommitInTermNotifier:
firstCommitInTermNotifier = s.firstCommitInTerm.Receive()
lg.Info("first commit in current term: resending ReadIndex request")
@ -845,9 +845,9 @@ func (s *EtcdServer) requestCurrentIndex(leaderChangedNotifier <-chan struct{},
zap.Duration("timeout", s.Cfg.ReqTimeout()),
)
slowReadIndex.Inc()
return 0, etcderrors.ErrTimeout
return 0, errors.ErrTimeout
case <-s.stopping:
return 0, etcderrors.ErrStopped
return 0, errors.ErrStopped
}
}
}
@ -898,7 +898,7 @@ func (s *EtcdServer) linearizableReadNotify(ctx context.Context) error {
case <-ctx.Done():
return ctx.Err()
case <-s.done:
return etcderrors.ErrStopped
return errors.ErrStopped
}
}
@ -923,7 +923,7 @@ func (s *EtcdServer) Downgrade(ctx context.Context, r *pb.DowngradeRequest) (*pb
case pb.DowngradeRequest_CANCEL:
return s.downgradeCancel(ctx)
default:
return nil, etcderrors.ErrUnknownMethod
return nil, errors.ErrUnknownMethod
}
}
@ -937,7 +937,7 @@ func (s *EtcdServer) downgradeValidate(ctx context.Context, v string) (*pb.Downg
cv := s.ClusterVersion()
if cv == nil {
return nil, etcderrors.ErrClusterVersionUnavailable
return nil, errors.ErrClusterVersionUnavailable
}
resp.Version = version.Cluster(cv.String())
err = s.Version().DowngradeValidate(ctx, targetVersion)

6
tests/functional/tester/stresser_key.go
View File

@ -26,7 +26,7 @@ import (
"go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
"go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/raft/v3"
"go.etcd.io/etcd/server/v3/etcdserver/etcderrors"
"go.etcd.io/etcd/server/v3/etcdserver/errors"
"go.etcd.io/etcd/tests/v3/functional/rpcpb"
"go.uber.org/zap"
@ -153,13 +153,13 @@ func (s *keyStresser) isRetryableError(err error) bool {
// as well. We want to keep stressing until the cluster elects a
// new leader and start processing requests again.
return true
case etcderrors.ErrTimeoutDueToLeaderFail.Error(), etcderrors.ErrTimeout.Error():
case errors.ErrTimeoutDueToLeaderFail.Error(), errors.ErrTimeout.Error():
// This retries when request is triggered at the same time as
// leader failure and follower nodes receive time out errors
// from losing their leader. Followers should retry to connect
// to the new leader.
return true
case etcderrors.ErrStopped.Error():
case errors.ErrStopped.Error():
// one of the etcd nodes stopped from failure injection
return true
case rpctypes.ErrNotCapable.Error():