Documentation

Overview

    Package etcdserver defines how etcd servers interact and store their states.

    Index

    Constants

    View Source
    const (
    	// DefaultQuotaBytes is the number of bytes the backend Size may
    	// consume before exceeding the space quota.
    	DefaultQuotaBytes = int64(2 * 1024 * 1024 * 1024) // 2GB
    	// MaxQuotaBytes is the maximum number of bytes suggested for a backend
    	// quota. A larger quota may lead to degraded performance.
    	MaxQuotaBytes = int64(8 * 1024 * 1024 * 1024) // 8GB
    )
    View Source
    const (
    	DefaultSnapCount = 100000
    
    	StoreClusterPrefix = "/0"
    	StoreKeysPrefix    = "/1"
    
    	// HealthInterval is the minimum time the cluster should be healthy
    	// before accepting add member requests.
    	HealthInterval = 5 * time.Second
    )

    Variables

    View Source
    var (
    	ErrUnknownMethod              = errors.New("etcdserver: unknown method")
    	ErrStopped                    = errors.New("etcdserver: server stopped")
    	ErrCanceled                   = errors.New("etcdserver: request cancelled")
    	ErrTimeout                    = errors.New("etcdserver: request timed out")
    	ErrTimeoutDueToLeaderFail     = errors.New("etcdserver: request timed out, possibly due to previous leader failure")
    	ErrTimeoutDueToConnectionLost = errors.New("etcdserver: request timed out, possibly due to connection lost")
    	ErrTimeoutLeaderTransfer      = errors.New("etcdserver: request timed out, leader transfer took too long")
    	ErrLeaderChanged              = errors.New("etcdserver: leader changed")
    	ErrNotEnoughStartedMembers    = errors.New("etcdserver: re-configuration failed due to not enough started members")
    	ErrNoLeader                   = errors.New("etcdserver: no leader")
    	ErrNotLeader                  = errors.New("etcdserver: not leader")
    	ErrRequestTooLarge            = errors.New("etcdserver: request is too large")
    	ErrNoSpace                    = errors.New("etcdserver: no space")
    	ErrTooManyRequests            = errors.New("etcdserver: too many requests")
    	ErrUnhealthy                  = errors.New("etcdserver: unhealthy cluster")
    	ErrKeyNotFound                = errors.New("etcdserver: key not found")
    	ErrCorrupt                    = errors.New("etcdserver: corrupt cluster")
    )

    Functions

    func GetClusterFromRemotePeers

    func GetClusterFromRemotePeers(urls []string, rt http.RoundTripper) (*membership.RaftCluster, error)

      GetClusterFromRemotePeers takes a set of URLs representing etcd peers, and attempts to construct a Cluster by accessing the members endpoint on one of these URLs. The first URL to provide a response is used. If no URLs provide a response, or a Cluster cannot be successfully created from a received response, an error is returned. Each request has a 10-second timeout. Because the upper limit of TTL is 5s, 10 second is enough for building connection and finishing request.

      Types

      type ApplierV2

      type ApplierV2 interface {
      	Delete(r *RequestV2) Response
      	Post(r *RequestV2) Response
      	Put(r *RequestV2) Response
      	QGet(r *RequestV2) Response
      	Sync(r *RequestV2) Response
      }

        ApplierV2 is the interface for processing V2 raft messages

        func NewApplierV2

        func NewApplierV2(s store.Store, c *membership.RaftCluster) ApplierV2

        type Authenticator

        type Authenticator interface {
        	AuthEnable(ctx context.Context, r *pb.AuthEnableRequest) (*pb.AuthEnableResponse, error)
        	AuthDisable(ctx context.Context, r *pb.AuthDisableRequest) (*pb.AuthDisableResponse, error)
        	Authenticate(ctx context.Context, r *pb.AuthenticateRequest) (*pb.AuthenticateResponse, error)
        	UserAdd(ctx context.Context, r *pb.AuthUserAddRequest) (*pb.AuthUserAddResponse, error)
        	UserDelete(ctx context.Context, r *pb.AuthUserDeleteRequest) (*pb.AuthUserDeleteResponse, error)
        	UserChangePassword(ctx context.Context, r *pb.AuthUserChangePasswordRequest) (*pb.AuthUserChangePasswordResponse, error)
        	UserGrantRole(ctx context.Context, r *pb.AuthUserGrantRoleRequest) (*pb.AuthUserGrantRoleResponse, error)
        	UserGet(ctx context.Context, r *pb.AuthUserGetRequest) (*pb.AuthUserGetResponse, error)
        	UserRevokeRole(ctx context.Context, r *pb.AuthUserRevokeRoleRequest) (*pb.AuthUserRevokeRoleResponse, error)
        	RoleAdd(ctx context.Context, r *pb.AuthRoleAddRequest) (*pb.AuthRoleAddResponse, error)
        	RoleGrantPermission(ctx context.Context, r *pb.AuthRoleGrantPermissionRequest) (*pb.AuthRoleGrantPermissionResponse, error)
        	RoleGet(ctx context.Context, r *pb.AuthRoleGetRequest) (*pb.AuthRoleGetResponse, error)
        	RoleRevokePermission(ctx context.Context, r *pb.AuthRoleRevokePermissionRequest) (*pb.AuthRoleRevokePermissionResponse, error)
        	RoleDelete(ctx context.Context, r *pb.AuthRoleDeleteRequest) (*pb.AuthRoleDeleteResponse, error)
        	UserList(ctx context.Context, r *pb.AuthUserListRequest) (*pb.AuthUserListResponse, error)
        	RoleList(ctx context.Context, r *pb.AuthRoleListRequest) (*pb.AuthRoleListResponse, error)
        }

        type DiscoveryError

        type DiscoveryError struct {
        	Op  string
        	Err error
        }

        func (DiscoveryError) Error

        func (e DiscoveryError) Error() string

        type EtcdServer

        type EtcdServer struct {
        	Cfg ServerConfig
        
        	SyncTicker *time.Ticker
        	// contains filtered or unexported fields
        }

          EtcdServer is the production implementation of the Server interface

          func NewServer

          func NewServer(cfg ServerConfig) (srv *EtcdServer, err error)

            NewServer creates a new EtcdServer from the supplied configuration. The configuration is considered static for the lifetime of the EtcdServer.

            func (*EtcdServer) AddMember

            func (s *EtcdServer) AddMember(ctx context.Context, memb membership.Member) ([]*membership.Member, error)

            func (*EtcdServer) Alarm

            func (*EtcdServer) Alarms

            func (s *EtcdServer) Alarms() []*pb.AlarmMember

            func (*EtcdServer) ApplyWait

            func (s *EtcdServer) ApplyWait() <-chan struct{}

            func (*EtcdServer) AuthDisable

            func (*EtcdServer) AuthEnable

            func (*EtcdServer) AuthInfoFromCtx

            func (s *EtcdServer) AuthInfoFromCtx(ctx context.Context) (*auth.AuthInfo, error)

            func (*EtcdServer) AuthStore

            func (s *EtcdServer) AuthStore() auth.AuthStore

            func (*EtcdServer) Authenticate

            func (*EtcdServer) Backend

            func (s *EtcdServer) Backend() backend.Backend

            func (*EtcdServer) CheckInitialHashKV

            func (s *EtcdServer) CheckInitialHashKV() error

              CheckInitialHashKV compares initial hash values with its peers before serving any peer/client traffic. Only mismatch when hashes are different at requested revision, with same compact revision.

              func (*EtcdServer) ClientCertAuthEnabled

              func (s *EtcdServer) ClientCertAuthEnabled() bool

              func (*EtcdServer) Cluster

              func (s *EtcdServer) Cluster() api.Cluster

              func (*EtcdServer) ClusterVersion

              func (s *EtcdServer) ClusterVersion() *semver.Version

              func (*EtcdServer) Compact

              func (*EtcdServer) CutPeer

              func (s *EtcdServer) CutPeer(id types.ID)

                CutPeer drops messages to the specified peer.

                func (*EtcdServer) DeleteRange

                func (*EtcdServer) Do

                func (s *EtcdServer) Do(ctx context.Context, r pb.Request) (Response, error)

                func (*EtcdServer) HardStop

                func (s *EtcdServer) HardStop()

                  HardStop stops the server without coordination with other members in the cluster.

                  func (*EtcdServer) ID

                  func (s *EtcdServer) ID() types.ID

                  func (*EtcdServer) Index

                  func (s *EtcdServer) Index() uint64

                  func (*EtcdServer) IsIDRemoved

                  func (s *EtcdServer) IsIDRemoved(id uint64) bool

                  func (*EtcdServer) KV

                  func (*EtcdServer) Lead

                  func (s *EtcdServer) Lead() uint64

                    Lead is only for testing purposes. TODO: add Raft server interface to expose raft related info: Index, Term, Lead, Committed, Applied, LastIndex, etc.

                    func (*EtcdServer) Leader

                    func (s *EtcdServer) Leader() types.ID

                    func (*EtcdServer) LeaderStats

                    func (s *EtcdServer) LeaderStats() []byte

                    func (*EtcdServer) LeaseGrant

                    func (*EtcdServer) LeaseHandler

                    func (s *EtcdServer) LeaseHandler() http.Handler

                    func (*EtcdServer) LeaseLeases

                    func (*EtcdServer) LeaseRenew

                    func (s *EtcdServer) LeaseRenew(ctx context.Context, id lease.LeaseID) (int64, error)

                    func (*EtcdServer) LeaseRevoke

                    func (*EtcdServer) LeaseTimeToLive

                    func (*EtcdServer) MendPeer

                    func (s *EtcdServer) MendPeer(id types.ID)

                      MendPeer recovers the message dropping behavior of the given peer.

                      func (*EtcdServer) MoveLeader

                      func (s *EtcdServer) MoveLeader(ctx context.Context, lead, transferee uint64) error

                        MoveLeader transfers the leader to the given transferee.

                        func (*EtcdServer) PauseSending

                        func (s *EtcdServer) PauseSending()

                        func (*EtcdServer) Process

                        func (s *EtcdServer) Process(ctx context.Context, m raftpb.Message) error

                          Process takes a raft message and applies it to the server's raft state machine, respecting any timeout of the given context.

                          func (*EtcdServer) Put

                          func (s *EtcdServer) Put(ctx context.Context, r *pb.PutRequest) (*pb.PutResponse, error)

                          func (*EtcdServer) RaftHandler

                          func (s *EtcdServer) RaftHandler() http.Handler

                          func (*EtcdServer) Range

                          func (*EtcdServer) ReadyNotify

                          func (s *EtcdServer) ReadyNotify() <-chan struct{}

                            ReadyNotify returns a channel that will be closed when the server is ready to serve client requests

                            func (*EtcdServer) RemoveMember

                            func (s *EtcdServer) RemoveMember(ctx context.Context, id uint64) ([]*membership.Member, error)

                            func (*EtcdServer) ReportSnapshot

                            func (s *EtcdServer) ReportSnapshot(id uint64, status raft.SnapshotStatus)

                              ReportSnapshot reports snapshot sent status to the raft state machine, and clears the used snapshot from the snapshot store.

                              func (*EtcdServer) ReportUnreachable

                              func (s *EtcdServer) ReportUnreachable(id uint64)

                              func (*EtcdServer) ResumeSending

                              func (s *EtcdServer) ResumeSending()

                              func (*EtcdServer) RoleAdd

                              func (*EtcdServer) RoleDelete

                              func (*EtcdServer) RoleGet

                              func (*EtcdServer) RoleList

                              func (*EtcdServer) SelfStats

                              func (s *EtcdServer) SelfStats() []byte

                              func (*EtcdServer) Start

                              func (s *EtcdServer) Start()

                                Start performs any initialization of the Server necessary for it to begin serving requests. It must be called before Do or Process. Start must be non-blocking; any long-running server functionality should be implemented in goroutines.

                                func (*EtcdServer) Stop

                                func (s *EtcdServer) Stop()

                                  Stop stops the server gracefully, and shuts down the running goroutine. Stop should be called after a Start(s), otherwise it will block forever. When stopping leader, Stop transfers its leadership to one of its peers before stopping the server. Stop terminates the Server and performs any necessary finalization. Do and Process cannot be called after Stop has been invoked.

                                  func (*EtcdServer) StopNotify

                                  func (s *EtcdServer) StopNotify() <-chan struct{}

                                    StopNotify returns a channel that receives a empty struct when the server is stopped.

                                    func (*EtcdServer) StoreStats

                                    func (s *EtcdServer) StoreStats() []byte

                                    func (*EtcdServer) Term

                                    func (s *EtcdServer) Term() uint64

                                    func (*EtcdServer) TransferLeadership

                                    func (s *EtcdServer) TransferLeadership() error

                                      TransferLeadership transfers the leader to the chosen transferee.

                                      func (*EtcdServer) Txn

                                      func (s *EtcdServer) Txn(ctx context.Context, r *pb.TxnRequest) (*pb.TxnResponse, error)

                                      func (*EtcdServer) UpdateMember

                                      func (s *EtcdServer) UpdateMember(ctx context.Context, memb membership.Member) ([]*membership.Member, error)

                                      func (*EtcdServer) UserAdd

                                      func (*EtcdServer) UserDelete

                                      func (*EtcdServer) UserGet

                                      func (*EtcdServer) UserGrantRole

                                      func (*EtcdServer) UserList

                                      func (*EtcdServer) UserRevokeRole

                                      func (*EtcdServer) Watchable

                                      func (s *EtcdServer) Watchable() mvcc.WatchableKV

                                        Watchable returns a watchable interface attached to the etcdserver.

                                        type Lessor

                                        type Lessor interface {
                                        	// LeaseGrant sends LeaseGrant request to raft and apply it after committed.
                                        	LeaseGrant(ctx context.Context, r *pb.LeaseGrantRequest) (*pb.LeaseGrantResponse, error)
                                        	// LeaseRevoke sends LeaseRevoke request to raft and apply it after committed.
                                        	LeaseRevoke(ctx context.Context, r *pb.LeaseRevokeRequest) (*pb.LeaseRevokeResponse, error)
                                        
                                        	// LeaseRenew renews the lease with given ID. The renewed TTL is returned. Or an error
                                        	// is returned.
                                        	LeaseRenew(ctx context.Context, id lease.LeaseID) (int64, error)
                                        
                                        	// LeaseTimeToLive retrieves lease information.
                                        	LeaseTimeToLive(ctx context.Context, r *pb.LeaseTimeToLiveRequest) (*pb.LeaseTimeToLiveResponse, error)
                                        
                                        	// LeaseLeases lists all leases.
                                        	LeaseLeases(ctx context.Context, r *pb.LeaseLeasesRequest) (*pb.LeaseLeasesResponse, error)
                                        }

                                        type Quota

                                        type Quota interface {
                                        	// Available judges whether the given request fits within the quota.
                                        	Available(req interface{}) bool
                                        	// Cost computes the charge against the quota for a given request.
                                        	Cost(req interface{}) int
                                        	// Remaining is the amount of charge left for the quota.
                                        	Remaining() int64
                                        }

                                          Quota represents an arbitrary quota against arbitrary requests. Each request costs some charge; if there is not enough remaining charge, then there are too few resources available within the quota to apply the request.

                                          func NewBackendQuota

                                          func NewBackendQuota(s *EtcdServer) Quota

                                          type RaftTimer

                                          type RaftTimer interface {
                                          	Index() uint64
                                          	Term() uint64
                                          }

                                          type RequestV2

                                          type RequestV2 pb.Request

                                          func (*RequestV2) Handle

                                          func (r *RequestV2) Handle(ctx context.Context, v2api RequestV2Handler) (Response, error)

                                            Handle interprets r and performs an operation on s.store according to r.Method and other fields. If r.Method is "POST", "PUT", "DELETE", or a "GET" with Quorum == true, r will be sent through consensus before performing its respective operation. Do will block until an action is performed or there is an error.

                                            func (*RequestV2) String

                                            func (r *RequestV2) String() string

                                            func (*RequestV2) TTLOptions

                                            func (r *RequestV2) TTLOptions() store.TTLOptionSet

                                            type RequestV2Handler

                                            type RequestV2Handler interface {
                                            	Post(ctx context.Context, r *RequestV2) (Response, error)
                                            	Put(ctx context.Context, r *RequestV2) (Response, error)
                                            	Delete(ctx context.Context, r *RequestV2) (Response, error)
                                            	QGet(ctx context.Context, r *RequestV2) (Response, error)
                                            	Get(ctx context.Context, r *RequestV2) (Response, error)
                                            	Head(ctx context.Context, r *RequestV2) (Response, error)
                                            }

                                            func NewStoreRequestV2Handler

                                            func NewStoreRequestV2Handler(s store.Store, applier ApplierV2) RequestV2Handler

                                            type Response

                                            type Response struct {
                                            	Term    uint64
                                            	Index   uint64
                                            	Event   *store.Event
                                            	Watcher store.Watcher
                                            	Err     error
                                            }

                                            type Server

                                            type Server interface {
                                            	// Leader returns the ID of the leader Server.
                                            	Leader() types.ID
                                            
                                            	// AddMember attempts to add a member into the cluster. It will return
                                            	// ErrIDRemoved if member ID is removed from the cluster, or return
                                            	// ErrIDExists if member ID exists in the cluster.
                                            	AddMember(ctx context.Context, memb membership.Member) ([]*membership.Member, error)
                                            	// RemoveMember attempts to remove a member from the cluster. It will
                                            	// return ErrIDRemoved if member ID is removed from the cluster, or return
                                            	// ErrIDNotFound if member ID is not in the cluster.
                                            	RemoveMember(ctx context.Context, id uint64) ([]*membership.Member, error)
                                            	// UpdateMember attempts to update an existing member in the cluster. It will
                                            	// return ErrIDNotFound if the member ID does not exist.
                                            	UpdateMember(ctx context.Context, updateMemb membership.Member) ([]*membership.Member, error)
                                            
                                            	// ClusterVersion is the cluster-wide minimum major.minor version.
                                            	// Cluster version is set to the min version that an etcd member is
                                            	// compatible with when first bootstrap.
                                            	//
                                            	// ClusterVersion is nil until the cluster is bootstrapped (has a quorum).
                                            	//
                                            	// During a rolling upgrades, the ClusterVersion will be updated
                                            	// automatically after a sync. (5 second by default)
                                            	//
                                            	// The API/raft component can utilize ClusterVersion to determine if
                                            	// it can accept a client request or a raft RPC.
                                            	// NOTE: ClusterVersion might be nil when etcd 2.1 works with etcd 2.0 and
                                            	// the leader is etcd 2.0. etcd 2.0 leader will not update clusterVersion since
                                            	// this feature is introduced post 2.0.
                                            	ClusterVersion() *semver.Version
                                            	Cluster() api.Cluster
                                            	Alarms() []*pb.AlarmMember
                                            }

                                            type ServerConfig

                                            type ServerConfig struct {
                                            	Name           string
                                            	DiscoveryURL   string
                                            	DiscoveryProxy string
                                            	ClientURLs     types.URLs
                                            	PeerURLs       types.URLs
                                            	DataDir        string
                                            	// DedicatedWALDir config will make the etcd to write the WAL to the WALDir
                                            	// rather than the dataDir/member/wal.
                                            	DedicatedWALDir     string
                                            	SnapCount           uint64
                                            	MaxSnapFiles        uint
                                            	MaxWALFiles         uint
                                            	InitialPeerURLsMap  types.URLsMap
                                            	InitialClusterToken string
                                            	NewCluster          bool
                                            	ForceNewCluster     bool
                                            	PeerTLSInfo         transport.TLSInfo
                                            
                                            	TickMs        uint
                                            	ElectionTicks int
                                            
                                            	// InitialElectionTickAdvance is true, then local member fast-forwards
                                            	// election ticks to speed up "initial" leader election trigger. This
                                            	// benefits the case of larger election ticks. For instance, cross
                                            	// datacenter deployment may require longer election timeout of 10-second.
                                            	// If true, local node does not need wait up to 10-second. Instead,
                                            	// forwards its election ticks to 8-second, and have only 2-second left
                                            	// before leader election.
                                            	//
                                            	// Major assumptions are that:
                                            	//  - cluster has no active leader thus advancing ticks enables faster
                                            	//    leader election, or
                                            	//  - cluster already has an established leader, and rejoining follower
                                            	//    is likely to receive heartbeats from the leader after tick advance
                                            	//    and before election timeout.
                                            	//
                                            	// However, when network from leader to rejoining follower is congested,
                                            	// and the follower does not receive leader heartbeat within left election
                                            	// ticks, disruptive election has to happen thus affecting cluster
                                            	// availabilities.
                                            	//
                                            	// Disabling this would slow down initial bootstrap process for cross
                                            	// datacenter deployments. Make your own tradeoffs by configuring
                                            	// --initial-election-tick-advance at the cost of slow initial bootstrap.
                                            	//
                                            	// If single-node, it advances ticks regardless.
                                            	//
                                            	// See https://github.com/coreos/etcd/issues/9333 for more detail.
                                            	InitialElectionTickAdvance bool
                                            
                                            	BootstrapTimeout time.Duration
                                            
                                            	AutoCompactionRetention time.Duration
                                            	AutoCompactionMode      string
                                            	QuotaBackendBytes       int64
                                            	MaxTxnOps               uint
                                            
                                            	// MaxRequestBytes is the maximum request size to send over raft.
                                            	MaxRequestBytes uint
                                            
                                            	StrictReconfigCheck bool
                                            
                                            	// ClientCertAuthEnabled is true when cert has been signed by the client CA.
                                            	ClientCertAuthEnabled bool
                                            
                                            	AuthToken string
                                            	TokenTTL  uint
                                            
                                            	// InitialCorruptCheck is true to check data corruption on boot
                                            	// before serving any peer/client traffic.
                                            	InitialCorruptCheck bool
                                            	CorruptCheckTime    time.Duration
                                            
                                            	Debug bool
                                            }

                                              ServerConfig holds the configuration of etcd as taken from the command line or discovery.

                                              func (*ServerConfig) MemberDir

                                              func (c *ServerConfig) MemberDir() string

                                              func (*ServerConfig) Print

                                              func (c *ServerConfig) Print()

                                              func (*ServerConfig) PrintWithInitial

                                              func (c *ServerConfig) PrintWithInitial()

                                              func (*ServerConfig) ReqTimeout

                                              func (c *ServerConfig) ReqTimeout() time.Duration

                                                ReqTimeout returns timeout for request to finish.

                                                func (*ServerConfig) ShouldDiscover

                                                func (c *ServerConfig) ShouldDiscover() bool

                                                func (*ServerConfig) SnapDir

                                                func (c *ServerConfig) SnapDir() string

                                                func (*ServerConfig) VerifyBootstrap

                                                func (c *ServerConfig) VerifyBootstrap() error

                                                  VerifyBootstrap sanity-checks the initial config for bootstrap case and returns an error for things that should never happen.

                                                  func (*ServerConfig) VerifyJoinExisting

                                                  func (c *ServerConfig) VerifyJoinExisting() error

                                                    VerifyJoinExisting sanity-checks the initial config for join existing cluster case and returns an error for things that should never happen.

                                                    func (*ServerConfig) WALDir

                                                    func (c *ServerConfig) WALDir() string

                                                    type ServerPeer

                                                    type ServerPeer interface {
                                                    	ServerV2
                                                    	RaftHandler() http.Handler
                                                    	LeaseHandler() http.Handler
                                                    }

                                                    type ServerV2

                                                    type ServerV2 interface {
                                                    	Server
                                                    	// Do takes a V2 request and attempts to fulfill it, returning a Response.
                                                    	Do(ctx context.Context, r pb.Request) (Response, error)
                                                    	stats.Stats
                                                    	ClientCertAuthEnabled() bool
                                                    }

                                                    type ServerV3

                                                    type ServerV3 interface {
                                                    	Server
                                                    	ID() types.ID
                                                    	RaftTimer
                                                    }

                                                    type Storage

                                                    type Storage interface {
                                                    	// Save function saves ents and state to the underlying stable storage.
                                                    	// Save MUST block until st and ents are on stable storage.
                                                    	Save(st raftpb.HardState, ents []raftpb.Entry) error
                                                    	// SaveSnap function saves snapshot to the underlying stable storage.
                                                    	SaveSnap(snap raftpb.Snapshot) error
                                                    	// Close closes the Storage and performs finalization.
                                                    	Close() error
                                                    	// Release releases the locked wal files older than the provided snapshot.
                                                    	Release(snap raftpb.Snapshot) error
                                                    	// Sync WAL
                                                    	Sync() error
                                                    }

                                                    func NewStorage

                                                    func NewStorage(w *wal.WAL, s *snap.Snapshotter) Storage

                                                    Directories

                                                    Path Synopsis
                                                    api
                                                    Package api manages the capabilities and features that are exposed to clients by the etcd cluster.
                                                    Package api manages the capabilities and features that are exposed to clients by the etcd cluster.
                                                    etcdhttp
                                                    Package etcdhttp implements HTTP transportation layer for etcdserver.
                                                    Package etcdhttp implements HTTP transportation layer for etcdserver.
                                                    v2http
                                                    Package v2http provides etcd client and server implementations.
                                                    Package v2http provides etcd client and server implementations.
                                                    v2http/httptypes
                                                    Package httptypes defines how etcd's HTTP API entities are serialized to and deserialized from JSON.
                                                    Package httptypes defines how etcd's HTTP API entities are serialized to and deserialized from JSON.
                                                    v2v3
                                                    Package v2v3 provides a ServerV2 implementation backed by clientv3.Client.
                                                    Package v2v3 provides a ServerV2 implementation backed by clientv3.Client.
                                                    v3client
                                                    Package v3client provides clientv3 interfaces from an etcdserver.
                                                    Package v3client provides clientv3 interfaces from an etcdserver.
                                                    v3election
                                                    Package v3election provides a v3 election service from an etcdserver.
                                                    Package v3election provides a v3 election service from an etcdserver.
                                                    v3election/v3electionpb/gw
                                                    Package v3electionpb is a reverse proxy.
                                                    Package v3electionpb is a reverse proxy.
                                                    v3lock
                                                    Package v3lock provides a v3 locking service from an etcdserver.
                                                    Package v3lock provides a v3 locking service from an etcdserver.
                                                    v3lock/v3lockpb/gw
                                                    Package v3lockpb is a reverse proxy.
                                                    Package v3lockpb is a reverse proxy.
                                                    v3rpc
                                                    Package v3rpc implements etcd v3 RPC system based on gRPC.
                                                    Package v3rpc implements etcd v3 RPC system based on gRPC.
                                                    v3rpc/rpctypes
                                                    Package rpctypes has types and values shared by the etcd server and client for v3 RPC interaction.
                                                    Package rpctypes has types and values shared by the etcd server and client for v3 RPC interaction.
                                                    Package auth implements etcd authentication.
                                                    Package auth implements etcd authentication.
                                                    gw
                                                    Package etcdserverpb is a reverse proxy.
                                                    Package etcdserverpb is a reverse proxy.
                                                    Package membership describes individual etcd members and clusters of members.
                                                    Package membership describes individual etcd members and clusters of members.
                                                    Package stats defines a standard interface for etcd cluster statistics.
                                                    Package stats defines a standard interface for etcd cluster statistics.