From 3e57bbf317156064f66a8da53d6d56edda35809b Mon Sep 17 00:00:00 2001 From: Anthony Romano Date: Wed, 24 Feb 2016 22:49:24 -0800 Subject: [PATCH] clientv3: use default client kv --- clientv3/concurrency/mutex.go | 11 ++++----- clientv3/example_kv_test.go | 30 +++++++----------------- clientv3/example_lease_test.go | 14 ++++------- clientv3/example_test.go | 4 +--- clientv3/mirror/syncer.go | 5 ++-- contrib/recipes/barrier.go | 9 ++++--- contrib/recipes/double_barrier.go | 10 ++++---- contrib/recipes/election.go | 9 ++++--- contrib/recipes/key.go | 2 +- contrib/recipes/priority_queue.go | 11 ++++----- contrib/recipes/queue.go | 11 ++++----- contrib/recipes/rwmutex.go | 9 ++++--- contrib/recipes/stm.go | 7 +++--- etcdctlv3/command/compaction_command.go | 3 +-- etcdctlv3/command/del_command.go | 4 +--- etcdctlv3/command/get_command.go | 4 +--- etcdctlv3/command/lock_command.go | 2 +- etcdctlv3/command/make_mirror_command.go | 8 +++---- etcdctlv3/command/put_command.go | 4 +--- etcdctlv3/command/txn_command.go | 2 +- integration/v3_stm_test.go | 9 ++++--- 21 files changed, 65 insertions(+), 103 deletions(-) diff --git a/clientv3/concurrency/mutex.go b/clientv3/concurrency/mutex.go index 6c18d99c7..603a3e6db 100644 --- a/clientv3/concurrency/mutex.go +++ b/clientv3/concurrency/mutex.go @@ -24,7 +24,6 @@ import ( // Mutex implements the sync Locker interface with etcd type Mutex struct { client *v3.Client - kv v3.KV ctx context.Context pfx string @@ -33,7 +32,7 @@ type Mutex struct { } func NewMutex(ctx context.Context, client *v3.Client, pfx string) *Mutex { - return &Mutex{client, v3.NewKV(client), ctx, pfx, "", -1} + return &Mutex{client, ctx, pfx, "", -1} } // Lock locks the mutex with a cancellable context. If the context is cancelled @@ -44,12 +43,12 @@ func (m *Mutex) Lock(ctx context.Context) error { return err } // put self in lock waiters via myKey; oldest waiter holds lock - m.myKey, m.myRev, err = NewUniqueKey(ctx, m.kv, m.pfx, v3.WithLease(s.Lease())) + m.myKey, m.myRev, err = NewUniqueKey(ctx, m.client, m.pfx, v3.WithLease(s.Lease())) // wait for lock to become available for err == nil { // find oldest element in waiters via revision of insertion var resp *v3.GetResponse - resp, err = m.kv.Get(ctx, m.pfx, v3.WithFirstRev()...) + resp, err = m.client.Get(ctx, m.pfx, v3.WithFirstRev()...) if err != nil { break } @@ -59,7 +58,7 @@ func (m *Mutex) Lock(ctx context.Context) error { } // otherwise myKey isn't lowest, so there must be a pfx prior to myKey opts := append(v3.WithLastRev(), v3.WithRev(m.myRev-1)) - resp, err = m.kv.Get(ctx, m.pfx, opts...) + resp, err = m.client.Get(ctx, m.pfx, opts...) if err != nil { break } @@ -80,7 +79,7 @@ func (m *Mutex) Lock(ctx context.Context) error { } func (m *Mutex) Unlock() error { - if _, err := m.kv.Delete(m.ctx, m.myKey); err != nil { + if _, err := m.client.Delete(m.ctx, m.myKey); err != nil { return err } m.myKey = "\x00" diff --git a/clientv3/example_kv_test.go b/clientv3/example_kv_test.go index 7c57b7bfe..9eb3377e2 100644 --- a/clientv3/example_kv_test.go +++ b/clientv3/example_kv_test.go @@ -32,10 +32,8 @@ func ExampleKV_put() { } defer cli.Close() - kvc := clientv3.NewKV(cli) - ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) - resp, err := kvc.Put(ctx, "sample_key", "sample_value") + resp, err := cli.Put(ctx, "sample_key", "sample_value") cancel() if err != nil { log.Fatal(err) @@ -54,15 +52,13 @@ func ExampleKV_get() { } defer cli.Close() - kvc := clientv3.NewKV(cli) - - _, err = kvc.Put(context.TODO(), "foo", "bar") + _, err = cli.Put(context.TODO(), "foo", "bar") if err != nil { log.Fatal(err) } ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) - resp, err := kvc.Get(ctx, "foo") + resp, err := cli.Get(ctx, "foo") cancel() if err != nil { log.Fatal(err) @@ -83,11 +79,9 @@ func ExampleKV_getSortedPrefix() { } defer cli.Close() - kvc := clientv3.NewKV(cli) - for i := range make([]int, 3) { ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) - _, err = kvc.Put(ctx, fmt.Sprintf("key_%d", i), "value") + _, err = cli.Put(ctx, fmt.Sprintf("key_%d", i), "value") cancel() if err != nil { log.Fatal(err) @@ -95,7 +89,7 @@ func ExampleKV_getSortedPrefix() { } ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) - resp, err := kvc.Get(ctx, "key", clientv3.WithPrefix(), clientv3.WithSort(clientv3.SortByKey, clientv3.SortDescend)) + resp, err := cli.Get(ctx, "key", clientv3.WithPrefix(), clientv3.WithSort(clientv3.SortByKey, clientv3.SortDescend)) cancel() if err != nil { log.Fatal(err) @@ -118,10 +112,8 @@ func ExampleKV_delete() { } defer cli.Close() - kvc := clientv3.NewKV(cli) - ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) - resp, err := kvc.Delete(ctx, "key", clientv3.WithPrefix()) + resp, err := cli.Delete(ctx, "key", clientv3.WithPrefix()) cancel() if err != nil { log.Fatal(err) @@ -140,10 +132,8 @@ func ExampleKV_compact() { } defer cli.Close() - kvc := clientv3.NewKV(cli) - ctx, cancel := context.WithTimeout(context.Background(), requestTimeout) - resp, err := kvc.Get(ctx, "foo") + resp, err := cli.Get(ctx, "foo") cancel() if err != nil { log.Fatal(err) @@ -151,7 +141,7 @@ func ExampleKV_compact() { compRev := resp.Header.Revision // specify compact revision of your choice ctx, cancel = context.WithTimeout(context.Background(), requestTimeout) - err = kvc.Compact(ctx, compRev) + err = cli.Compact(ctx, compRev) cancel() if err != nil { log.Fatal(err) @@ -207,15 +197,13 @@ func ExampleKV_do() { } defer cli.Close() - kvc := clientv3.NewKV(cli) - ops := []clientv3.Op{ clientv3.OpPut("put-key", "123"), clientv3.OpGet("put-key"), clientv3.OpPut("put-key", "456")} for _, op := range ops { - if _, err := kvc.Do(context.TODO(), op); err != nil { + if _, err := cli.Do(context.TODO(), op); err != nil { log.Fatal(err) } } diff --git a/clientv3/example_lease_test.go b/clientv3/example_lease_test.go index 6a4ec1e4a..1f583e180 100644 --- a/clientv3/example_lease_test.go +++ b/clientv3/example_lease_test.go @@ -33,7 +33,6 @@ func ExampleLease_create() { } defer cli.Close() - kvc := clientv3.NewKV(cli) lapi := clientv3.NewLease(cli) defer lapi.Close() @@ -44,7 +43,7 @@ func ExampleLease_create() { } // after 5 seconds, the key 'foo' will be removed - _, err = kvc.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) + _, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) if err != nil { log.Fatal(err) } @@ -60,7 +59,6 @@ func ExampleLease_revoke() { } defer cli.Close() - kvc := clientv3.NewKV(cli) lapi := clientv3.NewLease(cli) defer lapi.Close() @@ -69,7 +67,7 @@ func ExampleLease_revoke() { log.Fatal(err) } - _, err = kvc.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) + _, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) if err != nil { log.Fatal(err) } @@ -80,7 +78,7 @@ func ExampleLease_revoke() { log.Fatal(err) } - gresp, err := kvc.Get(context.TODO(), "foo") + gresp, err := cli.Get(context.TODO(), "foo") if err != nil { log.Fatal(err) } @@ -98,7 +96,6 @@ func ExampleLease_keepAlive() { } defer cli.Close() - kvc := clientv3.NewKV(cli) lapi := clientv3.NewLease(cli) defer lapi.Close() @@ -107,7 +104,7 @@ func ExampleLease_keepAlive() { log.Fatal(err) } - _, err = kvc.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) + _, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) if err != nil { log.Fatal(err) } @@ -129,7 +126,6 @@ func ExampleLease_keepAliveOnce() { } defer cli.Close() - kvc := clientv3.NewKV(cli) lapi := clientv3.NewLease(cli) defer lapi.Close() @@ -138,7 +134,7 @@ func ExampleLease_keepAliveOnce() { log.Fatal(err) } - _, err = kvc.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) + _, err = cli.Put(context.TODO(), "foo", "bar", clientv3.WithLease(lease.LeaseID(resp.ID))) if err != nil { log.Fatal(err) } diff --git a/clientv3/example_test.go b/clientv3/example_test.go index e7eb3b6b7..b1da6f4bf 100644 --- a/clientv3/example_test.go +++ b/clientv3/example_test.go @@ -38,9 +38,7 @@ func Example() { } defer cli.Close() // make sure to close the client - kvc := clientv3.NewKV(cli) - - _, err = kvc.Put(context.TODO(), "foo", "bar") + _, err = cli.Put(context.TODO(), "foo", "bar") if err != nil { log.Fatal(err) } diff --git a/clientv3/mirror/syncer.go b/clientv3/mirror/syncer.go index a07a40f6f..4363da522 100644 --- a/clientv3/mirror/syncer.go +++ b/clientv3/mirror/syncer.go @@ -48,10 +48,9 @@ func (s *syncer) SyncBase(ctx context.Context) (<-chan clientv3.GetResponse, cha respchan := make(chan clientv3.GetResponse, 1024) errchan := make(chan error, 1) - kapi := clientv3.NewKV(s.c) // if rev is not specified, we will choose the most recent revision. if s.rev == 0 { - resp, err := kapi.Get(ctx, "foo") + resp, err := s.c.Get(ctx, "foo") if err != nil { errchan <- err close(respchan) @@ -83,7 +82,7 @@ func (s *syncer) SyncBase(ctx context.Context) (<-chan clientv3.GetResponse, cha } for { - resp, err := kapi.Get(ctx, key, opts...) + resp, err := s.c.Get(ctx, key, opts...) if err != nil { errchan <- err return diff --git a/contrib/recipes/barrier.go b/contrib/recipes/barrier.go index 56fde2dfd..b0ffd29e3 100644 --- a/contrib/recipes/barrier.go +++ b/contrib/recipes/barrier.go @@ -24,32 +24,31 @@ import ( // release all blocked processes. type Barrier struct { client *v3.Client - kv v3.KV ctx context.Context key string } func NewBarrier(client *v3.Client, key string) *Barrier { - return &Barrier{client, v3.NewKV(client), context.TODO(), key} + return &Barrier{client, context.TODO(), key} } // Hold creates the barrier key causing processes to block on Wait. func (b *Barrier) Hold() error { - _, err := NewKey(b.kv, b.key, 0) + _, err := NewKey(b.client, b.key, 0) return err } // Release deletes the barrier key to unblock all waiting processes. func (b *Barrier) Release() error { - _, err := b.kv.Delete(b.ctx, b.key) + _, err := b.client.Delete(b.ctx, b.key) return err } // Wait blocks on the barrier key until it is deleted. If there is no key, Wait // assumes Release has already been called and returns immediately. func (b *Barrier) Wait() error { - resp, err := b.kv.Get(b.ctx, b.key, v3.WithFirstKey()...) + resp, err := b.client.Get(b.ctx, b.key, v3.WithFirstKey()...) if err != nil { return err } diff --git a/contrib/recipes/double_barrier.go b/contrib/recipes/double_barrier.go index 1be537d1c..1d0fcacd1 100644 --- a/contrib/recipes/double_barrier.go +++ b/contrib/recipes/double_barrier.go @@ -24,7 +24,6 @@ import ( // blocks again on Leave until all processes have left. type DoubleBarrier struct { client *clientv3.Client - kv clientv3.KV ctx context.Context key string // key for the collective barrier @@ -35,7 +34,6 @@ type DoubleBarrier struct { func NewDoubleBarrier(client *clientv3.Client, key string, count int) *DoubleBarrier { return &DoubleBarrier{ client: client, - kv: clientv3.NewKV(client), ctx: context.TODO(), key: key, count: count, @@ -50,7 +48,7 @@ func (b *DoubleBarrier) Enter() error { } b.myKey = ek - resp, err := b.kv.Get(b.ctx, b.key+"/waiters", clientv3.WithPrefix()) + resp, err := b.client.Get(b.ctx, b.key+"/waiters", clientv3.WithPrefix()) if err != nil { return err } @@ -61,7 +59,7 @@ func (b *DoubleBarrier) Enter() error { if len(resp.Kvs) == b.count { // unblock waiters - _, err = b.kv.Put(b.ctx, b.key+"/ready", "") + _, err = b.client.Put(b.ctx, b.key+"/ready", "") return err } @@ -75,7 +73,7 @@ func (b *DoubleBarrier) Enter() error { // Leave waits for "count" processes to leave the barrier then returns func (b *DoubleBarrier) Leave() error { - resp, err := b.kv.Get(b.ctx, b.key+"/waiters", clientv3.WithPrefix()) + resp, err := b.client.Get(b.ctx, b.key+"/waiters", clientv3.WithPrefix()) if len(resp.Kvs) == 0 { return nil } @@ -93,7 +91,7 @@ func (b *DoubleBarrier) Leave() error { if len(resp.Kvs) == 1 { // this is the only node in the barrier; finish up - if _, err = b.kv.Delete(b.ctx, b.key+"/ready"); err != nil { + if _, err = b.client.Delete(b.ctx, b.key+"/ready"); err != nil { return err } return b.myKey.Delete() diff --git a/contrib/recipes/election.go b/contrib/recipes/election.go index d091a1975..8c41b610b 100644 --- a/contrib/recipes/election.go +++ b/contrib/recipes/election.go @@ -22,7 +22,6 @@ import ( type Election struct { client *v3.Client - kv v3.KV ctx context.Context keyPrefix string @@ -31,7 +30,7 @@ type Election struct { // NewElection returns a new election on a given key prefix. func NewElection(client *v3.Client, keyPrefix string) *Election { - return &Election{client, v3.NewKV(client), context.TODO(), keyPrefix, nil} + return &Election{client, context.TODO(), keyPrefix, nil} } // Volunteer puts a value as eligible for the election. It blocks until @@ -62,7 +61,7 @@ func (e *Election) Resign() (err error) { // Leader returns the leader value for the current election. func (e *Election) Leader() (string, error) { - resp, err := e.kv.Get(e.ctx, e.keyPrefix, v3.WithFirstCreate()...) + resp, err := e.client.Get(e.ctx, e.keyPrefix, v3.WithFirstCreate()...) if err != nil { return "", err } else if len(resp.Kvs) == 0 { @@ -74,7 +73,7 @@ func (e *Election) Leader() (string, error) { // Wait waits for a leader to be elected, returning the leader value. func (e *Election) Wait() (string, error) { - resp, err := e.kv.Get(e.ctx, e.keyPrefix, v3.WithFirstCreate()...) + resp, err := e.client.Get(e.ctx, e.keyPrefix, v3.WithFirstCreate()...) if err != nil { return "", err } else if len(resp.Kvs) != 0 { @@ -94,7 +93,7 @@ func (e *Election) Wait() (string, error) { func (e *Election) waitLeadership(tryKey *EphemeralKV) error { opts := append(v3.WithLastCreate(), v3.WithRev(tryKey.Revision()-1)) - resp, err := e.kv.Get(e.ctx, e.keyPrefix, opts...) + resp, err := e.client.Get(e.ctx, e.keyPrefix, opts...) if err != nil { return err } else if len(resp.Kvs) == 0 { diff --git a/contrib/recipes/key.go b/contrib/recipes/key.go index a7011c177..b58d7f2bb 100644 --- a/contrib/recipes/key.go +++ b/contrib/recipes/key.go @@ -166,7 +166,7 @@ func NewEphemeralKV(client *v3.Client, key, val string) (*EphemeralKV, error) { if err != nil { return nil, err } - k, err := NewKV(v3.NewKV(client), key, val, s.Lease()) + k, err := NewKV(client, key, val, s.Lease()) if err != nil { return nil, err } diff --git a/contrib/recipes/priority_queue.go b/contrib/recipes/priority_queue.go index 1a1c628a1..7cb28c0f5 100644 --- a/contrib/recipes/priority_queue.go +++ b/contrib/recipes/priority_queue.go @@ -25,20 +25,19 @@ import ( // PriorityQueue implements a multi-reader, multi-writer distributed queue. type PriorityQueue struct { client *v3.Client - kv v3.KV ctx context.Context key string } // NewPriorityQueue creates an etcd priority queue. func NewPriorityQueue(client *v3.Client, key string) *PriorityQueue { - return &PriorityQueue{client, v3.NewKV(client), context.TODO(), key + "/"} + return &PriorityQueue{client, context.TODO(), key + "/"} } // Enqueue puts a value into a queue with a given priority. func (q *PriorityQueue) Enqueue(val string, pr uint16) error { prefix := fmt.Sprintf("%s%05d", q.key, pr) - _, err := NewSequentialKV(q.kv, prefix, val) + _, err := NewSequentialKV(q.client, prefix, val) return err } @@ -46,12 +45,12 @@ func (q *PriorityQueue) Enqueue(val string, pr uint16) error { // queue is empty, Dequeue blocks until items are available. func (q *PriorityQueue) Dequeue() (string, error) { // TODO: fewer round trips by fetching more than one key - resp, err := q.kv.Get(q.ctx, q.key, v3.WithFirstKey()...) + resp, err := q.client.Get(q.ctx, q.key, v3.WithFirstKey()...) if err != nil { return "", err } - kv, err := claimFirstKey(q.kv, resp.Kvs) + kv, err := claimFirstKey(q.client, resp.Kvs) if err != nil { return "", err } else if kv != nil { @@ -71,7 +70,7 @@ func (q *PriorityQueue) Dequeue() (string, error) { return "", err } - ok, err := deleteRevKey(q.kv, string(ev.Kv.Key), ev.Kv.ModRevision) + ok, err := deleteRevKey(q.client, string(ev.Kv.Key), ev.Kv.ModRevision) if err != nil { return "", err } else if !ok { diff --git a/contrib/recipes/queue.go b/contrib/recipes/queue.go index c0a4977fb..8c9faedf1 100644 --- a/contrib/recipes/queue.go +++ b/contrib/recipes/queue.go @@ -23,18 +23,17 @@ import ( // Queue implements a multi-reader, multi-writer distributed queue. type Queue struct { client *v3.Client - kv v3.KV ctx context.Context keyPrefix string } func NewQueue(client *v3.Client, keyPrefix string) *Queue { - return &Queue{client, v3.NewKV(client), context.TODO(), keyPrefix} + return &Queue{client, context.TODO(), keyPrefix} } func (q *Queue) Enqueue(val string) error { - _, err := NewUniqueKV(q.kv, q.keyPrefix, val, 0) + _, err := NewUniqueKV(q.client, q.keyPrefix, val, 0) return err } @@ -42,12 +41,12 @@ func (q *Queue) Enqueue(val string) error { // queue is empty, Dequeue blocks until elements are available. func (q *Queue) Dequeue() (string, error) { // TODO: fewer round trips by fetching more than one key - resp, err := q.kv.Get(q.ctx, q.keyPrefix, v3.WithFirstRev()...) + resp, err := q.client.Get(q.ctx, q.keyPrefix, v3.WithFirstRev()...) if err != nil { return "", err } - kv, err := claimFirstKey(q.kv, resp.Kvs) + kv, err := claimFirstKey(q.client, resp.Kvs) if err != nil { return "", err } else if kv != nil { @@ -67,7 +66,7 @@ func (q *Queue) Dequeue() (string, error) { return "", err } - ok, err := deleteRevKey(q.kv, string(ev.Kv.Key), ev.Kv.ModRevision) + ok, err := deleteRevKey(q.client, string(ev.Kv.Key), ev.Kv.ModRevision) if err != nil { return "", err } else if !ok { diff --git a/contrib/recipes/rwmutex.go b/contrib/recipes/rwmutex.go index ea2425c69..921976610 100644 --- a/contrib/recipes/rwmutex.go +++ b/contrib/recipes/rwmutex.go @@ -22,7 +22,6 @@ import ( type RWMutex struct { client *v3.Client - kv v3.KV ctx context.Context key string @@ -30,7 +29,7 @@ type RWMutex struct { } func NewRWMutex(client *v3.Client, key string) *RWMutex { - return &RWMutex{client, v3.NewKV(client), context.TODO(), key, nil} + return &RWMutex{client, context.TODO(), key, nil} } func (rwm *RWMutex) RLock() error { @@ -42,7 +41,7 @@ func (rwm *RWMutex) RLock() error { // if there are nodes with "write-" and a lower // revision number than us we must wait - resp, err := rwm.kv.Get(rwm.ctx, rwm.key+"/write", v3.WithFirstRev()...) + resp, err := rwm.client.Get(rwm.ctx, rwm.key+"/write", v3.WithFirstRev()...) if err != nil { return err } @@ -63,7 +62,7 @@ func (rwm *RWMutex) Lock() error { for { // find any key of lower rev number blocks the write lock opts := append(v3.WithLastRev(), v3.WithRev(rk.Revision()-1)) - resp, err := rwm.kv.Get(rwm.ctx, rwm.key, opts...) + resp, err := rwm.client.Get(rwm.ctx, rwm.key, opts...) if err != nil { return err } @@ -83,7 +82,7 @@ func (rwm *RWMutex) Lock() error { func (rwm *RWMutex) waitOnLowest() error { // must block; get key before ek for waiting opts := append(v3.WithLastRev(), v3.WithRev(rwm.myKey.Revision()-1)) - lastKey, err := rwm.kv.Get(rwm.ctx, rwm.key, opts...) + lastKey, err := rwm.client.Get(rwm.ctx, rwm.key, opts...) if err != nil { return err } diff --git a/contrib/recipes/stm.go b/contrib/recipes/stm.go index 03c090b3d..8c271944c 100644 --- a/contrib/recipes/stm.go +++ b/contrib/recipes/stm.go @@ -22,7 +22,6 @@ import ( // STM implements software transactional memory over etcd type STM struct { client *v3.Client - kv v3.KV // rset holds the read key's value and revision of read rset map[string]*RemoteKV // wset holds the write key and its value @@ -34,7 +33,7 @@ type STM struct { // NewSTM creates new transaction loop for a given apply function. func NewSTM(client *v3.Client, apply func(*STM) error) <-chan error { - s := &STM{client: client, kv: v3.NewKV(client), apply: apply} + s := &STM{client: client, apply: apply} errc := make(chan error, 1) go func() { var err error @@ -64,7 +63,7 @@ func (s *STM) Get(key string) (string, error) { if rk, ok := s.rset[key]; ok { return rk.Value(), nil } - rk, err := GetRemoteKV(s.kv, key) + rk, err := GetRemoteKV(s.client, key) if err != nil { return "", err } @@ -91,7 +90,7 @@ func (s *STM) commit() (ok bool, rr error) { for k, v := range s.wset { puts = append(puts, v3.OpPut(k, v)) } - txnresp, err := s.kv.Txn(context.TODO()).If(cmps...).Then(puts...).Commit() + txnresp, err := s.client.Txn(context.TODO()).If(cmps...).Then(puts...).Commit() return txnresp.Succeeded, err } diff --git a/etcdctlv3/command/compaction_command.go b/etcdctlv3/command/compaction_command.go index d68f3595b..24b05da8b 100644 --- a/etcdctlv3/command/compaction_command.go +++ b/etcdctlv3/command/compaction_command.go @@ -20,7 +20,6 @@ import ( "github.com/coreos/etcd/Godeps/_workspace/src/github.com/spf13/cobra" "github.com/coreos/etcd/Godeps/_workspace/src/golang.org/x/net/context" - "github.com/coreos/etcd/clientv3" ) // NewCompactionCommand returns the cobra command for "compaction". @@ -44,7 +43,7 @@ func compactionCommandFunc(cmd *cobra.Command, args []string) { } c := mustClientFromCmd(cmd) - if cerr := clientv3.NewKV(c).Compact(context.TODO(), rev); cerr != nil { + if cerr := c.Compact(context.TODO(), rev); cerr != nil { ExitWithError(ExitError, cerr) return } diff --git a/etcdctlv3/command/del_command.go b/etcdctlv3/command/del_command.go index cdabf8dd7..bc094367a 100644 --- a/etcdctlv3/command/del_command.go +++ b/etcdctlv3/command/del_command.go @@ -34,9 +34,7 @@ func NewDelCommand() *cobra.Command { // delCommandFunc executes the "del" command. func delCommandFunc(cmd *cobra.Command, args []string) { key, opts := getDelOp(cmd, args) - c := mustClientFromCmd(cmd) - kvapi := clientv3.NewKV(c) - resp, err := kvapi.Delete(context.TODO(), key, opts...) + resp, err := mustClientFromCmd(cmd).Delete(context.TODO(), key, opts...) if err != nil { ExitWithError(ExitError, err) } diff --git a/etcdctlv3/command/get_command.go b/etcdctlv3/command/get_command.go index 43a5f167b..9c1650cc8 100644 --- a/etcdctlv3/command/get_command.go +++ b/etcdctlv3/command/get_command.go @@ -49,9 +49,7 @@ func NewGetCommand() *cobra.Command { // getCommandFunc executes the "get" command. func getCommandFunc(cmd *cobra.Command, args []string) { key, opts := getGetOp(cmd, args) - c := mustClientFromCmd(cmd) - kvapi := clientv3.NewKV(c) - resp, err := kvapi.Get(context.TODO(), key, opts...) + resp, err := mustClientFromCmd(cmd).Get(context.TODO(), key, opts...) if err != nil { ExitWithError(ExitError, err) } diff --git a/etcdctlv3/command/lock_command.go b/etcdctlv3/command/lock_command.go index b68841422..a07f2a773 100644 --- a/etcdctlv3/command/lock_command.go +++ b/etcdctlv3/command/lock_command.go @@ -68,7 +68,7 @@ func lockUntilSignal(c *clientv3.Client, lockname string) error { return err } - k, kerr := clientv3.NewKV(c).Get(ctx, m.Key()) + k, kerr := c.Get(ctx, m.Key()) if kerr != nil { return kerr } diff --git a/etcdctlv3/command/make_mirror_command.go b/etcdctlv3/command/make_mirror_command.go index abef26ecf..19ceb563a 100644 --- a/etcdctlv3/command/make_mirror_command.go +++ b/etcdctlv3/command/make_mirror_command.go @@ -75,15 +75,13 @@ func makeMirror(ctx context.Context, c *clientv3.Client, dc *clientv3.Client) er }() // TODO: remove the prefix of the destination cluster? - dkv := clientv3.NewKV(dc) - s := mirror.NewSyncer(c, mmprefix, 0) rc, errc := s.SyncBase(ctx) for r := range rc { for _, kv := range r.Kvs { - _, err := dkv.Put(ctx, string(kv.Key), string(kv.Value)) + _, err := dc.Put(ctx, string(kv.Key), string(kv.Value)) if err != nil { return err } @@ -109,7 +107,7 @@ func makeMirror(ctx context.Context, c *clientv3.Client, dc *clientv3.Client) er for _, ev := range wr.Events { nrev := ev.Kv.ModRevision if rev != 0 && nrev > rev { - _, err := dkv.Txn(ctx).Then(ops...).Commit() + _, err := dc.Txn(ctx).Then(ops...).Commit() if err != nil { return err } @@ -128,7 +126,7 @@ func makeMirror(ctx context.Context, c *clientv3.Client, dc *clientv3.Client) er } if len(ops) != 0 { - _, err := dkv.Txn(ctx).Then(ops...).Commit() + _, err := dc.Txn(ctx).Then(ops...).Commit() if err != nil { return err } diff --git a/etcdctlv3/command/put_command.go b/etcdctlv3/command/put_command.go index 709675937..eb9e5ca77 100644 --- a/etcdctlv3/command/put_command.go +++ b/etcdctlv3/command/put_command.go @@ -58,9 +58,7 @@ will store the content of the file to . func putCommandFunc(cmd *cobra.Command, args []string) { key, value, opts := getPutOp(cmd, args) - c := mustClientFromCmd(cmd) - kvapi := clientv3.NewKV(c) - resp, err := kvapi.Put(context.TODO(), key, value, opts...) + resp, err := mustClientFromCmd(cmd).Put(context.TODO(), key, value, opts...) if err != nil { ExitWithError(ExitError, err) } diff --git a/etcdctlv3/command/txn_command.go b/etcdctlv3/command/txn_command.go index 13950166b..d0ae629cf 100644 --- a/etcdctlv3/command/txn_command.go +++ b/etcdctlv3/command/txn_command.go @@ -53,7 +53,7 @@ func txnCommandFunc(cmd *cobra.Command, args []string) { reader := bufio.NewReader(os.Stdin) - txn := clientv3.NewKV(mustClientFromCmd(cmd)).Txn(context.Background()) + txn := mustClientFromCmd(cmd).Txn(context.Background()) fmt.Println("compares:") txn.If(readCompares(reader)...) fmt.Println("success requests (get, put, delete):") diff --git a/integration/v3_stm_test.go b/integration/v3_stm_test.go index b496664dc..a056fda9e 100644 --- a/integration/v3_stm_test.go +++ b/integration/v3_stm_test.go @@ -19,7 +19,6 @@ import ( "strconv" "testing" - v3 "github.com/coreos/etcd/clientv3" "github.com/coreos/etcd/contrib/recipes" ) @@ -31,7 +30,7 @@ func TestSTMConflict(t *testing.T) { etcdc := clus.RandClient() keys := make([]*recipe.RemoteKV, 5) for i := 0; i < len(keys); i++ { - rk, err := recipe.NewKV(v3.NewKV(etcdc), fmt.Sprintf("foo-%d", i), "100", 0) + rk, err := recipe.NewKV(etcdc, fmt.Sprintf("foo-%d", i), "100", 0) if err != nil { t.Fatalf("could not make key (%v)", err) } @@ -76,7 +75,7 @@ func TestSTMConflict(t *testing.T) { // ensure sum matches initial sum sum := 0 for _, oldRK := range keys { - rk, err := recipe.GetRemoteKV(v3.NewKV(etcdc), oldRK.Key()) + rk, err := recipe.GetRemoteKV(etcdc, oldRK.Key()) if err != nil { t.Fatalf("couldn't fetch key %s (%v)", oldRK.Key(), err) } @@ -103,7 +102,7 @@ func TestSTMPutNewKey(t *testing.T) { t.Fatalf("error on stm txn (%v)", err) } - rk, err := recipe.GetRemoteKV(v3.NewKV(etcdc), "foo") + rk, err := recipe.GetRemoteKV(etcdc, "foo") if err != nil { t.Fatalf("error fetching key (%v)", err) } @@ -129,7 +128,7 @@ func TestSTMAbort(t *testing.T) { t.Fatalf("error on stm txn (%v)", err) } - rk, err := recipe.GetRemoteKV(v3.NewKV(etcdc), "foo") + rk, err := recipe.GetRemoteKV(etcdc, "foo") if err != nil { t.Fatalf("error fetching key (%v)", err) }