(May一一Y)
(pluiepoco)
第三方登录：这段时间吃鸡游戏老是进不去.老是提示 这个东西_百度知道
这段时间吃鸡游戏老是进不去.老是提示 这个东西
我有更好的答案
you need to upgrade your game client你需要升级你的游戏客户端
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。LG电子为您提供各种各样的智能家用产品，LG智能家电产品让您的生活更轻松更舒适 | LG中国官网
To properly experience our LG.com website, you will need to use an alternate browser or upgrade to a newer version of Internet Explorer (IE9 or greater).
LG.com网站采用响应式网页设计来提供符合您设备屏幕大小的舒适体验。为了让您享受最好的体验，请按照以下说明进行调整。
如果您正在使用IE 8或者更早的版本，您将需要使用一个可替换浏览器，比如Firefox或者Chrome，也可以选择更新到新版IE（IE 9或者更高版本）。
如果您正在使用IE 9或者更高版本，请按照以下步骤关闭您IE浏览器的“兼容性视图设置”
右击浏览器顶部，确定“菜单栏”选项是勾选状态。
从菜单栏选择“工具”然后选择“兼容性视图设置”
在弹出的菜单中取消三个勾选框的选择然后点击“关闭”
您的浏览器窗口将会自动刷新，接下来就可以开
启您的LG之旅了.
LG.com不支持SSLv2，v3，IE 6浏览器需要更改TLS 1.0选项.
1)进入Internet选项
2)选择“高级”选项卡，勾选使用TLS 1.0
（或者使用TLS 1.1,1.2）
* 在更改选项后，如果您仍无法使用HTTPS访问
页面，请联系技术团队 或者第三方技术团队。
您的浏览器似乎在禁用JavaScript，请启用JavaScript 以充分利用从LG网站了解产品和服务。
从一台，到一张
LG PRIME UHD TV
色彩是电视不可或缺的重要元素，它能细腻呈现画面所想表达的深层情感
LG 双o门中门(R)
LG 门中门(R) 让您最爱的食物触手可及。革新冰箱门设计，给您带来便捷生活体验。多次开门取放您最爱的食物，制冷效果依然表现出众。
重新定义洗衣机TWINWash 双擎
滚筒/波轮同步分类2合1洗衣机颠覆传统的洗涤方式分类洗涤 | 同步洗涤 | 节省空间 | 节省时间
蒸汽除菌 健康呵护
蒸汽除菌99.9&#37 ● 蒸汽柔顺 ● 蒸汽清新通过深层渗透衣物的蒸汽，去除细菌和异味，减少褶皱。给婴儿和家人更多健康呵护。
激发你的创造力
独注细微，精益求精
绝美影音旗舰发现无边框之美
LG V30 | LG V30+的无边框合计和18:9的完美平衡比例，让您一手掌控影音旗舰。除了惊艳的外形设计，织纹状保护面让其达到IP68防水防尘等级，甚至通过了美国军事规格掉落测试（MILSTD-810G）
Smart ThinQLG智慧家电APP
LG客服热线
个人顾客 :400-819-9999（全国热线中心）商用顾客 :400-819-0011（电视/显示器商用顾客）周一至周日：08:00 ~ 20:00
周一至周日：08:00 ~ 20:00clientv3 - GoDoc
package clientv3
import "github.com/coreos/etcd/clientv3"
Package clientv3 implements the official Go etcd client for v3.
Create client using `clientv3.New`:
// expect dial time-out on ipv4 blackhole
_, err := clientv3.New(clientv3.Config{
Endpoints:
[]string{""},
DialTimeout: 2 * time.Second
// etcd clientv3 &= v3.2.10, grpc/grpc-go &= v1.7.3
if err == context.DeadlineExceeded {
// handle errors
// etcd clientv3 &= v3.2.9, grpc/grpc-go &= v1.2.1
if err == grpc.ErrClientConnTimeout {
// handle errors
cli, err := clientv3.New(clientv3.Config{
Endpoints:
[]string{"localhost:2379", "localhost:22379", "localhost:32379"},
DialTimeout: 5 * time.Second,
if err != nil {
// handle error!
defer cli.Close()
Make sure to close the client after using it. If the client is not closed, the
connection will have leaky goroutines.
To specify a client request timeout, wrap the context with context.WithTimeout:
ctx, cancel := context.WithTimeout(context.Background(), timeout)
resp, err := kvc.Put(ctx, "sample_key", "sample_value")
if err != nil {
// handle error!
// use the response
The Client has internal state (watchers and leases), so Clients should be reused instead of created as needed.
Clients are safe for concurrent use by multiple goroutines.
etcd client returns 3 types of errors:
1. context error: canceled or deadline exceeded.
2. gRPC status error: e.g. when clock drifts in server-side before client's context deadline exceeded.
3. gRPC error: see
Here is the example code to handle client errors:
resp, err := kvc.Put(ctx, "", "")
if err != nil {
if err == context.Canceled {
// ctx is canceled by another routine
} else if err == context.DeadlineExceeded {
// ctx is attached with a deadline and it exceeded
} else if ev, ok := status.FromError(err); ok {
code := ev.Code()
if code == codes.DeadlineExceeded {
// server-side context might have timed-out first (due to clock skew)
// while original client-side context is not timed-out yet
} else if verr, ok := err.(*v3rpc.ErrEmptyKey); ok {
// process (verr.Errors)
// bad cluster endpoints, which are not etcd servers
go func() { cli.Close() }()
_, err := kvc.Get(ctx, "a")
if err != nil {
// with etcd clientv3 &= v3.3
if err == context.Canceled {
// grpc balancer calls 'Get' with an inflight client.Close
} else if err == grpc.ErrClientConnClosing {
// grpc balancer calls 'Get' after client.Close.
// with etcd clientv3 &= v3.4
if clientv3.IsConnCanceled(err) {
// gRPC client connection is closed
The grpc load balancer is registered statically and is shared across etcd clients.
To enable detailed load balancer logging, set the ETCD_CLIENT_DEBUG environment
E.g. "ETCD_CLIENT_DEBUG=1".
clientv3.SetLogger(grpclog.NewLoggerV2(os.Stderr, os.Stderr, os.Stderr))
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close() // make sure to close the client
_, err = cli.Put(context.TODO(), "foo", "bar")
if err != nil {
log.Fatal(err)
PermReadWrite = .
EventTypeDelete = .
EventTypePut
)const MaxLeaseTTL =
MaxLeaseTTL is the maximum lease TTL value
ErrNoAvailableEndpoints = .("etcdclient: no available endpoints")
ErrOldCluster
= .("etcdclient: old cluster version")
)var DefaultLogConfig = .{
Development: ,
Sampling: &.{
Thereafter: 100,
"json",
EncoderConfig: .(),
OutputPaths:
[]{"stderr"},
ErrorOutputPaths: []{"stderr"},
DefaultLogConfig is the default client logging configuration.
Default log level is "Warn". Use "zap.InfoLevel" for debugging.
Use "/dev/null" for output paths, to discard all logs.
func GetLogger() .
GetLogger returns the current logutil.Logger.
func GetPrefixRangeEnd(prefix )
GetPrefixRangeEnd gets the range end of the prefix.
'Get(foo, WithPrefix())' is equal to 'Get(foo, WithRange(GetPrefixRangeEnd(foo))'.
func IsConnCanceled(err )
IsConnCanceled returns true, if error is from a closed gRPC connection.
func NewLogger(gl .) .
NewLogger returns a new Logger with logutil.Logger.
func RetryAuthClient(c *) .
RetryAuthClient implements a AuthClient.
func RetryClusterClient(c *) .
RetryClusterClient implements a ClusterClient.
func RetryKVClient(c *) .
RetryKVClient implements a KVClient.
func RetryLeaseClient(c *) .
RetryLeaseClient implements a LeaseClient.
func RetryMaintenanceClient(c *, conn *.) .
RetryMaintenanceClient implements a Maintenance.
func SetLogger(l .)
SetLogger sets client-side Logger.
func WithRequireLeader(ctx .) .
WithRequireLeader requires client requests to only succeed
when the cluster has a leader.
type AlarmMember .
type AlarmResponse .
type Auth interface {
// AuthEnable enables auth of an etcd cluster.
AuthEnable(ctx .) (*, )
// AuthDisable disables auth of an etcd cluster.
AuthDisable(ctx .) (*, )
// UserAdd adds a new user to an etcd cluster.
UserAdd(ctx ., name , password ) (*, )
// UserDelete deletes a user from an etcd cluster.
UserDelete(ctx ., name ) (*, )
// UserChangePassword changes a password of a user.
UserChangePassword(ctx ., name , password ) (*, )
// UserGrantRole grants a role to a user.
UserGrantRole(ctx ., user , role ) (*, )
// UserGet gets a detailed information of a user.
UserGet(ctx ., name ) (*, )
// UserList gets a list of all users.
UserList(ctx .) (*, )
// UserRevokeRole revokes a role of a user.
UserRevokeRole(ctx ., name , role ) (*, )
// RoleAdd adds a new role to an etcd cluster.
RoleAdd(ctx ., name ) (*, )
// RoleGrantPermission grants a permission to a role.
RoleGrantPermission(ctx ., name , key, rangeEnd , permType ) (*, )
// RoleGet gets a detailed information of a role.
RoleGet(ctx ., role ) (*, )
// RoleList gets a list of all roles.
RoleList(ctx .) (*, )
// RoleRevokePermission revokes a permission from a role.
RoleRevokePermission(ctx ., role , key, rangeEnd ) (*, )
// RoleDelete deletes a role.
RoleDelete(ctx ., role ) (*, )
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
if _, err = cli.RoleAdd(context.TODO(), "root"); err != nil {
log.Fatal(err)
if _, err = cli.UserAdd(context.TODO(), "root", "123"); err != nil {
log.Fatal(err)
if _, err = cli.UserGrantRole(context.TODO(), "root", "root"); err != nil {
log.Fatal(err)
if _, err = cli.RoleAdd(context.TODO(), "r"); err != nil {
log.Fatal(err)
if _, err = cli.RoleGrantPermission(
context.TODO(),
"r",
// role name
"foo", // key
"zoo", // range end
clientv3.PermissionType(clientv3.PermReadWrite),
); err != nil {
log.Fatal(err)
if _, err = cli.UserAdd(context.TODO(), "u", "123"); err != nil {
log.Fatal(err)
if _, err = cli.UserGrantRole(context.TODO(), "u", "r"); err != nil {
log.Fatal(err)
if _, err = cli.AuthEnable(context.TODO()); err != nil {
log.Fatal(err)
cliAuth, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
"u",
"123",
if err != nil {
log.Fatal(err)
defer cliAuth.Close()
if _, err = cliAuth.Put(context.TODO(), "foo1", "bar"); err != nil {
log.Fatal(err)
_, err = cliAuth.Txn(context.TODO()).
If(clientv3.Compare(clientv3.Value("zoo1"), "&", "abc")).
Then(clientv3.OpPut("zoo1", "XYZ")).
Else(clientv3.OpPut("zoo1", "ABC")).
fmt.Println(err)
// now check the permission with the root account
rootCli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
"root",
"123",
if err != nil {
log.Fatal(err)
defer rootCli.Close()
resp, err := rootCli.RoleGet(context.TODO(), "r")
if err != nil {
log.Fatal(err)
fmt.Printf("user u permission: key %q, range end %q\n", resp.Perm[0].Key, resp.Perm[0].RangeEnd)
if _, err = rootCli.AuthDisable(context.TODO()); err != nil {
log.Fatal(err)
Output:etcdserver: permission denied
user u permission: key "foo", range end "zoo"
func NewAuth(c *)
type AuthDisableResponse .
type AuthEnableResponse .
type AuthRoleAddResponse .
type AuthRoleDeleteResponse .
type AuthRoleGetResponse .
type AuthRoleGrantPermissionResponse .
type AuthRoleListResponse .
type AuthRoleRevokePermissionResponse .
type AuthUserAddResponse .
type AuthUserChangePasswordResponse .
type AuthUserDeleteResponse .
type AuthUserGetResponse .
type AuthUserGrantRoleResponse .
type AuthUserListResponse .
type AuthUserRevokeRoleResponse .
type AuthenticateResponse .
type Client struct {
// Username is a user name for authentication.
// Password is a password for authentication.
// contains filtered or unexported fields
Client provides and manages an etcd v3 client session.
cli, err := clientv3.New(clientv3.Config{
Endpoints: endpoints,
DialOptions: []grpc.DialOption{
grpc.WithUnaryInterceptor(grpcprom.UnaryClientInterceptor),
grpc.WithStreamInterceptor(grpcprom.StreamClientInterceptor),
if err != nil {
log.Fatal(err)
defer cli.Close()
// get a key so it shows up in the metrics as a range RPC
cli.Get(context.TODO(), "test_key")
// listen for all Prometheus metrics
ln, err := net.Listen("tcp", ":0")
if err != nil {
log.Fatal(err)
donec := make(chan struct{})
go func() {
defer close(donec)
http.Serve(ln, promhttp.Handler())
defer func() {
ln.Close()
// make an http request to fetch all Prometheus metrics
url := "http://" + ln.Addr().String() + "/metrics"
resp, err := http.Get(url)
if err != nil {
log.Fatalf("fetch error: %v", err)
b, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
log.Fatalf("fetch error: reading %s: %v", url, err)
// confirm range request in metrics
for _, l := range strings.Split(string(b), "\n") {
if strings.Contains(l, `grpc_client_started_total{grpc_method="Range"`) {
fmt.Println(l)
Output: grpc_client_started_total{grpc_method="Range",grpc_service="etcdserverpb.KV",grpc_type="unary"} 1
func New(cfg ) (*, )
New creates a new etcdv3 client from a given configuration.
func NewCtxClient(ctx .) *
NewCtxClient creates a client with a context but no underlying grpc
connection. This is useful for embedded cases that override the
service interface implementations and do not need connection management.
func NewFromURL(url ) (*, )
NewFromURL creates a new etcdv3 client from a URL.
func NewFromURLs(urls []) (*, )
NewFromURLs creates a new etcdv3 client from URLs.
func (*Client)
func (c *) ActiveConnection() *.
ActiveConnection returns the current in-use connection
func (*Client)
func (c *) Close()
Close shuts down the client's etcd connections.
func (*Client)
func (c *) Ctx() .
Ctx is a context for "out of band" messages (e.g., for sending
"clean up" message when another context is canceled). It is
canceled on client Close().
func (*Client)
func (c *) Dial(endpoint ) (*., )
Dial connects to a single endpoint using the client's config.
func (*Client)
func (c *) Endpoints() (eps [])
Endpoints lists the registered endpoints for the client.
func (*Client)
func (c *) SetEndpoints(eps ...)
SetEndpoints updates client's endpoints.
func (*Client)
func (c *) Sync(ctx .)
Sync synchronizes client's endpoints with the known endpoints from the etcd membership.
type Cluster interface {
// MemberList lists the current cluster membership.
MemberList(ctx .) (*, )
// MemberAdd adds a new member into the cluster.
MemberAdd(ctx ., peerAddrs []) (*, )
// MemberRemove removes an existing member from the cluster.
MemberRemove(ctx ., id ) (*, )
// MemberUpdate updates the peer addresses of the member.
(ctx ., id , peerAddrs []) (*, )
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints[:2],
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
peerURLs := endpoints[2:]
mresp, err := cli.MemberAdd(context.Background(), peerURLs)
if err != nil {
log.Fatal(err)
fmt.Println("added member.PeerURLs:", mresp.Member.PeerURLs)
// added member.PeerURLs: [http://localhost:32380]
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
resp, err := cli.MemberList(context.Background())
if err != nil {
log.Fatal(err)
fmt.Println("members:", len(resp.Members))
Output:members: 3
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints[1:],
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
resp, err := cli.MemberList(context.Background())
if err != nil {
log.Fatal(err)
_, err = cli.MemberRemove(context.Background(), resp.Members[0].ID)
if err != nil {
log.Fatal(err)
func NewCluster(c *)
func NewClusterFromClusterClient(remote ., c *)
type Cmp .
func Compare(cmp , result , v interface{})
func CreateRevision(key )
func LeaseValue(key )
LeaseValue compares a key's LeaseID to a value of your choosing. The empty
LeaseID is 0, otherwise known as `NoLease`.
func ModRevision(key )
func Value(key )
func Version(key )
func (*Cmp)
func (cmp *) KeyBytes() []
KeyBytes returns the byte slice holding with the comparison key.
func (*Cmp)
func (cmp *) ValueBytes() []
ValueBytes returns the byte slice holding the comparison value, if any.
func (*Cmp)
func (cmp *) WithKeyBytes(key [])
WithKeyBytes sets the byte slice for the comparison key.
func (Cmp)
func (cmp ) WithPrefix()
WithPrefix sets the comparison to scan all keys prefixed by the key.
func (Cmp)
func (cmp ) WithRange(end )
WithRange sets the comparison to scan the range [key, end).
func (*Cmp)
func (cmp *) WithValueBytes(v [])
WithValueBytes sets the byte slice for the comparison's value.
type CompactOp struct {
// contains filtered or unexported fields
CompactOp represents a compact operation.
func OpCompact(rev , opts ...)
OpCompact wraps slice CompactOption to create a CompactOp.
type CompactOption func(*)
CompactOption configures compact operation.
func WithCompactPhysical()
WithCompactPhysical makes Compact wait until all compacted entries are
removed from the etcd server's storage.
type CompactResponse .
type CompareResult
type CompareTarget
CompareVersion
CompareCreated
CompareModified
CompareValue
type Config struct {
// Endpoints is a list of URLs.
Endpoints [] `json:"endpoints"`
// AutoSyncInterval is the interval to update endpoints with its latest members.
// 0 disables auto-sync. By default auto-sync is disabled.
AutoSyncInterval . `json:"auto-sync-interval"`
// DialTimeout is the timeout for failing to establish a connection.
. `json:"dial-timeout"`
// DialKeepAliveTime is the time after which client pings the server to see if
// transport is alive.
. `json:"dial-keep-alive-time"`
// DialKeepAliveTimeout is the time that the client waits for a response for the
// keep-alive probe. If the response is not received in this time, the connection is closed.
. `json:"dial-keep-alive-timeout"`
// MaxCallSendMsgSize is the client-side request send limit in bytes.
// If 0, it defaults to 2.0 MiB (2 * 1024 * 1024).
// Make sure that "MaxCallSendMsgSize" & server-side default send/recv limit.
// ("--max-request-bytes" flag to etcd or "embed.Config.MaxRequestBytes").
MaxCallSendMsgSize
// MaxCallRecvMsgSize is the client-side response receive limit.
// If 0, it defaults to "math.MaxInt32", because range response can
// easily exceed request send limits.
// Make sure that "MaxCallRecvMsgSize" &= server-side default send/recv limit.
// ("--max-request-bytes" flag to etcd or "embed.Config.MaxRequestBytes").
MaxCallRecvMsgSize
// TLS holds the client secure credentials, if any.
// Username is a user name for authentication.
`json:"username"`
// Password is a password for authentication.
`json:"password"`
// RejectOldCluster when set will refuse to create a client against an outdated cluster.
RejectOldCluster
`json:"reject-old-cluster"`
// DialOptions is a list of dial options for the grpc client (e.g., for interceptors).
DialOptions [].
// Context is the de it can be used to cancel grpc dial out and
// other operations that do not have an explicit context.
// LogConfig configures client-side logger.
// If nil, use the default logger.
// TODO: configure gRPC logger
LogConfig *.
tlsInfo := transport.TLSInfo{
"/tmp/test-certs/test-name-1.pem",
"/tmp/test-certs/test-name-1-key.pem",
TrustedCAFile: "/tmp/test-certs/trusted-ca.pem",
tlsConfig, err := tlsInfo.ClientConfig()
if err != nil {
log.Fatal(err)
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
tlsConfig,
if err != nil {
log.Fatal(err)
defer cli.Close() // make sure to close the client
_, err = cli.Put(context.TODO(), "foo", "bar")
if err != nil {
log.Fatal(err)
type DefragmentResponse .
type DeleteResponse .
func (*DeleteResponse)
func (resp *) OpResponse()
type ErrKeepAliveHalted struct {
ErrKeepAliveHalted is returned if client keep alive loop halts with an unexpected error.
This usually means that automatic lease renewal via KeepAlive is broken, but KeepAliveOnce will still work as expected.
func (ErrKeepAliveHalted)
func (e ) Error()
type Event .
func (*Event)
func (e *) IsCreate()
IsCreate returns true if the event tells that the key is newly created.
func (*Event)
func (e *) IsModify()
IsModify returns true if the event tells that a new value is put on existing key.
type GetResponse .
func (*GetResponse)
func (resp *) OpResponse()
type HashKVResponse .
type KV interface {
// Put puts a key-value pair into etcd.
// Note that key,value can be plain bytes array and string is
// an immutable representation of that bytes array.
// To get a string of bytes, do string([]byte{0x10, 0x20}).
Put(ctx ., key, val , opts ...) (*, )
// Get retrieves keys.
// By default, Get will return the value for "key", if any.
// When passed WithRange(end), Get will return the keys in the range [key, end).
// When passed WithFromKey(), Get returns keys greater than or equal to key.
// When passed WithRev(rev) with rev & 0, Get retrieves keys a
// if the required revision is compacted, the request will fail with ErrCompacted .
// When passed WithLimit(limit), the number of returned keys is bounded by limit.
// When passed WithSort(), the keys will be sorted.
Get(ctx ., key , opts ...) (*, )
// Delete deletes a key, or optionally using WithRange(end), [key, end).
Delete(ctx ., key , opts ...) (*, )
// Compact compacts etcd KV history before the given rev.
Compact(ctx ., rev , opts ...) (*, )
// Do applies a single Op on KV without a transaction.
// Do is useful when creating arbitrary operations to be issued at a
// the user can range over the operations, calling Do to
// execute them. Get/Put/Delete, on the other hand, are best suited
// for when the operation should be issued at the time of declaration.
Do(ctx ., op ) (, )
// Txn creates a transaction.
Txn(ctx .)
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
resp, err := cli.Get(ctx, "foo")
if err != nil {
log.Fatal(err)
compRev := resp.Header.Revision // specify compact revision of your choice
ctx, cancel = context.WithTimeout(context.Background(), requestTimeout)
_, err = cli.Compact(ctx, compRev)
if err != nil {
log.Fatal(err)
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
defer cancel()
// count keys about to be deleted
gresp, err := cli.Get(ctx, "key", clientv3.WithPrefix())
if err != nil {
log.Fatal(err)
// delete the keys
dresp, err := cli.Delete(ctx, "key", clientv3.WithPrefix())
if err != nil {
log.Fatal(err)
fmt.Println("Deleted all keys:", int64(len(gresp.Kvs)) == dresp.Deleted)
Output:Deleted all keys: true
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
ops := []clientv3.Op{
clientv3.OpPut("put-key", "123"),
clientv3.OpGet("put-key"),
clientv3.OpPut("put-key", "456")}
for _, op := range ops {
if _, err := cli.Do(context.TODO(), op); err != nil {
log.Fatal(err)
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
_, err = cli.Put(context.TODO(), "foo", "bar")
if err != nil {
log.Fatal(err)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
resp, err := cli.Get(ctx, "foo")
if err != nil {
log.Fatal(err)
for _, ev := range resp.Kvs {
fmt.Printf("%s : %s\n", ev.Key, ev.Value)
Output:foo : bar
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
for i := range make([]int, 3) {
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
_, err = cli.Put(ctx, fmt.Sprintf("key_%d", i), "value")
if err != nil {
log.Fatal(err)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
resp, err := cli.Get(ctx, "key", clientv3.WithPrefix(), clientv3.WithSort(clientv3.SortByKey, clientv3.SortDescend))
if err != nil {
log.Fatal(err)
for _, ev := range resp.Kvs {
fmt.Printf("%s : %s\n", ev.Key, ev.Value)
Output:key_2 : value
key_1 : value
key_0 : value
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
presp, err := cli.Put(context.TODO(), "foo", "bar1")
if err != nil {
log.Fatal(err)
_, err = cli.Put(context.TODO(), "foo", "bar2")
if err != nil {
log.Fatal(err)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
resp, err := cli.Get(ctx, "foo", clientv3.WithRev(presp.Header.Revision))
if err != nil {
log.Fatal(err)
for _, ev := range resp.Kvs {
fmt.Printf("%s : %s\n", ev.Key, ev.Value)
Output:foo : bar1
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
_, err = cli.Put(ctx, "sample_key", "sample_value")
if err != nil {
log.Fatal(err)
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
_, err = cli.Put(ctx, "", "sample_value")
if err != nil {
switch err {
case context.Canceled:
fmt.Printf("ctx is canceled by another routine: %v\n", err)
case context.DeadlineExceeded:
fmt.Printf("ctx is attached with a deadline is exceeded: %v\n", err)
case rpctypes.ErrEmptyKey:
fmt.Printf("client-side error: %v\n", err)
fmt.Printf("bad cluster endpoints, which are not etcd servers: %v\n", err)
Output:client-side error: etcdserver: key is not provided
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
kvc := clientv3.NewKV(cli)
_, err = kvc.Put(context.TODO(), "key", "xyz")
if err != nil {
log.Fatal(err)
ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
_, err = kvc.Txn(ctx).
// txn value comparisons are lexical
If(clientv3.Compare(clientv3.Value("key"), "&", "abc")).
// the "Then" runs, since "xyz" & "abc"
Then(clientv3.OpPut("key", "XYZ")).
// the "Else" does not run
Else(clientv3.OpPut("key", "ABC")).
if err != nil {
log.Fatal(err)
gresp, err := kvc.Get(context.TODO(), "key")
if err != nil {
log.Fatal(err)
for _, ev := range gresp.Kvs {
fmt.Printf("%s : %s\n", ev.Key, ev.Value)
Output:key : XYZ
func NewKV(c *)
func NewKVFromKVClient(remote ., c *)
type Lease interface {
// Grant creates a new lease.
Grant(ctx ., ttl ) (*, )
// Revoke revokes the given lease.
Revoke(ctx ., id ) (*, )
// TimeToLive retrieves the lease information of the given lease ID.
(ctx ., id , opts ...) (*, )
// Leases retrieves all leases.
Leases(ctx .) (*, )
// KeepAlive keeps the given lease alive forever. If the keepalive response
// posted to the channel is not consumed immediately, the lease client will
// continue sending keep alive requests to the etcd server at least every
// second until latest response is consumed.
// The returned "LeaseKeepAliveResponse" channel closes if underlying keep
// alive stream is interrupted in some way the client
// given context "ctx" is canceled or timed out. "LeaseKeepAliveResponse"
// from this closed channel is nil.
// If client keep alive loop halts with an unexpected error (e.g. "etcdserver:
// no leader") or canceled by the caller (e.g. context.Canceled), the error
// is returned. Otherwise, it retries.
// TODO(v4.0): post errors to last keep alive message before closing
// (see https://github.com/coreos/etcd/pull/7866)
KeepAlive(ctx ., id ) (&-chan *, )
// KeepAliveOnce renews the lease once. The response corresponds to the
// first message from calling KeepAlive. If the response has a recoverable
// error, KeepAliveOnce will retry the RPC with a new keep alive message.
// In most of the cases, Keepalive should be used instead of KeepAliveOnce.
KeepAliveOnce(ctx ., id ) (*, )
// Close releases all resources Lease keeps for efficient communication
// with the etcd server.
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
// minimum lease TTL is 5-second
resp, err := cli.Grant(context.TODO(), 5)
if err != nil {
log.Fatal(err)
// after 5 seconds, the key 'foo' will be removed
_, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
if err != nil {
log.Fatal(err)
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
resp, err := cli.Grant(context.TODO(), 5)
if err != nil {
log.Fatal(err)
_, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
if err != nil {
log.Fatal(err)
// the key 'foo' will be kept forever
ch, kaerr := cli.KeepAlive(context.TODO(), resp.ID)
if kaerr != nil {
log.Fatal(kaerr)
ka := &-ch
fmt.Println("ttl:", ka.TTL)
Output:ttl: 5
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
resp, err := cli.Grant(context.TODO(), 5)
if err != nil {
log.Fatal(err)
_, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
if err != nil {
log.Fatal(err)
// to renew the lease only once
ka, kaerr := cli.KeepAliveOnce(context.TODO(), resp.ID)
if kaerr != nil {
log.Fatal(kaerr)
fmt.Println("ttl:", ka.TTL)
Output:ttl: 5
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
resp, err := cli.Grant(context.TODO(), 5)
if err != nil {
log.Fatal(err)
_, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(resp.ID))
if err != nil {
log.Fatal(err)
// revoking lease expires the key attached to its lease ID
_, err = cli.Revoke(context.TODO(), resp.ID)
if err != nil {
log.Fatal(err)
gresp, err := cli.Get(context.TODO(), "foo")
if err != nil {
log.Fatal(err)
fmt.Println("number of keys:", len(gresp.Kvs))
Output:number of keys: 0
func NewLease(c *)
func NewLeaseFromLeaseClient(remote ., c *, keepAliveTimeout .)
type LeaseGrantResponse struct {
LeaseGrantResponse wraps the protobuf message LeaseGrantResponse.
type LeaseID
// NoLease is a lease ID for the absence of a lease.
type LeaseKeepAliveResponse struct {
LeaseKeepAliveResponse wraps the protobuf message LeaseKeepAliveResponse.
type LeaseLeasesResponse struct {
Leases [] `json:"leases"`
LeaseLeasesResponse wraps the protobuf message LeaseLeasesResponse.
type LeaseOp struct {
// contains filtered or unexported fields
LeaseOp represents an Operation that lease can execute.
type LeaseOption func(*)
LeaseOption configures lease operations.
func WithAttachedKeys()
WithAttachedKeys makes TimeToLive list the keys attached to the given lease ID.
type LeaseRevokeResponse .
type LeaseStatus struct {
`json:"id"`
LeaseStatus represents a lease status.
type LeaseTimeToLiveResponse struct {
`json:"id"`
// TTL is the remaining TTL in s the lease will expire in under TTL+1 seconds. Expired lease will return -1.
`json:"ttl"`
// GrantedTTL is the initial granted time in seconds upon lease creation/renewal.
`json:"granted-ttl"`
// Keys is the list of keys attached to this lease.
[][] `json:"keys"`
LeaseTimeToLiveResponse wraps the protobuf message LeaseTimeToLiveResponse.
type Maintenance interface {
// AlarmList gets all active alarms.
AlarmList(ctx .) (*, )
// AlarmDisarm disarms a given alarm.
AlarmDisarm(ctx ., m *) (*, )
// Defragment releases wasted space from internal fragmentation on a given etcd member.
// Defragment is only needed when deleting a large number of keys and want to reclaim
// the resources.
// Defragment is an expensive operation. User should avoid defragmenting multiple members
// at the same time.
// To defragment multiple members in the cluster, user need to call defragment multiple
// times with different endpoints.
Defragment(ctx ., endpoint ) (*, )
// Status gets the status of the endpoint.
Status(ctx ., endpoint ) (*, )
// HashKV returns a hash of the KV state at the time of the RPC.
// If revision is zero, the hash is computed on all keys. If the revision
// is non-zero, the hash is computed on all keys at or below the given revision.
HashKV(ctx ., endpoint , rev ) (*, )
// Snapshot provides a reader for a point-in-time snapshot of etcd.
// If the context "ctx" is canceled or timed out, reading from returned
// "io.ReadCloser" would error out (e.g. context.Canceled, context.DeadlineExceeded).
Snapshot(ctx .) (., )
// MoveLeader requests current leader to transfer its leadership to the transferee.
// Request must be made to the leader.
MoveLeader(ctx ., transfereeID ) (*, )
for _, ep := range endpoints {
cli, err := clientv3.New(clientv3.Config{
Endpoints:
[]string{ep},
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
if _, err = cli.Defragment(context.TODO(), ep); err != nil {
log.Fatal(err)
for _, ep := range endpoints {
cli, err := clientv3.New(clientv3.Config{
Endpoints:
[]string{ep},
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
resp, err := cli.Status(context.Background(), ep)
if err != nil {
log.Fatal(err)
fmt.Printf("endpoint: %s / Leader: %v\n", ep, resp.Header.MemberId == resp.Leader)
// endpoint: localhost:2379 / Leader: false
// endpoint: localhost:22379 / Leader: false
// endpoint: localhost:32379 / Leader: true
func NewMaintenance(c *)
func NewMaintenanceFromMaintenanceClient(remote ., c *)
type Member .
type MemberAddResponse .
type MemberListResponse .
type MemberRemoveResponse .
type MemberUpdateResponse .
type MoveLeaderResponse .
type Op struct {
// contains filtered or unexported fields
Op represents an Operation that kv can execute.
func OpDelete(key , opts ...)
OpDelete returns "delete" operation based on given key and operation options.
func OpGet(key , opts ...)
OpGet returns "get" operation based on given key and operation options.
func OpPut(key, val , opts ...)
OpPut returns "put" operation based on given key-value and operation options.
func OpTxn(cmps [], thenOps [], elseOps [])
OpTxn returns "txn" operation based on given transaction conditions.
func (op ) IsCountOnly()
IsCountOnly returns whether countOnly is set.
func (op ) IsDelete()
IsDelete returns true iff the operation is a Delete.
func (op ) IsGet()
IsGet returns true iff the operation is a Get.
func (op ) IsKeysOnly()
IsKeysOnly returns whether keysOnly is set.
func (op ) IsPut()
IsPut returns true iff the operation is a Put.
func (op ) IsSerializable()
IsSerializable returns true if the serializable field is true.
func (op ) IsTxn()
IsTxn returns true if the "Op" type is transaction.
func (op ) KeyBytes() []
KeyBytes returns the byte slice holding the Op's key.
func (op ) MaxCreateRev()
MaxCreateRev returns the operation's maximum create revision.
func (op ) MaxModRev()
MaxModRev returns the operation's maximum modify revision.
func (op ) MinCreateRev()
MinCreateRev returns the operation's minimum create revision.
func (op ) MinModRev()
MinModRev returns the operation's minimum modify revision.
func (op ) RangeBytes() []
RangeBytes returns the byte slice holding with the Op's range end, if any.
func (op ) Rev()
Rev returns the requested revision, if any.
func (op ) Txn() ([], [], [])
Txn returns the comparison(if) operations, "then" operations, and "else" operations.
func (op ) ValueBytes() []
ValueBytes returns the byte slice holding the Op's value, if any.
func (*Op)
func (op *) WithKeyBytes(key [])
WithKeyBytes sets the byte slice for the Op's key.
func (*Op)
func (op *) WithRangeBytes(end [])
WithRangeBytes sets the byte slice for the Op's range end.
func (*Op)
func (op *) WithValueBytes(v [])
WithValueBytes sets the byte slice for the Op's value.
type OpOption func(*)
OpOption configures Operations like Get, Put, Delete.
func WithCountOnly()
WithCountOnly makes the 'Get' request return only the count of keys.
func WithCreatedNotify()
WithCreatedNotify makes watch server sends the created event.
func WithFilterDelete()
WithFilterDelete discards DELETE events from the watcher.
func WithFilterPut()
WithFilterPut discards PUT events from the watcher.
func WithFirstCreate() []
WithFirstCreate gets the key with the oldest creation revision in the request range.
func WithFirstKey() []
WithFirstKey gets the lexically first key in the request range.
func WithFirstRev() []
WithFirstRev gets the key with the oldest modification revision in the request range.
func WithFragment()
WithFragment to receive raw watch response with fragmentation.
Fragmentation is disabled by default. If fragmentation is enabled,
etcd watch server will split watch response before sending to clients
when the total size of watch events exceed server-side request limit.
The default server-side request limit is 1.5 MiB, which can be configured
as "--max-request-bytes" flag value + gRPC-overhead 512 bytes.
See "etcdserver/api/v3rpc/watch.go" for more details.
func WithFromKey()
WithFromKey specifies the range of 'Get', 'Delete', 'Watch' requests
to be equal or greater than the key in the argument.
func WithIgnoreLease()
WithIgnoreLease updates the key using its current lease.
This option can not be combined with WithLease.
Returns an error if the key does not exist.
func WithIgnoreValue()
WithIgnoreValue updates the key using its current value.
This option can not be combined with non-empty values.
Returns an error if the key does not exist.
func WithKeysOnly()
WithKeysOnly makes the 'Get' request return only the keys and the corresponding
values will be omitted.
func WithLastCreate() []
WithLastCreate gets the key with the latest creation revision in the request range.
func WithLastKey() []
WithLastKey gets the lexically last key in the request range.
func WithLastRev() []
WithLastRev gets the key with the latest modification revision in the request range.
func WithLease(leaseID )
WithLease attaches a lease ID to a key in 'Put' request.
func WithLimit(n )
WithLimit limits the number of results to return from 'Get' request.
If WithLimit is given a 0 limit, it is treated as no limit.
func WithMaxCreateRev(rev )
WithMaxCreateRev filters out keys for Get with creation revisions greater than the given revision.
func WithMaxModRev(rev )
WithMaxModRev filters out keys for Get with modification revisions greater than the given revision.
func WithMinCreateRev(rev )
WithMinCreateRev filters out keys for Get with creation revisions less than the given revision.
func WithMinModRev(rev )
WithMinModRev filters out keys for Get with modification revisions less than the given revision.
func WithPrefix()
WithPrefix enables 'Get', 'Delete', or 'Watch' requests to operate
on the keys with matching prefix. For example, 'Get(foo, WithPrefix())'
can return 'foo1', 'foo2', and so on.
func WithPrevKV()
WithPrevKV gets the previous key-value pair before the event happens. If the previous KV is already compacted,
nothing will be returned.
func WithProgressNotify()
WithProgressNotify makes watch server send periodic progress updates
every 10 minutes when there is no incoming events.
Progress updates have zero events in WatchResponse.
func WithRange(endKey )
WithRange specifies the range of 'Get', 'Delete', 'Watch' requests.
For example, 'Get' requests with 'WithRange(end)' returns
the keys in the range [key, end).
endKey must be lexicographically greater than start key.
func WithRev(rev )
WithRev specifies the store revision for 'Get' request.
Or the start revision of 'Watch' request.
func WithSerializable()
WithSerializable makes 'Get' request serializable. By default,
it's linearizable. Serializable requests are better for lower latency
requirement.
func WithSort(target , order )
WithSort specifies the ordering in 'Get' request. It requires
'WithRange' and/or 'WithPrefix' to be specified too.
'target' specifies the target to sort by: key, version, revisions, value.
'order' can be either 'SortNone', 'SortAscend', 'SortDescend'.
type OpResponse struct {
// contains filtered or unexported fields
func (OpResponse)
func (op ) Del() *
func (OpResponse)
func (op ) Get() *
func (OpResponse)
func (op ) Put() *
func (OpResponse)
func (op ) Txn() *
type Permission .
type PermissionType .
func StrToPermissionType(s ) (, )
type PutResponse .
func (*PutResponse)
func (resp *) OpResponse()
type SortOption struct {
type SortOrder
SortAscend
SortDescend
type SortTarget
SortByVersion
SortByCreateRevision
SortByModRevision
SortByValue
type StatusResponse .
type Txn interface {
// If takes a list of comparison. If all comparisons passed in succeed,
// the operations passed into Then() will be executed. Or the operations
// passed into Else() will be executed.
If(cs ...)
// Then takes a list of operations. The Ops list will be executed, if the
// comparisons passed in If() succeed.
Then(ops ...)
// Else takes a list of operations. The Ops list will be executed, if the
// comparisons passed in If() fail.
Else(ops ...)
// Commit tries to commit the transaction.
Commit() (*, )
Txn is the interface that wraps mini-transactions.
Txn(context.TODO()).If(
Compare(Value(k1), "&", v1),
Compare(Version(k1), "=", 2)
OpPut(k2,v2), OpPut(k3,v3)
OpPut(k4,v4), OpPut(k5,v5)
).Commit()
type TxnResponse .
func (*TxnResponse)
func (resp *) OpResponse()
type WatchChan &-chan
type WatchResponse struct {
Events []*
// CompactRevision is the minimum revision the watcher may receive.
CompactRevision
// Canceled is used to indicate watch failure.
// If the watch failed and the stream was about to close, before the channel is closed,
// the channel sends a final response that has Canceled set to true with a non-nil Err().
// Created is used to indicate the creation of the watcher.
// contains filtered or unexported fields
func (*WatchResponse)
func (wr *) Err()
Err is the error value if this WatchResponse holds an error.
func (*WatchResponse)
func (wr *) IsProgressNotify()
IsProgressNotify returns true if the WatchResponse is progress notification.
type Watcher interface {
// Watch watches on a key or prefix. The watched events will be returned
// through the returned channel. If revisions waiting to be sent over the
// watch are compacted, then the watch will be canceled by the server, the
// client will post a compacted error watch response, and the channel will close.
// If the context "ctx" is canceled or timed out, returned "WatchChan" is closed,
// and "WatchResponse" from this closed channel has zero events and nil "Err()".
// The context "ctx" MUST be canceled, as soon as watcher is no longer being used,
// to release the associated resources.
// If the context is "context.Background/TODO", returned "WatchChan" will
// not be closed and block until event is triggered, except when server
// returns a non-recoverable error (e.g. ErrCompacted).
// For example, when context passed with "WithRequireLeader" and the
// connected server has no leader (e.g. due to network partition),
// error "etcdserver: no leader" (ErrNoLeader) will be returned,
// and then "WatchChan" is closed with non-nil "Err()".
// In order to prevent a watch stream being stuck in a partitioned node,
// make sure to wrap context with "WithRequireLeader".
// Otherwise, as long as the context has not been canceled or timed out,
// watch will retry on other recoverable errors forever until reconnected.
// TODO: explicitly set context error in the last "WatchResponse" message and close channel?
// Currently, client contexts are overwritten with "valCtx" that never closes.
// TODO(v3.4): configure watch retry policy, limit maximum retry number
// (see https://github.com/coreos/etcd/issues/8980)
Watch(ctx ., key , opts ...)
// RequestProgress requests a progress notify response be sent in all watch channels.
RequestProgress(ctx .)
// Close closes the watcher and cancels all watch requests.
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
rch := cli.Watch(context.Background(), "foo")
for wresp := range rch {
for _, ev := range wresp.Events {
fmt.Printf("%s %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
// PUT "foo" : "bar"
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
rch := cli.Watch(context.Background(), "foo", clientv3.WithPrefix())
for wresp := range rch {
for _, ev := range wresp.Events {
fmt.Printf("%s %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
// PUT "foo1" : "bar"
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
rch := cli.Watch(context.Background(), "foo", clientv3.WithProgressNotify())
wresp := &-rch
fmt.Printf("wresp.Header.Revision: %d\n", wresp.Header.Revision)
fmt.Println("wresp.IsProgressNotify:", wresp.IsProgressNotify())
// wresp.Header.Revision: 0
// wresp.IsProgressNotify: true
cli, err := clientv3.New(clientv3.Config{
Endpoints:
endpoints,
DialTimeout: dialTimeout,
if err != nil {
log.Fatal(err)
defer cli.Close()
// watches within ['foo1', 'foo4'), in lexicographical order
rch := cli.Watch(context.Background(), "foo1", clientv3.WithRange("foo4"))
for wresp := range rch {
for _, ev := range wresp.Events {
fmt.Printf("%s %q : %q\n", ev.Type, ev.Kv.Key, ev.Kv.Value)
// PUT "foo1" : "bar"
// PUT "foo2" : "bar"
// PUT "foo3" : "bar"
func NewWatchFromWatchClient(wc ., c *)
func NewWatcher(c *)
Directories
PathSynopsis
Package balancer implements client balancer.Package picker defines/implements client balancer picker policy.Package endpoint resolves etcd entpoints using grpc targets of the form 'endpoint://&id&/&endpoint&'.Package clientv3util contains utility functions derived from clientv3.Package concurrency implements concurrency operations on top of etcd such as distributed locks, barriers, and elections.Package integration implements tests built upon embedded etcd, and focuses on correctness of etcd client.Package leasing serves linearizable reads from a local cache by acquiring exclusive write access to keys through a client-side leasing protocol.Package mirror implements etcd mirroring operations.Package namespace is a clientv3 wrapper that translates all keys to begin with a given prefix.Package naming provides an etcd-backed gRPC resolver for discovering gRPC services.Package ordering is a clientv3 wrapper that caches response header revisions to detect ordering violations from stale responses.Package snapshot implements utilities around etcd snapshot.Package yaml handles yaml-formatted clientv3 configuration data.
? : This menu
/ : Search site
f : Jump to identifier
g then g : Go to top of page
g then b : Go to end of page
g then i : Go to index
g then e : Go to examples