Rename etcdserver/etcderrors package to etcdserver/errors.

server/etcdmain/etcd.go

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

server/etcdserver/api/etcdhttp/peer.go

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

server/etcdserver/api/etcdhttp/utils.go

@@ -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,
+		case errors.ErrTimeoutDueToLeaderFail, errors.ErrTimeoutDueToConnectionLost, errors.ErrNotEnoughStartedMembers,
-			etcderrors.ErrUnhealthy:
+			errors.ErrUnhealthy:
 			if lg != nil {
 				lg.Warn(
 					"v2 response error",

server/etcdserver/api/v3rpc/maintenance.go

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

server/etcdserver/api/v3rpc/util.go

@@ -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.ErrIDRemoved:           rpctypes.ErrGRPCMemberNotFound,
-	membership.ErrIDNotFound:              rpctypes.ErrGRPCMemberNotFound,
+	membership.ErrIDNotFound:          rpctypes.ErrGRPCMemberNotFound,
-	membership.ErrIDExists:                rpctypes.ErrGRPCMemberExist,
+	membership.ErrIDExists:            rpctypes.ErrGRPCMemberExist,
-	membership.ErrPeerURLexists:           rpctypes.ErrGRPCPeerURLExist,
+	membership.ErrPeerURLexists:       rpctypes.ErrGRPCPeerURLExist,
-	membership.ErrMemberNotLearner:        rpctypes.ErrGRPCMemberNotLearner,
+	membership.ErrMemberNotLearner:    rpctypes.ErrGRPCMemberNotLearner,
-	membership.ErrTooManyLearners:         rpctypes.ErrGRPCTooManyLearners,
+	membership.ErrTooManyLearners:     rpctypes.ErrGRPCTooManyLearners,
-	etcderrors.ErrNotEnoughStartedMembers: rpctypes.ErrMemberNotEnoughStarted,
+	errors.ErrNotEnoughStartedMembers: rpctypes.ErrMemberNotEnoughStarted,
-	etcderrors.ErrLearnerNotReady:         rpctypes.ErrGRPCLearnerNotReady,
+	errors.ErrLearnerNotReady:         rpctypes.ErrGRPCLearnerNotReady,
 
-	mvcc.ErrCompacted:             rpctypes.ErrGRPCCompacted,
+	mvcc.ErrCompacted:         rpctypes.ErrGRPCCompacted,
-	mvcc.ErrFutureRev:             rpctypes.ErrGRPCFutureRev,
+	mvcc.ErrFutureRev:         rpctypes.ErrGRPCFutureRev,
-	etcderrors.ErrRequestTooLarge: rpctypes.ErrGRPCRequestTooLarge,
+	errors.ErrRequestTooLarge: rpctypes.ErrGRPCRequestTooLarge,
-	etcderrors.ErrNoSpace:         rpctypes.ErrGRPCNoSpace,
+	errors.ErrNoSpace:         rpctypes.ErrGRPCNoSpace,
-	etcderrors.ErrTooManyRequests: rpctypes.ErrTooManyRequests,
+	errors.ErrTooManyRequests: rpctypes.ErrTooManyRequests,
 
-	etcderrors.ErrNoLeader:                   rpctypes.ErrGRPCNoLeader,
+	errors.ErrNoLeader:                   rpctypes.ErrGRPCNoLeader,
-	etcderrors.ErrNotLeader:                  rpctypes.ErrGRPCNotLeader,
+	errors.ErrNotLeader:                  rpctypes.ErrGRPCNotLeader,
-	etcderrors.ErrLeaderChanged:              rpctypes.ErrGRPCLeaderChanged,
+	errors.ErrLeaderChanged:              rpctypes.ErrGRPCLeaderChanged,
-	etcderrors.ErrStopped:                    rpctypes.ErrGRPCStopped,
+	errors.ErrStopped:                    rpctypes.ErrGRPCStopped,
-	etcderrors.ErrTimeout:                    rpctypes.ErrGRPCTimeout,
+	errors.ErrTimeout:                    rpctypes.ErrGRPCTimeout,
-	etcderrors.ErrTimeoutDueToLeaderFail:     rpctypes.ErrGRPCTimeoutDueToLeaderFail,
+	errors.ErrTimeoutDueToLeaderFail:     rpctypes.ErrGRPCTimeoutDueToLeaderFail,
-	etcderrors.ErrTimeoutDueToConnectionLost: rpctypes.ErrGRPCTimeoutDueToConnectionLost,
+	errors.ErrTimeoutDueToConnectionLost: rpctypes.ErrGRPCTimeoutDueToConnectionLost,
-	etcderrors.ErrTimeoutWaitAppliedIndex:    rpctypes.ErrGRPCTimeoutWaitAppliedIndex,
+	errors.ErrTimeoutWaitAppliedIndex:    rpctypes.ErrGRPCTimeoutWaitAppliedIndex,
-	etcderrors.ErrUnhealthy:                  rpctypes.ErrGRPCUnhealthy,
+	errors.ErrUnhealthy:                  rpctypes.ErrGRPCUnhealthy,
-	etcderrors.ErrKeyNotFound:                rpctypes.ErrGRPCKeyNotFound,
+	errors.ErrKeyNotFound:                rpctypes.ErrGRPCKeyNotFound,
-	etcderrors.ErrCorrupt:                    rpctypes.ErrGRPCCorrupt,
+	errors.ErrCorrupt:                    rpctypes.ErrGRPCCorrupt,
-	etcderrors.ErrBadLeaderTransferee:        rpctypes.ErrGRPCBadLeaderTransferee,
+	errors.ErrBadLeaderTransferee:        rpctypes.ErrGRPCBadLeaderTransferee,
 
-	etcderrors.ErrClusterVersionUnavailable:   rpctypes.ErrGRPCClusterVersionUnavailable,
+	errors.ErrClusterVersionUnavailable:      rpctypes.ErrGRPCClusterVersionUnavailable,
-	etcderrors.ErrWrongDowngradeVersionFormat: rpctypes.ErrGRPCWrongDowngradeVersionFormat,
+	errors.ErrWrongDowngradeVersionFormat:    rpctypes.ErrGRPCWrongDowngradeVersionFormat,
-	version.ErrInvalidDowngradeTargetVersion:  rpctypes.ErrGRPCInvalidDowngradeTargetVersion,
+	version.ErrInvalidDowngradeTargetVersion: rpctypes.ErrGRPCInvalidDowngradeTargetVersion,
-	version.ErrDowngradeInProcess:             rpctypes.ErrGRPCDowngradeInProcess,
+	version.ErrDowngradeInProcess:            rpctypes.ErrGRPCDowngradeInProcess,
-	version.ErrNoInflightDowngrade:            rpctypes.ErrGRPCNoInflightDowngrade,
+	version.ErrNoInflightDowngrade:           rpctypes.ErrGRPCNoInflightDowngrade,
 
 	lease.ErrLeaseNotFound:    rpctypes.ErrGRPCLeaseNotFound,
 	lease.ErrLeaseExists:      rpctypes.ErrGRPCLeaseExist,

server/etcdserver/apply/apply.go

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

server/etcdserver/apply/corrupt.go

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

server/etcdserver/apply_v2.go

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

server/etcdserver/bootstrap.go

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

server/etcdserver/cluster_util.go

@@ -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()) {
+		if strings.Contains(string(b), errors.ErrLearnerNotReady.Error()) {
-			return nil, etcderrors.ErrLearnerNotReady
+			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

server/etcdserver/errors/errors.go

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

server/etcdserver/server.go

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

server/etcdserver/server_test.go

@@ -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 {
+	if err != errors.ErrCanceled {
-		t.Fatalf("err = %v, want %v", err, etcderrors.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 {
+	if err != errors.ErrTimeout {
-		t.Fatalf("err = %v, want %v", err, etcderrors.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 {
+	if err != errors.ErrStopped {
-		t.Errorf("err = %v, want %v", err, etcderrors.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 {

server/etcdserver/txn/txn.go

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

server/etcdserver/v2_server.go

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

server/etcdserver/v3_server.go

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

tests/functional/tester/stresser_key.go

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