*: rename storage package to mvcc

Documentation/api_v3.md

@@ -141,6 +141,6 @@ etcd ensures linearizability for all other operations by default. Linearizabilit
 [strict_consistency]: https://en.wikipedia.org/wiki/Consistency_model#Strict_consistency
 [serializable_isolation]: https://en.wikipedia.org/wiki/Isolation_(database_systems)#Serializable
 [Linearizability]: #Linearizability
-[kv-proto]: https://github.com/coreos/etcd/blob/master/storage/storagepb/kv.proto
+[kv-proto]: https://github.com/coreos/etcd/blob/master/mvcc/mvccpb/kv.proto
 [kv-service]: https://github.com/coreos/etcd/blob/master/etcdserver/etcdserverpb/rpc.proto
 [response_header]: https://github.com/coreos/etcd/blob/master/etcdserver/etcdserverpb/rpc.proto

Documentation/dev-guide/api_reference_v3.md

@@ -567,7 +567,7 @@ Empty field.
 | Field | Description | Type |
 | ----- | ----------- | ---- |
 | header |  | ResponseHeader |
-| kvs | kvs is the list of key-value pairs matched by the range request. | (slice of) storagepb.KeyValue |
+| kvs | kvs is the list of key-value pairs matched by the range request. | (slice of) mvccpb.KeyValue |
 | more | more indicates if there are more keys to return in the requested range. | bool |
 
 
@@ -700,11 +700,11 @@ From google paxosdb paper: Our implementation hinges around a powerful primitive
 | created | created is set to true if the response is for a create watch request. The client should record the watch_id and expect to receive events for the created watcher from the same stream. All events sent to the created watcher will attach with the same watch_id. | bool |
 | canceled | canceled is set to true if the response is for a cancel watch request. No further events will be sent to the canceled watcher. | bool |
 | compact_revision | compact_revision is set to the minimum index if a watcher tries to watch at a compacted index.  This happens when creating a watcher at a compacted revision or the watcher cannot catch up with the progress of the key-value store.  The client should treat the watcher as canceled and should not try to create any watcher with the same start_revision again. | int64 |
-| events |  | (slice of) storagepb.Event |
+| events |  | (slice of) mvccpb.Event |
 
 
 
-##### message `Event` (storage/storagepb/kv.proto)
+##### message `Event` (mvcc/mvccpb/kv.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -713,7 +713,7 @@ From google paxosdb paper: Our implementation hinges around a powerful primitive
 
 
 
-##### message `KeyValue` (storage/storagepb/kv.proto)
+##### message `KeyValue` (mvcc/mvccpb/kv.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |

Documentation/dev-guide/interacting_v3.md

@@ -179,7 +179,7 @@ compacted revision 5
 
 # any revisions before the compacted one are not accessible
 $ etcdctl get --rev=4 foo
-Error:  rpc error: code = 11 desc = etcdserver: storage: required revision has been compacted
+Error:  rpc error: code = 11 desc = etcdserver: mvcc: required revision has been compacted
 ```
 
 ## Grant leases
@@ -240,4 +240,4 @@ lease 32695410dcc0ca0 keepalived with TTL(100)
 lease 32695410dcc0ca0 keepalived with TTL(100)
 lease 32695410dcc0ca0 keepalived with TTL(100)
 ...
-```
+```

Documentation/op-guide/maintenance.md

@@ -31,7 +31,7 @@ Revisions prior to the compaction revision become inaccessible:
 
 ```sh
 $ etcdctl get --rev=2 somekey
-Error:  rpc error: code = 11 desc = etcdserver: storage: required revision has been compacted
+Error:  rpc error: code = 11 desc = etcdserver: mvcc: required revision has been compacted
 ```
 
 ## Defragmentation
@@ -64,7 +64,7 @@ The space quota can be triggered with a loop:
 # fill keyspace
 $ while [ 1 ]; do dd if=/dev/urandom bs=1024 count=1024  | etcdctl put key  || break; done
 ...
-Error:  rpc error: code = 8 desc = etcdserver: storage: database space exceeded
+Error:  rpc error: code = 8 desc = etcdserver: mvcc: database space exceeded
 # confirm quota space is exceeded
 $ etcdctl endpoint status
 +----------------+------------------+-----------+---------+-----------+-----------+------------+

Documentation/rfc/v3api.md

@@ -208,4 +208,4 @@ WatchResponse {
 ```
 
 [api-protobuf]: https://github.com/coreos/etcd/blob/master/etcdserver/etcdserverpb/rpc.proto
-[kv-protobuf]: https://github.com/coreos/etcd/blob/master/storage/storagepb/kv.proto
+[kv-protobuf]: https://github.com/coreos/etcd/blob/master/mvcc/mvccpb/kv.proto

alarm/alarms.go

@@ -19,8 +19,8 @@ import (
 	"sync"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/types"
-	"github.com/coreos/etcd/storage/backend"
 	"github.com/coreos/pkg/capnslog"
 )
 

auth/authpb/auth.pb.go

@@ -756,21 +756,20 @@ var (
 )
 
 var fileDescriptorAuth = []byte{
-	// 254 bytes of a gzipped FileDescriptorProto
+	// 236 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x4a, 0x2c, 0x2d, 0xc9,
 	0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0xb1, 0x0b, 0x92, 0xa4, 0x44, 0xd2, 0xf3,
-	0xd3, 0xf3, 0xc1, 0x42, 0xfa, 0x20, 0x16, 0x44, 0x56, 0xc9, 0x87, 0x8b, 0x25, 0xb4, 0x38, 0xb5,
-	0x48, 0x48, 0x88, 0x8b, 0x25, 0x2f, 0x31, 0x37, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0x27, 0x08,
-	0xcc, 0x16, 0x92, 0xe2, 0xe2, 0x28, 0x48, 0x2c, 0x2e, 0x2e, 0xcf, 0x2f, 0x4a, 0x91, 0x60, 0x02,
-	0x8b, 0xc3, 0xf9, 0x42, 0x22, 0x5c, 0xac, 0x45, 0xf9, 0x39, 0xa9, 0xc5, 0x12, 0xcc, 0x0a, 0xcc,
-	0x1a, 0x9c, 0x41, 0x10, 0x8e, 0x52, 0x3d, 0x17, 0x57, 0x40, 0x6a, 0x51, 0x6e, 0x66, 0x71, 0x71,
-	0x66, 0x7e, 0x9e, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0x25, 0xd4, 0x48, 0x10, 0x53, 0xc8, 0x18,
-	0x68, 0x22, 0x50, 0x3e, 0xa4, 0xb2, 0x20, 0x15, 0x6c, 0x22, 0x9f, 0x91, 0xb8, 0x1e, 0xc4, 0x79,
-	0x7a, 0x08, 0x7d, 0x7a, 0x20, 0xe9, 0x20, 0xb8, 0x42, 0x25, 0x2d, 0x2e, 0x16, 0x10, 0x2d, 0xc4,
-	0xc1, 0xc5, 0x12, 0xe4, 0xea, 0xe8, 0x22, 0xc0, 0x20, 0xc4, 0xc9, 0xc5, 0x1a, 0x1e, 0xe4, 0x19,
-	0xe2, 0x2a, 0xc0, 0x28, 0xc4, 0xcb, 0xc5, 0x09, 0x12, 0x84, 0x70, 0x99, 0x94, 0x42, 0x80, 0x6a,
-	0x80, 0x2e, 0xc1, 0xea, 0x1d, 0x0b, 0x2e, 0x5e, 0xa0, 0x1b, 0x10, 0xf6, 0x00, 0x5d, 0xc0, 0xac,
-	0xc1, 0x6d, 0x24, 0x84, 0xe9, 0x82, 0x20, 0x54, 0x85, 0x4e, 0x22, 0x27, 0x1e, 0xca, 0x31, 0x5c,
-	0x00, 0xe2, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x00, 0xf1, 0x03, 0x20, 0x4e, 0x62, 0x03, 0x87, 0xa0,
-	0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x92, 0x06, 0xa1, 0xed, 0x6d, 0x01, 0x00, 0x00,
+	0xd3, 0xf3, 0xc1, 0x42, 0xfa, 0x20, 0x16, 0x44, 0x56, 0xc9, 0x94, 0x8b, 0x25, 0xb4, 0x38, 0xb5,
+	0x48, 0x88, 0x87, 0x8b, 0x25, 0x2f, 0x31, 0x37, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0x47, 0x48,
+	0x80, 0x8b, 0xa3, 0x20, 0xb1, 0xb8, 0xb8, 0x3c, 0xbf, 0x28, 0x45, 0x82, 0x09, 0x2c, 0xc2, 0xcb,
+	0xc5, 0x5a, 0x94, 0x9f, 0x93, 0x5a, 0x2c, 0xc1, 0xac, 0xc0, 0xac, 0xc1, 0xa9, 0x54, 0xc0, 0xc5,
+	0x15, 0x90, 0x5a, 0x94, 0x9b, 0x59, 0x5c, 0x9c, 0x99, 0x9f, 0x27, 0xc4, 0xcd, 0xc5, 0x9c, 0x9d,
+	0x5a, 0x09, 0xd5, 0xab, 0x09, 0xd4, 0x0b, 0x94, 0x0a, 0xa9, 0x2c, 0x48, 0x05, 0xeb, 0xe5, 0x33,
+	0x12, 0xd7, 0x83, 0x38, 0x41, 0x0f, 0xa1, 0x45, 0x0f, 0x24, 0xad, 0xa4, 0xc5, 0xc5, 0x02, 0xa2,
+	0x85, 0x38, 0xb8, 0x58, 0x82, 0x5c, 0x1d, 0x5d, 0x04, 0x18, 0x84, 0x38, 0xb9, 0x58, 0xc3, 0x83,
+	0x3c, 0x43, 0x5c, 0x05, 0x18, 0x81, 0x36, 0x72, 0x82, 0x04, 0x21, 0x5c, 0x26, 0x25, 0x7b, 0xa0,
+	0x1a, 0xa0, 0x03, 0xd0, 0x1c, 0xaa, 0xc9, 0xc5, 0x0b, 0xb4, 0x19, 0x61, 0x2e, 0xd0, 0x46, 0x66,
+	0x0d, 0x6e, 0x23, 0x21, 0x4c, 0x1b, 0x9d, 0x44, 0x4e, 0x3c, 0x94, 0x63, 0xb8, 0x00, 0xc4, 0x27,
+	0x1e, 0xc9, 0x31, 0x5e, 0x00, 0xe2, 0x07, 0x40, 0x9c, 0xc4, 0x06, 0x0e, 0x06, 0x63, 0x40, 0x00,
+	0x00, 0x00, 0xff, 0xff, 0x8d, 0x09, 0x06, 0x6e, 0x32, 0x01, 0x00, 0x00,
 }

auth/store.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/coreos/etcd/auth/authpb"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/pkg/capnslog"
 	"golang.org/x/crypto/bcrypt"
 )

clientv3/concurrency/election.go

@@ -18,7 +18,7 @@ import (
 	"errors"
 
 	v3 "github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
@@ -128,7 +128,7 @@ func (e *Election) observe(ctx context.Context, ch chan<- v3.GetResponse) {
 			return
 		}
 
-		var kv *storagepb.KeyValue
+		var kv *mvccpb.KeyValue
 
 		cctx, cancel := context.WithCancel(ctx)
 		if len(resp.Kvs) == 0 {
@@ -144,7 +144,7 @@ func (e *Election) observe(ctx context.Context, ch chan<- v3.GetResponse) {
 				}
 				// only accept PUTs; a DELETE will make observe() spin
 				for _, ev := range wr.Events {
-					if ev.Type == storagepb.PUT {
+					if ev.Type == mvccpb.PUT {
 						kv = ev.Kv
 						break
 					}
@@ -162,12 +162,12 @@ func (e *Election) observe(ctx context.Context, ch chan<- v3.GetResponse) {
 				return
 			}
 			for _, ev := range wr.Events {
-				if ev.Type == storagepb.DELETE {
+				if ev.Type == mvccpb.DELETE {
 					keyDeleted = true
 					break
 				}
 				resp.Header = &wr.Header
-				resp.Kvs = []*storagepb.KeyValue{ev.Kv}
+				resp.Kvs = []*mvccpb.KeyValue{ev.Kv}
 				select {
 				case ch <- *resp:
 				case <-cctx.Done():

clientv3/concurrency/key.go

@@ -20,7 +20,7 @@ import (
 	"time"
 
 	v3 "github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
@@ -51,7 +51,7 @@ func waitDelete(ctx context.Context, client *v3.Client, key string, rev int64) e
 	wch := client.Watch(cctx, key, v3.WithRev(rev))
 	for wr := range wch {
 		for _, ev := range wr.Events {
-			if ev.Type == storagepb.DELETE {
+			if ev.Type == mvccpb.DELETE {
 				return nil
 			}
 		}

clientv3/integration/kv_test.go

@@ -23,8 +23,8 @@ import (
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	"github.com/coreos/etcd/integration"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/testutil"
-	"github.com/coreos/etcd/storage/storagepb"
 	"golang.org/x/net/context"
 )
 
@@ -99,7 +99,7 @@ func TestKVRange(t *testing.T) {
 		rev        int64
 		opts       []clientv3.OpOption
 
-		wantSet []*storagepb.KeyValue
+		wantSet []*mvccpb.KeyValue
 	}{
 		// range first two
 		{
@@ -107,7 +107,7 @@ func TestKVRange(t *testing.T) {
 			0,
 			nil,
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("a"), Value: nil, CreateRevision: 2, ModRevision: 2, Version: 1},
 				{Key: []byte("b"), Value: nil, CreateRevision: 3, ModRevision: 3, Version: 1},
 			},
@@ -118,7 +118,7 @@ func TestKVRange(t *testing.T) {
 			0,
 			[]clientv3.OpOption{clientv3.WithSerializable()},
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("a"), Value: nil, CreateRevision: 2, ModRevision: 2, Version: 1},
 				{Key: []byte("b"), Value: nil, CreateRevision: 3, ModRevision: 3, Version: 1},
 			},
@@ -129,7 +129,7 @@ func TestKVRange(t *testing.T) {
 			2,
 			nil,
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("a"), Value: nil, CreateRevision: 2, ModRevision: 2, Version: 1},
 			},
 		},
@@ -139,7 +139,7 @@ func TestKVRange(t *testing.T) {
 			0,
 			[]clientv3.OpOption{clientv3.WithSort(clientv3.SortByKey, clientv3.SortAscend)},
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("a"), Value: nil, CreateRevision: 2, ModRevision: 2, Version: 1},
 				{Key: []byte("b"), Value: nil, CreateRevision: 3, ModRevision: 3, Version: 1},
 				{Key: []byte("c"), Value: nil, CreateRevision: 4, ModRevision: 6, Version: 3},
@@ -154,7 +154,7 @@ func TestKVRange(t *testing.T) {
 			0,
 			[]clientv3.OpOption{clientv3.WithSort(clientv3.SortByCreateRevision, clientv3.SortDescend)},
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("fop"), Value: nil, CreateRevision: 9, ModRevision: 9, Version: 1},
 				{Key: []byte("foo/abc"), Value: nil, CreateRevision: 8, ModRevision: 8, Version: 1},
 				{Key: []byte("foo"), Value: nil, CreateRevision: 7, ModRevision: 7, Version: 1},
@@ -169,7 +169,7 @@ func TestKVRange(t *testing.T) {
 			0,
 			[]clientv3.OpOption{clientv3.WithSort(clientv3.SortByModRevision, clientv3.SortDescend)},
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("fop"), Value: nil, CreateRevision: 9, ModRevision: 9, Version: 1},
 				{Key: []byte("foo/abc"), Value: nil, CreateRevision: 8, ModRevision: 8, Version: 1},
 				{Key: []byte("foo"), Value: nil, CreateRevision: 7, ModRevision: 7, Version: 1},
@@ -184,7 +184,7 @@ func TestKVRange(t *testing.T) {
 			0,
 			[]clientv3.OpOption{clientv3.WithPrefix()},
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("foo"), Value: nil, CreateRevision: 7, ModRevision: 7, Version: 1},
 				{Key: []byte("foo/abc"), Value: nil, CreateRevision: 8, ModRevision: 8, Version: 1},
 			},
@@ -195,7 +195,7 @@ func TestKVRange(t *testing.T) {
 			0,
 			[]clientv3.OpOption{clientv3.WithFromKey()},
 
-			[]*storagepb.KeyValue{
+			[]*mvccpb.KeyValue{
 				{Key: []byte("foo"), Value: nil, CreateRevision: 7, ModRevision: 7, Version: 1},
 				{Key: []byte("foo/abc"), Value: nil, CreateRevision: 8, ModRevision: 8, Version: 1},
 				{Key: []byte("fop"), Value: nil, CreateRevision: 9, ModRevision: 9, Version: 1},
@@ -392,7 +392,7 @@ func TestKVGetRetry(t *testing.T) {
 		if gerr != nil {
 			t.Fatal(gerr)
 		}
-		wkvs := []*storagepb.KeyValue{
+		wkvs := []*mvccpb.KeyValue{
 			{
 				Key:            []byte("foo"),
 				Value:          []byte("bar"),

clientv3/integration/mirror_test.go

@@ -21,8 +21,8 @@ import (
 
 	"github.com/coreos/etcd/clientv3/mirror"
 	"github.com/coreos/etcd/integration"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/testutil"
-	"github.com/coreos/etcd/storage/storagepb"
 	"golang.org/x/net/context"
 )
 
@@ -40,7 +40,7 @@ func TestMirrorSync(t *testing.T) {
 
 	syncer := mirror.NewSyncer(c, "", 0)
 	gch, ech := syncer.SyncBase(context.TODO())
-	wkvs := []*storagepb.KeyValue{{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1}}
+	wkvs := []*mvccpb.KeyValue{{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1}}
 
 	for g := range gch {
 		if !reflect.DeepEqual(g.Kvs, wkvs) {
@@ -61,7 +61,7 @@ func TestMirrorSync(t *testing.T) {
 
 	select {
 	case r := <-wch:
-		wkv := &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 2}
+		wkv := &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 2}
 		if !reflect.DeepEqual(r.Events[0].Kv, wkv) {
 			t.Fatalf("kv = %v, want %v", r.Events[0].Kv, wkv)
 		}

clientv3/integration/watch_test.go

@@ -25,8 +25,8 @@ import (
 	"github.com/coreos/etcd/etcdserver/api/v3rpc"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	"github.com/coreos/etcd/integration"
+	mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/testutil"
-	storagepb "github.com/coreos/etcd/storage/storagepb"
 	"golang.org/x/net/context"
 )
 
@@ -419,7 +419,7 @@ func testWatchWithProgressNotify(t *testing.T, watchOnPut bool) {
 		}
 		if watchOnPut { // wait for put if watch on the put key
 			ev := []*clientv3.Event{{Type: clientv3.EventTypePut,
-				Kv: &storagepb.KeyValue{Key: []byte("foox"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1}}}
+				Kv: &mvccpb.KeyValue{Key: []byte("foox"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1}}}
 			if !reflect.DeepEqual(ev, resp.Events) {
 				t.Fatalf("expected %+v, got %+v", ev, resp.Events)
 			}
@@ -457,7 +457,7 @@ func TestWatchEventType(t *testing.T) {
 	}
 
 	tests := []struct {
-		et       storagepb.Event_EventType
+		et       mvccpb.Event_EventType
 		isCreate bool
 		isModify bool
 	}{{

clientv3/watch.go

@@ -20,17 +20,17 @@ import (
 
 	v3rpc "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	storagepb "github.com/coreos/etcd/storage/storagepb"
+	mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 )
 
 const (
-	EventTypeDelete = storagepb.DELETE
-	EventTypePut    = storagepb.PUT
+	EventTypeDelete = mvccpb.DELETE
+	EventTypePut    = mvccpb.PUT
 )
 
-type Event storagepb.Event
+type Event mvccpb.Event
 
 type WatchChan <-chan WatchResponse
 

clientv3/watch_test.go

@@ -17,7 +17,7 @@ package clientv3
 import (
 	"testing"
 
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
 func TestEvent(t *testing.T) {
@@ -28,7 +28,7 @@ func TestEvent(t *testing.T) {
 	}{{
 		ev: &Event{
 			Type: EventTypePut,
-			Kv: &storagepb.KeyValue{
+			Kv: &mvccpb.KeyValue{
 				CreateRevision: 3,
 				ModRevision:    3,
 			},
@@ -37,7 +37,7 @@ func TestEvent(t *testing.T) {
 	}, {
 		ev: &Event{
 			Type: EventTypePut,
-			Kv: &storagepb.KeyValue{
+			Kv: &mvccpb.KeyValue{
 				CreateRevision: 3,
 				ModRevision:    4,
 			},

compactor/compactor.go

@@ -19,7 +19,7 @@ import (
 	"time"
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"github.com/coreos/etcd/storage"
+	"github.com/coreos/etcd/mvcc"
 	"github.com/coreos/pkg/capnslog"
 	"github.com/jonboulle/clockwork"
 	"golang.org/x/net/context"
@@ -96,7 +96,7 @@ func (t *Periodic) Run() {
 
 			plog.Noticef("Starting auto-compaction at revision %d", rev)
 			_, err := t.c.Compact(t.ctx, &pb.CompactionRequest{Revision: rev})
-			if err == nil || err == storage.ErrCompacted {
+			if err == nil || err == mvcc.ErrCompacted {
 				t.revs = make([]int64, 0)
 				last = clock.Now()
 				plog.Noticef("Finished auto-compaction at revision %d", rev)

contrib/recipes/barrier.go

@@ -16,7 +16,7 @@ package recipe
 
 import (
 	v3 "github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
@@ -60,6 +60,6 @@ func (b *Barrier) Wait() error {
 		b.client,
 		b.key,
 		resp.Header.Revision,
-		[]storagepb.Event_EventType{storagepb.PUT, storagepb.DELETE})
+		[]mvccpb.Event_EventType{mvccpb.PUT, mvccpb.DELETE})
 	return err
 }

contrib/recipes/client.go

@@ -18,7 +18,7 @@ import (
 	"errors"
 
 	v3 "github.com/coreos/etcd/clientv3"
-	spb "github.com/coreos/etcd/storage/storagepb"
+	spb "github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 

contrib/recipes/double_barrier.go

@@ -16,7 +16,7 @@ package recipe
 
 import (
 	"github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
@@ -67,7 +67,7 @@ func (b *DoubleBarrier) Enter() error {
 		b.client,
 		b.key+"/ready",
 		ek.Revision(),
-		[]storagepb.Event_EventType{storagepb.PUT})
+		[]mvccpb.Event_EventType{mvccpb.PUT})
 	return err
 }
 
@@ -109,7 +109,7 @@ func (b *DoubleBarrier) Leave() error {
 			b.client,
 			string(highest.Key),
 			highest.ModRevision,
-			[]storagepb.Event_EventType{storagepb.DELETE})
+			[]mvccpb.Event_EventType{mvccpb.DELETE})
 		if err != nil {
 			return err
 		}
@@ -126,7 +126,7 @@ func (b *DoubleBarrier) Leave() error {
 		b.client,
 		key,
 		lowest.ModRevision,
-		[]storagepb.Event_EventType{storagepb.DELETE})
+		[]mvccpb.Event_EventType{mvccpb.DELETE})
 	if err != nil {
 		return err
 	}

contrib/recipes/priority_queue.go

@@ -18,7 +18,7 @@ import (
 	"fmt"
 
 	v3 "github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
@@ -65,7 +65,7 @@ func (q *PriorityQueue) Dequeue() (string, error) {
 		q.client,
 		q.key,
 		resp.Header.Revision,
-		[]storagepb.Event_EventType{storagepb.PUT})
+		[]mvccpb.Event_EventType{mvccpb.PUT})
 	if err != nil {
 		return "", err
 	}

contrib/recipes/queue.go

@@ -16,7 +16,7 @@ package recipe
 
 import (
 	v3 "github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
@@ -61,7 +61,7 @@ func (q *Queue) Dequeue() (string, error) {
 		q.client,
 		q.keyPrefix,
 		resp.Header.Revision,
-		[]storagepb.Event_EventType{storagepb.PUT})
+		[]mvccpb.Event_EventType{mvccpb.PUT})
 	if err != nil {
 		return "", err
 	}

contrib/recipes/rwmutex.go

@@ -16,7 +16,7 @@ package recipe
 
 import (
 	v3 "github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
@@ -91,7 +91,7 @@ func (rwm *RWMutex) waitOnLowest() error {
 		rwm.client,
 		string(lastKey.Kvs[0].Key),
 		rwm.myKey.Revision(),
-		[]storagepb.Event_EventType{storagepb.DELETE})
+		[]mvccpb.Event_EventType{mvccpb.DELETE})
 	return err
 }
 

contrib/recipes/watch.go

@@ -16,12 +16,12 @@ package recipe
 
 import (
 	"github.com/coreos/etcd/clientv3"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"golang.org/x/net/context"
 )
 
 // WaitEvents waits on a key until it observes the given events and returns the final one.
-func WaitEvents(c *clientv3.Client, key string, rev int64, evs []storagepb.Event_EventType) (*clientv3.Event, error) {
+func WaitEvents(c *clientv3.Client, key string, rev int64, evs []mvccpb.Event_EventType) (*clientv3.Event, error) {
 	wc := c.Watch(context.Background(), key, clientv3.WithRev(rev))
 	if wc == nil {
 		return nil, ErrNoWatcher
@@ -29,7 +29,7 @@ func WaitEvents(c *clientv3.Client, key string, rev int64, evs []storagepb.Event
 	return waitEvents(wc, evs), nil
 }
 
-func WaitPrefixEvents(c *clientv3.Client, prefix string, rev int64, evs []storagepb.Event_EventType) (*clientv3.Event, error) {
+func WaitPrefixEvents(c *clientv3.Client, prefix string, rev int64, evs []mvccpb.Event_EventType) (*clientv3.Event, error) {
 	wc := c.Watch(context.Background(), prefix, clientv3.WithPrefix(), clientv3.WithRev(rev))
 	if wc == nil {
 		return nil, ErrNoWatcher
@@ -37,7 +37,7 @@ func WaitPrefixEvents(c *clientv3.Client, prefix string, rev int64, evs []storag
 	return waitEvents(wc, evs), nil
 }
 
-func waitEvents(wc clientv3.WatchChan, evs []storagepb.Event_EventType) *clientv3.Event {
+func waitEvents(wc clientv3.WatchChan, evs []mvccpb.Event_EventType) *clientv3.Event {
 	i := 0
 	for wresp := range wc {
 		for _, ev := range wresp.Events {

e2e/ctl_v3_alarm_test.go

@@ -31,7 +31,7 @@ func alarmTest(cx ctlCtx) {
 	// test big put (to be rejected, and trigger quota alarm)
 	bigbuf := strings.Repeat("a", int(cx.quotaBackendBytes))
 	if err := ctlV3Put(cx, "abc", bigbuf, ""); err != nil {
-		if !strings.Contains(err.Error(), "etcdserver: storage: database space exceeded") {
+		if !strings.Contains(err.Error(), "etcdserver: mvcc: database space exceeded") {
 			cx.t.Fatal(err)
 		}
 	}
@@ -41,7 +41,7 @@ func alarmTest(cx ctlCtx) {
 
 	// alarm is on rejecting Puts and Txns
 	if err := ctlV3Put(cx, "def", smallbuf, ""); err != nil {
-		if !strings.Contains(err.Error(), "etcdserver: storage: database space exceeded") {
+		if !strings.Contains(err.Error(), "etcdserver: mvcc: database space exceeded") {
 			cx.t.Fatal(err)
 		}
 	}

etcdctl/READMEv3.md

@@ -723,7 +723,7 @@ On success, prints a line of JSON encoding the database hash, revision, total ke
 
 
 [etcdrpc]: ../etcdserver/etcdserverpb/rpc.proto
-[storagerpc]: ../storage/storagepb/kv.proto
+[storagerpc]: ../mvcc/mvccpb/kv.proto
 
 ## Compatibility Support
 

etcdctl/ctlv3/command/make_mirror_command.go

@@ -23,7 +23,7 @@ import (
 	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/clientv3/mirror"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 )
@@ -125,10 +125,10 @@ func makeMirror(ctx context.Context, c *clientv3.Client, dc *clientv3.Client) er
 				ops = []clientv3.Op{}
 			}
 			switch ev.Type {
-			case storagepb.PUT:
+			case mvccpb.PUT:
 				ops = append(ops, clientv3.OpPut(string(ev.Kv.Key), string(ev.Kv.Value)))
 				atomic.AddInt64(&total, 1)
-			case storagepb.DELETE, storagepb.EXPIRE:
+			case mvccpb.DELETE, mvccpb.EXPIRE:
 				ops = append(ops, clientv3.OpDelete(string(ev.Kv.Key)))
 				atomic.AddInt64(&total, 1)
 			default:

etcdctl/ctlv3/command/printer.go

@@ -23,7 +23,7 @@ import (
 
 	v3 "github.com/coreos/etcd/clientv3"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	spb "github.com/coreos/etcd/storage/storagepb"
+	spb "github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/dustin/go-humanize"
 	"github.com/olekukonko/tablewriter"
 )

etcdctl/ctlv3/command/snapshot_command.go

@@ -28,12 +28,12 @@ import (
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/etcdserver/membership"
+	"github.com/coreos/etcd/mvcc"
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/fileutil"
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/etcd/raft"
 	"github.com/coreos/etcd/raft/raftpb"
-	"github.com/coreos/etcd/storage"
-	"github.com/coreos/etcd/storage/backend"
 	"github.com/coreos/etcd/wal"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
@@ -275,7 +275,7 @@ func makeDB(snapdir, dbfile string) {
 	// update consistentIndex so applies go through on etcdserver despite
 	// having a new raft instance
 	be := backend.NewDefaultBackend(dbpath)
-	s := storage.NewStore(be, nil, &initIndex{})
+	s := mvcc.NewStore(be, nil, &initIndex{})
 	id := s.TxnBegin()
 	btx := be.BatchTx()
 	del := func(k, v []byte) error {

etcdctl/ctlv3/command/util.go

@@ -19,7 +19,7 @@ import (
 	"fmt"
 	"regexp"
 
-	pb "github.com/coreos/etcd/storage/storagepb"
+	pb "github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 )

etcdserver/api/v3rpc/maintenance.go

@@ -19,8 +19,8 @@ import (
 
 	"github.com/coreos/etcd/etcdserver"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/types"
-	"github.com/coreos/etcd/storage/backend"
 	"github.com/coreos/etcd/version"
 	"golang.org/x/net/context"
 )

etcdserver/api/v3rpc/rpctypes/error.go

@@ -23,9 +23,9 @@ var (
 	ErrEmptyKey     = grpc.Errorf(codes.InvalidArgument, "etcdserver: key is not provided")
 	ErrTooManyOps   = grpc.Errorf(codes.InvalidArgument, "etcdserver: too many operations in txn request")
 	ErrDuplicateKey = grpc.Errorf(codes.InvalidArgument, "etcdserver: duplicate key given in txn request")
-	ErrCompacted    = grpc.Errorf(codes.OutOfRange, "etcdserver: storage: required revision has been compacted")
-	ErrFutureRev    = grpc.Errorf(codes.OutOfRange, "etcdserver: storage: required revision is a future revision")
-	ErrNoSpace      = grpc.Errorf(codes.ResourceExhausted, "etcdserver: storage: database space exceeded")
+	ErrCompacted    = grpc.Errorf(codes.OutOfRange, "etcdserver: mvcc: required revision has been compacted")
+	ErrFutureRev    = grpc.Errorf(codes.OutOfRange, "etcdserver: mvcc: required revision is a future revision")
+	ErrNoSpace      = grpc.Errorf(codes.ResourceExhausted, "etcdserver: mvcc: database space exceeded")
 
 	ErrLeaseNotFound = grpc.Errorf(codes.NotFound, "etcdserver: requested lease not found")
 	ErrLeaseExist    = grpc.Errorf(codes.FailedPrecondition, "etcdserver: lease already exists")

etcdserver/api/v3rpc/util.go

@@ -19,16 +19,16 @@ import (
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage"
+	"github.com/coreos/etcd/mvcc"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 )
 
 func togRPCError(err error) error {
 	switch err {
-	case storage.ErrCompacted:
+	case mvcc.ErrCompacted:
 		return rpctypes.ErrCompacted
-	case storage.ErrFutureRev:
+	case mvcc.ErrFutureRev:
 		return rpctypes.ErrFutureRev
 	case lease.ErrLeaseNotFound:
 		return rpctypes.ErrLeaseNotFound

etcdserver/api/v3rpc/watch.go

@@ -21,15 +21,15 @@ import (
 
 	"github.com/coreos/etcd/etcdserver"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"github.com/coreos/etcd/storage"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
 type watchServer struct {
 	clusterID int64
 	memberID  int64
 	raftTimer etcdserver.RaftTimer
-	watchable storage.Watchable
+	watchable mvcc.Watchable
 }
 
 func NewWatchServer(s *etcdserver.EtcdServer) pb.WatchServer {
@@ -71,7 +71,7 @@ const (
 )
 
 // serverWatchStream is an etcd server side stream. It receives requests
-// from client side gRPC stream. It receives watch events from storage.WatchStream,
+// from client side gRPC stream. It receives watch events from mvcc.WatchStream,
 // and creates responses that forwarded to gRPC stream.
 // It also forwards control message like watch created and canceled.
 type serverWatchStream struct {
@@ -80,12 +80,12 @@ type serverWatchStream struct {
 	raftTimer etcdserver.RaftTimer
 
 	gRPCStream  pb.Watch_WatchServer
-	watchStream storage.WatchStream
+	watchStream mvcc.WatchStream
 	ctrlStream  chan *pb.WatchResponse
 
 	// progress tracks the watchID that stream might need to send
 	// progress to.
-	progress map[storage.WatchID]bool
+	progress map[mvcc.WatchID]bool
 	// mu protects progress
 	mu sync.Mutex
 
@@ -102,7 +102,7 @@ func (ws *watchServer) Watch(stream pb.Watch_WatchServer) error {
 		watchStream: ws.watchable.NewWatchStream(),
 		// chan for sending control response like watcher created and canceled.
 		ctrlStream: make(chan *pb.WatchResponse, ctrlStreamBufLen),
-		progress:   make(map[storage.WatchID]bool),
+		progress:   make(map[mvcc.WatchID]bool),
 		closec:     make(chan struct{}),
 	}
 	defer sws.close()
@@ -154,7 +154,7 @@ func (sws *serverWatchStream) recvLoop() error {
 		case *pb.WatchRequest_CancelRequest:
 			if uv.CancelRequest != nil {
 				id := uv.CancelRequest.WatchId
-				err := sws.watchStream.Cancel(storage.WatchID(id))
+				err := sws.watchStream.Cancel(mvcc.WatchID(id))
 				if err == nil {
 					sws.ctrlStream <- &pb.WatchResponse{
 						Header:   sws.newResponseHeader(sws.watchStream.Rev()),
@@ -162,7 +162,7 @@ func (sws *serverWatchStream) recvLoop() error {
 						Canceled: true,
 					}
 					sws.mu.Lock()
-					delete(sws.progress, storage.WatchID(id))
+					delete(sws.progress, mvcc.WatchID(id))
 					sws.mu.Unlock()
 				}
 			}
@@ -175,9 +175,9 @@ func (sws *serverWatchStream) recvLoop() error {
 
 func (sws *serverWatchStream) sendLoop() {
 	// watch ids that are currently active
-	ids := make(map[storage.WatchID]struct{})
+	ids := make(map[mvcc.WatchID]struct{})
 	// watch responses pending on a watch id creation message
-	pending := make(map[storage.WatchID][]*pb.WatchResponse)
+	pending := make(map[mvcc.WatchID][]*pb.WatchResponse)
 
 	interval := GetProgressReportInterval()
 	progressTicker := time.NewTicker(interval)
@@ -190,11 +190,11 @@ func (sws *serverWatchStream) sendLoop() {
 				return
 			}
 
-			// TODO: evs is []storagepb.Event type
-			// either return []*storagepb.Event from storage package
-			// or define protocol buffer with []storagepb.Event.
+			// TODO: evs is []mvccpb.Event type
+			// either return []*mvccpb.Event from the mvcc package
+			// or define protocol buffer with []mvccpb.Event.
 			evs := wresp.Events
-			events := make([]*storagepb.Event, len(evs))
+			events := make([]*mvccpb.Event, len(evs))
 			for i := range evs {
 				events[i] = &evs[i]
 			}
@@ -213,7 +213,7 @@ func (sws *serverWatchStream) sendLoop() {
 				continue
 			}
 
-			storage.ReportEventReceived()
+			mvcc.ReportEventReceived()
 			if err := sws.gRPCStream.Send(wr); err != nil {
 				return
 			}
@@ -234,7 +234,7 @@ func (sws *serverWatchStream) sendLoop() {
 			}
 
 			// track id creation
-			wid := storage.WatchID(c.WatchId)
+			wid := mvcc.WatchID(c.WatchId)
 			if c.Canceled {
 				delete(ids, wid)
 				continue
@@ -243,7 +243,7 @@ func (sws *serverWatchStream) sendLoop() {
 				// flush buffered events
 				ids[wid] = struct{}{}
 				for _, v := range pending[wid] {
-					storage.ReportEventReceived()
+					mvcc.ReportEventReceived()
 					if err := sws.gRPCStream.Send(v); err != nil {
 						return
 					}
@@ -260,11 +260,11 @@ func (sws *serverWatchStream) sendLoop() {
 		case <-sws.closec:
 			// drain the chan to clean up pending events
 			for range sws.watchStream.Chan() {
-				storage.ReportEventReceived()
+				mvcc.ReportEventReceived()
 			}
 			for _, wrs := range pending {
 				for range wrs {
-					storage.ReportEventReceived()
+					mvcc.ReportEventReceived()
 				}
 			}
 		}

etcdserver/apply.go

@@ -21,9 +21,9 @@ import (
 
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/lease"
+	"github.com/coreos/etcd/mvcc"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/types"
-	dstorage "github.com/coreos/etcd/storage"
-	"github.com/coreos/etcd/storage/storagepb"
 	"github.com/gogo/protobuf/proto"
 )
 
@@ -166,7 +166,7 @@ func (a *applierV3backend) Range(txnID int64, r *pb.RangeRequest) (*pb.RangeResp
 	resp.Header = &pb.ResponseHeader{}
 
 	var (
-		kvs []storagepb.KeyValue
+		kvs []mvccpb.KeyValue
 		rev int64
 		err error
 	)
@@ -292,12 +292,12 @@ func (a *applierV3backend) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
 func (a *applierV3backend) applyCompare(c *pb.Compare) (int64, bool) {
 	ckvs, rev, err := a.s.KV().Range(c.Key, nil, 1, 0)
 	if err != nil {
-		if err == dstorage.ErrTxnIDMismatch {
+		if err == mvcc.ErrTxnIDMismatch {
 			panic("unexpected txn ID mismatch error")
 		}
 		return rev, false
 	}
-	var ckv storagepb.KeyValue
+	var ckv mvccpb.KeyValue
 	if len(ckvs) != 0 {
 		ckv = ckvs[0]
 	} else {
@@ -557,7 +557,7 @@ func (a *quotaApplierV3) LeaseGrant(lc *pb.LeaseGrantRequest) (*pb.LeaseGrantRes
 	return resp, err
 }
 
-type kvSort struct{ kvs []storagepb.KeyValue }
+type kvSort struct{ kvs []mvccpb.KeyValue }
 
 func (s *kvSort) Swap(i, j int) {
 	t := s.kvs[i]
@@ -625,10 +625,10 @@ func (a *applierV3backend) checkRequestRange(reqs []*pb.RequestUnion) error {
 		}
 
 		if greq.Revision > a.s.KV().Rev() {
-			return dstorage.ErrFutureRev
+			return mvcc.ErrFutureRev
 		}
 		if greq.Revision < a.s.KV().FirstRev() {
-			return dstorage.ErrCompacted
+			return mvcc.ErrCompacted
 		}
 	}
 	return nil

etcdserver/consistent_index.go

@@ -19,7 +19,7 @@ import (
 )
 
 // consistentIndex represents the offset of an entry in a consistent replica log.
-// It implements the storage.ConsistentIndexGetter interface.
+// It implements the mvcc.ConsistentIndexGetter interface.
 // It is always set to the offset of current entry before executing the entry,
 // so ConsistentWatchableKV could get the consistent index from it.
 type consistentIndex uint64

etcdserver/etcdserverpb/etcdserver.pb.go

@@ -110,23 +110,23 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion1
 
 type Request struct {
-	ID               uint64 `protobuf:"varint,1,opt,name=ID,json=iD" json:"ID"`
-	Method           string `protobuf:"bytes,2,opt,name=Method,json=method" json:"Method"`
-	Path             string `protobuf:"bytes,3,opt,name=Path,json=path" json:"Path"`
-	Val              string `protobuf:"bytes,4,opt,name=Val,json=val" json:"Val"`
-	Dir              bool   `protobuf:"varint,5,opt,name=Dir,json=dir" json:"Dir"`
-	PrevValue        string `protobuf:"bytes,6,opt,name=PrevValue,json=prevValue" json:"PrevValue"`
-	PrevIndex        uint64 `protobuf:"varint,7,opt,name=PrevIndex,json=prevIndex" json:"PrevIndex"`
-	PrevExist        *bool  `protobuf:"varint,8,opt,name=PrevExist,json=prevExist" json:"PrevExist,omitempty"`
-	Expiration       int64  `protobuf:"varint,9,opt,name=Expiration,json=expiration" json:"Expiration"`
-	Wait             bool   `protobuf:"varint,10,opt,name=Wait,json=wait" json:"Wait"`
-	Since            uint64 `protobuf:"varint,11,opt,name=Since,json=since" json:"Since"`
-	Recursive        bool   `protobuf:"varint,12,opt,name=Recursive,json=recursive" json:"Recursive"`
-	Sorted           bool   `protobuf:"varint,13,opt,name=Sorted,json=sorted" json:"Sorted"`
-	Quorum           bool   `protobuf:"varint,14,opt,name=Quorum,json=quorum" json:"Quorum"`
-	Time             int64  `protobuf:"varint,15,opt,name=Time,json=time" json:"Time"`
-	Stream           bool   `protobuf:"varint,16,opt,name=Stream,json=stream" json:"Stream"`
-	Refresh          *bool  `protobuf:"varint,17,opt,name=Refresh,json=refresh" json:"Refresh,omitempty"`
+	ID               uint64 `protobuf:"varint,1,opt,name=ID" json:"ID"`
+	Method           string `protobuf:"bytes,2,opt,name=Method" json:"Method"`
+	Path             string `protobuf:"bytes,3,opt,name=Path" json:"Path"`
+	Val              string `protobuf:"bytes,4,opt,name=Val" json:"Val"`
+	Dir              bool   `protobuf:"varint,5,opt,name=Dir" json:"Dir"`
+	PrevValue        string `protobuf:"bytes,6,opt,name=PrevValue" json:"PrevValue"`
+	PrevIndex        uint64 `protobuf:"varint,7,opt,name=PrevIndex" json:"PrevIndex"`
+	PrevExist        *bool  `protobuf:"varint,8,opt,name=PrevExist" json:"PrevExist,omitempty"`
+	Expiration       int64  `protobuf:"varint,9,opt,name=Expiration" json:"Expiration"`
+	Wait             bool   `protobuf:"varint,10,opt,name=Wait" json:"Wait"`
+	Since            uint64 `protobuf:"varint,11,opt,name=Since" json:"Since"`
+	Recursive        bool   `protobuf:"varint,12,opt,name=Recursive" json:"Recursive"`
+	Sorted           bool   `protobuf:"varint,13,opt,name=Sorted" json:"Sorted"`
+	Quorum           bool   `protobuf:"varint,14,opt,name=Quorum" json:"Quorum"`
+	Time             int64  `protobuf:"varint,15,opt,name=Time" json:"Time"`
+	Stream           bool   `protobuf:"varint,16,opt,name=Stream" json:"Stream"`
+	Refresh          *bool  `protobuf:"varint,17,opt,name=Refresh" json:"Refresh,omitempty"`
 	XXX_unrecognized []byte `json:"-"`
 }
 
@@ -136,8 +136,8 @@ func (*Request) ProtoMessage()               {}
 func (*Request) Descriptor() ([]byte, []int) { return fileDescriptorEtcdserver, []int{0} }
 
 type Metadata struct {
-	NodeID           uint64 `protobuf:"varint,1,opt,name=NodeID,json=nodeID" json:"NodeID"`
-	ClusterID        uint64 `protobuf:"varint,2,opt,name=ClusterID,json=clusterID" json:"ClusterID"`
+	NodeID           uint64 `protobuf:"varint,1,opt,name=NodeID" json:"NodeID"`
+	ClusterID        uint64 `protobuf:"varint,2,opt,name=ClusterID" json:"ClusterID"`
 	XXX_unrecognized []byte `json:"-"`
 }
 
@@ -1005,30 +1005,25 @@ var (
 )
 
 var fileDescriptorEtcdserver = []byte{
-	// 388 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x92, 0xd1, 0xee, 0xd2, 0x30,
-	0x14, 0xc6, 0xff, 0xdb, 0xca, 0x60, 0x15, 0x15, 0x1b, 0x62, 0x4e, 0x88, 0x41, 0x43, 0xbc, 0xf0,
-	0x4a, 0xdf, 0x01, 0xe1, 0x82, 0x44, 0x0d, 0x82, 0xd1, 0xeb, 0xba, 0x1d, 0xa1, 0x09, 0x5b, 0x47,
-	0xdb, 0x4d, 0xde, 0xc0, 0x57, 0xe3, 0xd2, 0x27, 0x30, 0xea, 0x93, 0xd8, 0x16, 0x86, 0xd5, 0x8b,
-	0x26, 0xcb, 0xef, 0xfb, 0xce, 0xe9, 0xd7, 0x73, 0x46, 0x47, 0x68, 0xf2, 0x42, 0xa3, 0x6a, 0x51,
-	0xbd, 0xac, 0x95, 0x34, 0x92, 0x0d, 0xff, 0x92, 0xfa, 0xf3, 0x64, 0xbc, 0x93, 0x3b, 0xe9, 0x85,
-	0x57, 0xee, 0xeb, 0xe2, 0x99, 0x7d, 0x23, 0xb4, 0xbf, 0xc1, 0x63, 0x83, 0xda, 0xb0, 0x31, 0x8d,
-	0x57, 0x0b, 0x88, 0x9e, 0x45, 0x2f, 0xc8, 0x9c, 0x9c, 0x7f, 0x3c, 0xbd, 0xdb, 0xc4, 0x62, 0xc1,
-	0x9e, 0xd0, 0xf4, 0x2d, 0x9a, 0xbd, 0x2c, 0x20, 0xb6, 0x4a, 0x76, 0x55, 0xd2, 0xd2, 0x33, 0x06,
-	0x94, 0xac, 0xb9, 0xd9, 0x43, 0x12, 0x68, 0xa4, 0xb6, 0x84, 0x3d, 0xa6, 0xc9, 0x47, 0x7e, 0x00,
-	0x12, 0x08, 0x49, 0xcb, 0x0f, 0x8e, 0x2f, 0x84, 0x82, 0x9e, 0xe5, 0x83, 0x8e, 0x17, 0x42, 0xb1,
-	0x19, 0xcd, 0xd6, 0x0a, 0x5b, 0x5b, 0xd3, 0x20, 0xa4, 0x41, 0x55, 0x56, 0x77, 0xb8, 0xf3, 0xac,
-	0xaa, 0x02, 0x4f, 0xd0, 0x0f, 0x82, 0x7a, 0x8f, 0xc7, 0x9d, 0x67, 0x79, 0x12, 0xda, 0xc0, 0xe0,
-	0x76, 0x4b, 0x74, 0xf1, 0x78, 0xcc, 0x9e, 0x53, 0xba, 0x3c, 0xd5, 0x42, 0x71, 0x23, 0x64, 0x05,
-	0x99, 0x35, 0x25, 0xd7, 0x46, 0x14, 0x6f, 0xdc, 0xbd, 0xed, 0x13, 0x17, 0x06, 0x68, 0x10, 0x95,
-	0x7c, 0xb5, 0x84, 0x4d, 0x68, 0x6f, 0x2b, 0xaa, 0x1c, 0xe1, 0x5e, 0x90, 0xa1, 0xa7, 0x1d, 0x72,
-	0xf7, 0x6f, 0x30, 0x6f, 0x94, 0x16, 0x2d, 0xc2, 0x30, 0x28, 0xcd, 0x54, 0x87, 0xdd, 0x4c, 0xb7,
-	0x52, 0x19, 0x2c, 0xe0, 0x7e, 0x60, 0x48, 0xb5, 0x67, 0x4e, 0x7d, 0xdf, 0x48, 0xd5, 0x94, 0xf0,
-	0x20, 0x54, 0x8f, 0x9e, 0xb9, 0x54, 0x1f, 0x44, 0x89, 0xf0, 0x30, 0x48, 0x4d, 0x8c, 0x25, 0xbe,
-	0xab, 0x51, 0xc8, 0x4b, 0x18, 0xfd, 0xd3, 0xd5, 0x33, 0x36, 0x75, 0x8b, 0xfe, 0xa2, 0x50, 0xef,
-	0xe1, 0x51, 0x30, 0x95, 0xbe, 0xba, 0xc0, 0xd9, 0x1b, 0x3a, 0xb0, 0x7b, 0xe6, 0x05, 0x37, 0xdc,
-	0x75, 0x7a, 0x27, 0x0b, 0xfc, 0xef, 0x6f, 0x48, 0x2b, 0xcf, 0xdc, 0x0b, 0x5f, 0x1f, 0x1a, 0x6d,
-	0x50, 0x59, 0x43, 0x1c, 0x6e, 0x21, 0xef, 0xf0, 0x7c, 0x74, 0xfe, 0x35, 0xbd, 0x3b, 0xff, 0x9e,
-	0x46, 0xdf, 0xed, 0xf9, 0x69, 0xcf, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x8e, 0x1a, 0x0d,
-	0xa0, 0x02, 0x00, 0x00,
+	// 320 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x91, 0x4f, 0x4f, 0xf2, 0x40,
+	0x10, 0xc6, 0x69, 0x29, 0xff, 0xf6, 0xe5, 0xd5, 0x52, 0x31, 0x4e, 0x3c, 0xa0, 0xe1, 0xe4, 0x49,
+	0xcf, 0x5e, 0x11, 0x0e, 0x1c, 0x34, 0x08, 0x46, 0xcf, 0x2b, 0x1d, 0x61, 0x13, 0x60, 0x71, 0x3a,
+	0x4b, 0xf8, 0x88, 0x1c, 0xfd, 0x04, 0x46, 0xfd, 0x22, 0xba, 0xd5, 0xc6, 0x6e, 0x3d, 0x6c, 0xd2,
+	0xfc, 0x9e, 0x67, 0x66, 0x9e, 0x99, 0x8a, 0x10, 0x79, 0x1a, 0x27, 0x48, 0x1b, 0xa4, 0xf3, 0x35,
+	0x69, 0xd6, 0x51, 0x33, 0x27, 0xeb, 0xc7, 0xe3, 0xf6, 0x4c, 0xcf, 0xf4, 0xb7, 0x70, 0x91, 0x7e,
+	0xfd, 0x78, 0xba, 0x9f, 0xbe, 0xa8, 0x8d, 0xf1, 0xd9, 0x60, 0xc2, 0x51, 0x28, 0xfc, 0x61, 0x1f,
+	0xbc, 0x53, 0xef, 0x2c, 0xe8, 0x05, 0xbb, 0xd7, 0x93, 0x52, 0xd4, 0x16, 0xd5, 0x6b, 0xe4, 0xb9,
+	0x8e, 0xc1, 0xb7, 0xb4, 0x91, 0xd1, 0x48, 0x04, 0x23, 0xc9, 0x73, 0x28, 0x3b, 0xac, 0x25, 0xca,
+	0xf7, 0x72, 0x01, 0x41, 0x11, 0xf5, 0x15, 0x41, 0xc5, 0xa2, 0x7a, 0x86, 0x8e, 0x44, 0x63, 0x44,
+	0xb8, 0xb1, 0x4e, 0x83, 0x50, 0x75, 0xbc, 0x99, 0x30, 0x5c, 0xc5, 0xb8, 0x85, 0x9a, 0x93, 0x20,
+	0x13, 0x06, 0x5b, 0x95, 0x30, 0xd4, 0x7f, 0x5b, 0x79, 0x11, 0x08, 0x31, 0xd8, 0xae, 0x15, 0x49,
+	0x56, 0x7a, 0x05, 0x0d, 0xab, 0x94, 0xf3, 0x78, 0x0f, 0x52, 0x31, 0x08, 0x67, 0xf0, 0x81, 0xa8,
+	0x4c, 0xd4, 0x6a, 0x8a, 0xf0, 0xaf, 0xd8, 0x7b, 0x8c, 0x53, 0x43, 0x89, 0xda, 0x20, 0x34, 0x1d,
+	0xb7, 0x5d, 0x7b, 0xa2, 0x89, 0x31, 0x86, 0xff, 0x45, 0x7a, 0x6b, 0x34, 0x99, 0x25, 0xec, 0x39,
+	0xd4, 0x4e, 0xbb, 0x53, 0x4b, 0x84, 0x7d, 0x27, 0x41, 0x5a, 0xcf, 0x84, 0x72, 0x09, 0xa1, 0xe3,
+	0x3c, 0x4c, 0x2f, 0xfd, 0x44, 0x98, 0xcc, 0xa1, 0x95, 0x2f, 0xd2, 0xbd, 0x14, 0x75, 0x7b, 0x63,
+	0x19, 0x4b, 0x96, 0x69, 0xe1, 0x8d, 0x8e, 0xf1, 0xcf, 0x5f, 0xb0, 0x39, 0xaf, 0x16, 0x26, 0x61,
+	0x24, 0x2b, 0xf8, 0xb9, 0xd0, 0x0b, 0x77, 0xef, 0x9d, 0xd2, 0xee, 0xa3, 0xe3, 0xbd, 0xd8, 0xf7,
+	0x66, 0xdf, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x32, 0x78, 0xf7, 0x38, 0x05, 0x02, 0x00, 0x00,
 }

etcdserver/etcdserverpb/raft_internal.pb.go

@@ -22,22 +22,22 @@ var _ = math.Inf
 // An InternalRaftRequest is the union of all requests which can be
 // sent via raft.
 type InternalRaftRequest struct {
-	ID                     uint64                         `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID                     uint64                         `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
 	V2                     *Request                       `protobuf:"bytes,2,opt,name=v2" json:"v2,omitempty"`
 	Range                  *RangeRequest                  `protobuf:"bytes,3,opt,name=range" json:"range,omitempty"`
 	Put                    *PutRequest                    `protobuf:"bytes,4,opt,name=put" json:"put,omitempty"`
-	DeleteRange            *DeleteRangeRequest            `protobuf:"bytes,5,opt,name=delete_range,json=deleteRange" json:"delete_range,omitempty"`
+	DeleteRange            *DeleteRangeRequest            `protobuf:"bytes,5,opt,name=delete_range" json:"delete_range,omitempty"`
 	Txn                    *TxnRequest                    `protobuf:"bytes,6,opt,name=txn" json:"txn,omitempty"`
 	Compaction             *CompactionRequest             `protobuf:"bytes,7,opt,name=compaction" json:"compaction,omitempty"`
-	LeaseGrant             *LeaseGrantRequest             `protobuf:"bytes,8,opt,name=lease_grant,json=leaseGrant" json:"lease_grant,omitempty"`
-	LeaseRevoke            *LeaseRevokeRequest            `protobuf:"bytes,9,opt,name=lease_revoke,json=leaseRevoke" json:"lease_revoke,omitempty"`
-	AuthEnable             *AuthEnableRequest             `protobuf:"bytes,10,opt,name=auth_enable,json=authEnable" json:"auth_enable,omitempty"`
-	AuthUserAdd            *AuthUserAddRequest            `protobuf:"bytes,11,opt,name=auth_user_add,json=authUserAdd" json:"auth_user_add,omitempty"`
-	AuthUserDelete         *AuthUserDeleteRequest         `protobuf:"bytes,12,opt,name=auth_user_delete,json=authUserDelete" json:"auth_user_delete,omitempty"`
-	AuthUserChangePassword *AuthUserChangePasswordRequest `protobuf:"bytes,13,opt,name=auth_user_change_password,json=authUserChangePassword" json:"auth_user_change_password,omitempty"`
-	AuthUserGrant          *AuthUserGrantRequest          `protobuf:"bytes,14,opt,name=auth_user_grant,json=authUserGrant" json:"auth_user_grant,omitempty"`
-	AuthRoleAdd            *AuthRoleAddRequest            `protobuf:"bytes,15,opt,name=auth_role_add,json=authRoleAdd" json:"auth_role_add,omitempty"`
-	AuthRoleGrant          *AuthRoleGrantRequest          `protobuf:"bytes,16,opt,name=auth_role_grant,json=authRoleGrant" json:"auth_role_grant,omitempty"`
+	LeaseGrant             *LeaseGrantRequest             `protobuf:"bytes,8,opt,name=lease_grant" json:"lease_grant,omitempty"`
+	LeaseRevoke            *LeaseRevokeRequest            `protobuf:"bytes,9,opt,name=lease_revoke" json:"lease_revoke,omitempty"`
+	AuthEnable             *AuthEnableRequest             `protobuf:"bytes,10,opt,name=auth_enable" json:"auth_enable,omitempty"`
+	AuthUserAdd            *AuthUserAddRequest            `protobuf:"bytes,11,opt,name=auth_user_add" json:"auth_user_add,omitempty"`
+	AuthUserDelete         *AuthUserDeleteRequest         `protobuf:"bytes,12,opt,name=auth_user_delete" json:"auth_user_delete,omitempty"`
+	AuthUserChangePassword *AuthUserChangePasswordRequest `protobuf:"bytes,13,opt,name=auth_user_change_password" json:"auth_user_change_password,omitempty"`
+	AuthUserGrant          *AuthUserGrantRequest          `protobuf:"bytes,14,opt,name=auth_user_grant" json:"auth_user_grant,omitempty"`
+	AuthRoleAdd            *AuthRoleAddRequest            `protobuf:"bytes,15,opt,name=auth_role_add" json:"auth_role_add,omitempty"`
+	AuthRoleGrant          *AuthRoleGrantRequest          `protobuf:"bytes,16,opt,name=auth_role_grant" json:"auth_role_grant,omitempty"`
 	Authenticate           *AuthenticateRequest           `protobuf:"bytes,17,opt,name=authenticate" json:"authenticate,omitempty"`
 	Alarm                  *AlarmRequest                  `protobuf:"bytes,18,opt,name=alarm" json:"alarm,omitempty"`
 }
@@ -1185,39 +1185,35 @@ var (
 )
 
 var fileDescriptorRaftInternal = []byte{
-	// 534 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x94, 0xdf, 0x6e, 0xd3, 0x30,
-	0x14, 0xc6, 0x69, 0xf7, 0x87, 0xcd, 0xfd, 0x8b, 0x07, 0xc8, 0xf4, 0x62, 0x8c, 0x22, 0x24, 0x04,
-	0x52, 0x41, 0xe3, 0x01, 0xa0, 0xb4, 0x15, 0x1a, 0x02, 0x69, 0x8a, 0xe0, 0x3a, 0x72, 0x93, 0xb3,
-	0xae, 0x22, 0x8d, 0x83, 0xe3, 0x94, 0xf1, 0x86, 0xbb, 0xe4, 0x11, 0x80, 0xb7, 0xe0, 0x0e, 0xfb,
-	0x24, 0x71, 0x9a, 0xcd, 0xbd, 0xa8, 0x94, 0x7c, 0xe7, 0x3b, 0xbf, 0xf3, 0xc5, 0x47, 0x2e, 0x39,
-	0x92, 0xfc, 0x42, 0xf9, 0xcb, 0x58, 0x81, 0x8c, 0x79, 0x34, 0x4a, 0xa4, 0x50, 0x82, 0xb6, 0x41,
-	0x05, 0x61, 0x0a, 0x72, 0x0d, 0x32, 0x99, 0x0f, 0xee, 0x2f, 0xc4, 0x42, 0x60, 0xe1, 0x95, 0x79,
-	0xca, 0x3d, 0x83, 0x7e, 0xe5, 0x29, 0x94, 0x43, 0x99, 0x04, 0xf9, 0xe3, 0xf0, 0xdf, 0x01, 0x39,
-	0x3a, 0x2b, 0x98, 0x9e, 0x1e, 0xe0, 0xc1, 0xf7, 0x0c, 0x52, 0x45, 0xbb, 0xa4, 0x79, 0x36, 0x65,
-	0x8d, 0x93, 0xc6, 0xf3, 0x5d, 0xaf, 0xb9, 0x9c, 0xd2, 0x67, 0xa4, 0xb9, 0x3e, 0x65, 0x4d, 0xfd,
-	0xde, 0x3a, 0x7d, 0x30, 0xda, 0x9c, 0x3a, 0x2a, 0x5a, 0x3c, 0x6d, 0xa0, 0xaf, 0xc9, 0x9e, 0xe4,
-	0xf1, 0x02, 0xd8, 0x0e, 0x3a, 0x07, 0x37, 0x9c, 0xa6, 0x54, 0xda, 0x73, 0x23, 0x7d, 0x41, 0x76,
-	0x92, 0x4c, 0xb1, 0x5d, 0xf4, 0xb3, 0xba, 0xff, 0x3c, 0x2b, 0xf3, 0x78, 0xc6, 0x44, 0x27, 0xa4,
-	0x1d, 0x42, 0x04, 0x0a, 0xfc, 0x7c, 0xc8, 0x1e, 0x36, 0x9d, 0xd4, 0x9b, 0xa6, 0xe8, 0xa8, 0x8d,
-	0x6a, 0x85, 0x95, 0x66, 0x06, 0xaa, 0xab, 0x98, 0xed, 0xbb, 0x06, 0x7e, 0xb9, 0x8a, 0xed, 0x40,
-	0x6d, 0xa2, 0x6f, 0x09, 0x09, 0xc4, 0x2a, 0xe1, 0x81, 0x5a, 0x8a, 0x98, 0xdd, 0xc5, 0x96, 0xc7,
-	0xf5, 0x96, 0x89, 0xad, 0x97, 0x9d, 0x1b, 0x2d, 0xf4, 0x1d, 0x69, 0x45, 0xc0, 0x53, 0xf0, 0x17,
-	0x3a, 0xb1, 0x62, 0x07, 0x2e, 0xc2, 0x27, 0x63, 0xf8, 0x60, 0xea, 0x96, 0x10, 0x59, 0xc9, 0x7c,
-	0x73, 0x4e, 0x90, 0xb0, 0x16, 0xdf, 0x80, 0x1d, 0xba, 0xbe, 0x19, 0x11, 0x1e, 0x1a, 0xec, 0x37,
-	0x47, 0x95, 0x66, 0x62, 0xf0, 0x4c, 0x5d, 0xfa, 0x10, 0xf3, 0x79, 0x04, 0x8c, 0xb8, 0x62, 0x8c,
-	0xb5, 0x61, 0x86, 0x75, 0x1b, 0x83, 0x5b, 0x89, 0x4e, 0x49, 0x07, 0x09, 0x99, 0xf6, 0xfb, 0x3c,
-	0x0c, 0x59, 0xcb, 0x95, 0xc3, 0x30, 0xbe, 0xea, 0xb7, 0x71, 0x18, 0xda, 0x1c, 0xbc, 0xd2, 0xe8,
-	0x67, 0xd2, 0xaf, 0x28, 0xf9, 0x52, 0x58, 0x1b, 0x41, 0x4f, 0xdd, 0xa0, 0x62, 0x99, 0x05, 0xab,
-	0xcb, 0x6b, 0x32, 0xbd, 0x20, 0x8f, 0x2a, 0x5c, 0x70, 0x69, 0xd6, 0xeb, 0x27, 0x3c, 0x4d, 0x7f,
-	0x08, 0x19, 0xb2, 0x0e, 0x72, 0x5f, 0xba, 0xb9, 0x13, 0x34, 0x9f, 0x17, 0xde, 0x92, 0xff, 0x90,
-	0x3b, 0xcb, 0xf4, 0x23, 0xe9, 0x55, 0x73, 0xf2, 0x4d, 0x76, 0x91, 0x3e, 0x74, 0xd3, 0x6b, 0xcb,
-	0xec, 0xf0, 0x4d, 0xd5, 0x1e, 0xa4, 0x14, 0x11, 0xe0, 0x41, 0xf6, 0xb6, 0x1d, 0xa4, 0xa7, 0x1d,
-	0x37, 0x0f, 0xb2, 0xd0, 0x6c, 0x22, 0xa4, 0xe4, 0x89, 0xfa, 0xdb, 0x12, 0x99, 0x9e, 0xdb, 0x89,
-	0xac, 0x4a, 0x67, 0xa4, 0x6d, 0x04, 0x88, 0xd5, 0x32, 0xe0, 0x7a, 0x21, 0xf7, 0x10, 0xf4, 0xe4,
-	0x36, 0xa8, 0x74, 0x94, 0x9c, 0x5a, 0x9b, 0xb9, 0xfa, 0x3c, 0xe2, 0x72, 0xc5, 0xa8, 0xeb, 0xea,
-	0x8f, 0x4d, 0xc9, 0x5e, 0x7d, 0x34, 0x0e, 0x7b, 0xa4, 0x33, 0x5b, 0x25, 0xea, 0xa7, 0x07, 0x69,
-	0x22, 0xe2, 0x14, 0xde, 0xf7, 0xaf, 0xff, 0x1c, 0xdf, 0xb9, 0xfe, 0x7b, 0xdc, 0xf8, 0xa5, 0x7f,
-	0xbf, 0xf5, 0x6f, 0xbe, 0x8f, 0xff, 0x52, 0x6f, 0xfe, 0x07, 0x00, 0x00, 0xff, 0xff, 0xee, 0xd7,
-	0xc5, 0x26, 0xfd, 0x04, 0x00, 0x00,
+	// 473 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x93, 0xdf, 0x6e, 0xd3, 0x30,
+	0x14, 0xc6, 0x69, 0xf7, 0x8f, 0x9d, 0xb6, 0xb4, 0x74, 0x20, 0x99, 0x5e, 0x8c, 0xad, 0x08, 0x09,
+	0x84, 0x54, 0xa4, 0x0d, 0xc1, 0x05, 0xe2, 0xa2, 0x6c, 0x13, 0x9a, 0x84, 0xd0, 0x14, 0xc1, 0x75,
+	0xe4, 0x26, 0x87, 0xae, 0x22, 0xb5, 0x83, 0xe3, 0x94, 0xf1, 0x50, 0xbc, 0xc7, 0x2e, 0x79, 0x04,
+	0xe0, 0x49, 0xb0, 0x4f, 0xe2, 0x35, 0xe9, 0xdc, 0x8b, 0x48, 0xde, 0xce, 0xef, 0xf7, 0x9d, 0xe4,
+	0xab, 0x0c, 0x7b, 0x8a, 0x7f, 0xd5, 0xe1, 0x4c, 0x68, 0x54, 0x82, 0x27, 0xa3, 0x54, 0x49, 0x2d,
+	0xfb, 0x6d, 0xd4, 0x51, 0x9c, 0xa1, 0x5a, 0xa0, 0x4a, 0x27, 0x83, 0x07, 0x53, 0x39, 0x95, 0x34,
+	0x78, 0x69, 0x4f, 0x05, 0x33, 0xe8, 0x2d, 0x99, 0xf2, 0x3f, 0xbb, 0x2a, 0x8d, 0x8a, 0xe3, 0xf0,
+	0xd7, 0x0e, 0xec, 0x9d, 0x97, 0x99, 0x81, 0x59, 0x10, 0xe0, 0xf7, 0x1c, 0x33, 0xdd, 0x07, 0x68,
+	0x9e, 0x9f, 0xb2, 0xc6, 0x41, 0xe3, 0xd9, 0x66, 0xff, 0x10, 0x9a, 0x8b, 0x23, 0xd6, 0x34, 0xe7,
+	0xd6, 0xd1, 0xc3, 0x51, 0x75, 0xe3, 0xc8, 0xe1, 0xcf, 0x61, 0x4b, 0x71, 0x31, 0x45, 0xb6, 0x41,
+	0xd4, 0x60, 0x85, 0xb2, 0x23, 0x87, 0x3e, 0x85, 0x8d, 0x34, 0xd7, 0x6c, 0x93, 0x40, 0x56, 0x07,
+	0x2f, 0xf2, 0x9b, 0x17, 0x78, 0x0d, 0xed, 0x18, 0x13, 0xd4, 0x18, 0x16, 0xc1, 0x5b, 0xc4, 0x1f,
+	0xd4, 0xf9, 0x53, 0x22, 0x56, 0xe3, 0xf5, 0x95, 0x60, 0xdb, 0xbe, 0xf8, 0xcf, 0x57, 0xc2, 0x61,
+	0xc7, 0x00, 0x91, 0x9c, 0xa7, 0x3c, 0xd2, 0x33, 0x29, 0xd8, 0x0e, 0xd1, 0x8f, 0xeb, 0xf4, 0xc9,
+	0xcd, 0xdc, 0x49, 0xaf, 0xa0, 0x95, 0x20, 0xcf, 0x30, 0x9c, 0x9a, 0x77, 0xd2, 0xec, 0xae, 0xcf,
+	0xfa, 0x68, 0x81, 0x0f, 0x76, 0x5e, 0xf9, 0x92, 0xc2, 0x52, 0xb8, 0x90, 0xdf, 0x90, 0xed, 0xfa,
+	0xbe, 0x84, 0xb4, 0x80, 0x80, 0xca, 0x36, 0x9e, 0xeb, 0xcb, 0x10, 0x05, 0x9f, 0x24, 0xc8, 0xc0,
+	0xb7, 0x6d, 0x6c, 0x80, 0x33, 0x9a, 0x3b, 0xeb, 0x0d, 0x74, 0xc8, 0xca, 0x0d, 0x13, 0xf2, 0x38,
+	0x66, 0x2d, 0xdf, 0x3a, 0xeb, 0x7d, 0x31, 0x7f, 0x8d, 0xe3, 0xd8, 0x89, 0xef, 0xa0, 0xb7, 0x14,
+	0x8b, 0xea, 0x59, 0x9b, 0xdc, 0x27, 0x7e, 0xb7, 0x2c, 0xbf, 0xd4, 0x3f, 0xc1, 0xa3, 0xa5, 0x1e,
+	0x5d, 0xda, 0x9f, 0x24, 0x4c, 0x79, 0x96, 0xfd, 0x90, 0x2a, 0x66, 0x1d, 0xca, 0x79, 0xe1, 0xcf,
+	0x39, 0x21, 0xf8, 0xa2, 0x64, 0x5d, 0xde, 0x5b, 0xe8, 0x2e, 0xf3, 0x8a, 0xbe, 0xef, 0x51, 0xca,
+	0xd0, 0x9f, 0x52, 0xab, 0xdc, 0x95, 0xa0, 0x64, 0x82, 0x54, 0x42, 0x77, 0x5d, 0x09, 0x81, 0x21,
+	0x2a, 0x25, 0xb8, 0xad, 0x24, 0x16, 0x5b, 0x7b, 0xeb, 0xb6, 0x5a, 0x75, 0x65, 0x6b, 0xdb, 0xca,
+	0x28, 0xf4, 0x2c, 0xe2, 0xa6, 0xbd, 0xfb, 0x64, 0x1e, 0xde, 0x36, 0x1d, 0x51, 0xb9, 0x3d, 0x3c,
+	0xe1, 0x6a, 0xce, 0xfa, 0xbe, 0xdb, 0x33, 0xb6, 0xa3, 0x12, 0x1d, 0x76, 0xa1, 0x73, 0x36, 0x4f,
+	0xf5, 0xcf, 0x00, 0xb3, 0x54, 0x8a, 0x0c, 0xdf, 0xf7, 0xae, 0xff, 0xee, 0xdf, 0xb9, 0xfe, 0xb7,
+	0xdf, 0xf8, 0x6d, 0x9e, 0x3f, 0xe6, 0x99, 0x6c, 0xd3, 0xcd, 0x3e, 0xfe, 0x1f, 0x00, 0x00, 0xff,
+	0xff, 0x8e, 0xdf, 0x9b, 0x7d, 0x31, 0x04, 0x00, 0x00,
 }

etcdserver/etcdserverpb/rpc.pb.go

@@ -16,7 +16,7 @@ import (
 	io "io"
 )
 
-import storagepb "github.com/coreos/etcd/storage/storagepb"
+import mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
 
 import (
 	context "golang.org/x/net/context"
@@ -182,13 +182,13 @@ func (AlarmRequest_AlarmAction) EnumDescriptor() ([]byte, []int) {
 
 type ResponseHeader struct {
 	// cluster_id is the ID of the cluster which sent the response.
-	ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
+	ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,proto3" json:"cluster_id,omitempty"`
 	// member_id is the ID of the member which sent the response.
-	MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"`
+	MemberId uint64 `protobuf:"varint,2,opt,name=member_id,proto3" json:"member_id,omitempty"`
 	// revision is the key-value store revision when the request was applied.
 	Revision int64 `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
 	// raft_term is the raft term when the request was applied.
-	RaftTerm uint64 `protobuf:"varint,4,opt,name=raft_term,json=raftTerm,proto3" json:"raft_term,omitempty"`
+	RaftTerm uint64 `protobuf:"varint,4,opt,name=raft_term,proto3" json:"raft_term,omitempty"`
 }
 
 func (m *ResponseHeader) Reset()                    { *m = ResponseHeader{} }
@@ -201,7 +201,7 @@ type RangeRequest struct {
 	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
 	// range_end is the upper bound on the requested range [key, range_end).
 	// If range_end is '\0', the range is all keys >= key.
-	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,proto3" json:"range_end,omitempty"`
 	// limit is a limit on the number of keys returned for the request.
 	Limit int64 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
 	// revision is the point-in-time of the key-value store to use for the range.
@@ -209,9 +209,9 @@ type RangeRequest struct {
 	// If the revision has been compacted, ErrCompaction is returned as a response.
 	Revision int64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
 	// sort_order is the order for returned sorted results.
-	SortOrder RangeRequest_SortOrder `protobuf:"varint,5,opt,name=sort_order,json=sortOrder,proto3,enum=etcdserverpb.RangeRequest_SortOrder" json:"sort_order,omitempty"`
+	SortOrder RangeRequest_SortOrder `protobuf:"varint,5,opt,name=sort_order,proto3,enum=etcdserverpb.RangeRequest_SortOrder" json:"sort_order,omitempty"`
 	// sort_target is the key-value field to use for sorting.
-	SortTarget RangeRequest_SortTarget `protobuf:"varint,6,opt,name=sort_target,json=sortTarget,proto3,enum=etcdserverpb.RangeRequest_SortTarget" json:"sort_target,omitempty"`
+	SortTarget RangeRequest_SortTarget `protobuf:"varint,6,opt,name=sort_target,proto3,enum=etcdserverpb.RangeRequest_SortTarget" json:"sort_target,omitempty"`
 	// serializable sets the range request to use serializable member-local reads.
 	// Range requests are linearizable by default; linearizable requests have higher
 	// latency and lower throughput than serializable requests but reflect the current
@@ -229,7 +229,7 @@ func (*RangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []
 type RangeResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	// kvs is the list of key-value pairs matched by the range request.
-	Kvs []*storagepb.KeyValue `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"`
+	Kvs []*mvccpb.KeyValue `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"`
 	// more indicates if there are more keys to return in the requested range.
 	More bool `protobuf:"varint,3,opt,name=more,proto3" json:"more,omitempty"`
 }
@@ -246,7 +246,7 @@ func (m *RangeResponse) GetHeader() *ResponseHeader {
 	return nil
 }
 
-func (m *RangeResponse) GetKvs() []*storagepb.KeyValue {
+func (m *RangeResponse) GetKvs() []*mvccpb.KeyValue {
 	if m != nil {
 		return m.Kvs
 	}
@@ -290,7 +290,7 @@ type DeleteRangeRequest struct {
 	// range_end is the key following the last key to delete for the range [key, range_end).
 	// If range_end is not given, the range is defined to contain only the key argument.
 	// If range_end is '\0', the range is all keys greater than or equal to the key argument.
-	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,proto3" json:"range_end,omitempty"`
 }
 
 func (m *DeleteRangeRequest) Reset()                    { *m = DeleteRangeRequest{} }
@@ -338,13 +338,13 @@ type isRequestUnion_Request interface {
 }
 
 type RequestUnion_RequestRange struct {
-	RequestRange *RangeRequest `protobuf:"bytes,1,opt,name=request_range,json=requestRange,oneof"`
+	RequestRange *RangeRequest `protobuf:"bytes,1,opt,name=request_range,oneof"`
 }
 type RequestUnion_RequestPut struct {
-	RequestPut *PutRequest `protobuf:"bytes,2,opt,name=request_put,json=requestPut,oneof"`
+	RequestPut *PutRequest `protobuf:"bytes,2,opt,name=request_put,oneof"`
 }
 type RequestUnion_RequestDeleteRange struct {
-	RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range,json=requestDeleteRange,oneof"`
+	RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range,oneof"`
 }
 
 func (*RequestUnion_RequestRange) isRequestUnion_Request()       {}
@@ -494,13 +494,13 @@ type isResponseUnion_Response interface {
 }
 
 type ResponseUnion_ResponseRange struct {
-	ResponseRange *RangeResponse `protobuf:"bytes,1,opt,name=response_range,json=responseRange,oneof"`
+	ResponseRange *RangeResponse `protobuf:"bytes,1,opt,name=response_range,oneof"`
 }
 type ResponseUnion_ResponsePut struct {
-	ResponsePut *PutResponse `protobuf:"bytes,2,opt,name=response_put,json=responsePut,oneof"`
+	ResponsePut *PutResponse `protobuf:"bytes,2,opt,name=response_put,oneof"`
 }
 type ResponseUnion_ResponseDeleteRange struct {
-	ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range,json=responseDeleteRange,oneof"`
+	ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range,oneof"`
 }
 
 func (*ResponseUnion_ResponseRange) isResponseUnion_Response()       {}
@@ -658,10 +658,10 @@ type Compare_Version struct {
 	Version int64 `protobuf:"varint,4,opt,name=version,proto3,oneof"`
 }
 type Compare_CreateRevision struct {
-	CreateRevision int64 `protobuf:"varint,5,opt,name=create_revision,json=createRevision,proto3,oneof"`
+	CreateRevision int64 `protobuf:"varint,5,opt,name=create_revision,proto3,oneof"`
 }
 type Compare_ModRevision struct {
-	ModRevision int64 `protobuf:"varint,6,opt,name=mod_revision,json=modRevision,proto3,oneof"`
+	ModRevision int64 `protobuf:"varint,6,opt,name=mod_revision,proto3,oneof"`
 }
 type Compare_Value struct {
 	Value []byte `protobuf:"bytes,7,opt,name=value,proto3,oneof"`
@@ -953,7 +953,7 @@ type SnapshotResponse struct {
 	// stream indicates the point in time of the snapshot.
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	// remaining_bytes is the number of blob bytes to be sent after this message
-	RemainingBytes uint64 `protobuf:"varint,2,opt,name=remaining_bytes,json=remainingBytes,proto3" json:"remaining_bytes,omitempty"`
+	RemainingBytes uint64 `protobuf:"varint,2,opt,name=remaining_bytes,proto3" json:"remaining_bytes,omitempty"`
 	// blob contains the next chunk of the snapshot in the snapshot stream.
 	Blob []byte `protobuf:"bytes,3,opt,name=blob,proto3" json:"blob,omitempty"`
 }
@@ -991,10 +991,10 @@ type isWatchRequest_RequestUnion interface {
 }
 
 type WatchRequest_CreateRequest struct {
-	CreateRequest *WatchCreateRequest `protobuf:"bytes,1,opt,name=create_request,json=createRequest,oneof"`
+	CreateRequest *WatchCreateRequest `protobuf:"bytes,1,opt,name=create_request,oneof"`
 }
 type WatchRequest_CancelRequest struct {
-	CancelRequest *WatchCancelRequest `protobuf:"bytes,2,opt,name=cancel_request,json=cancelRequest,oneof"`
+	CancelRequest *WatchCancelRequest `protobuf:"bytes,2,opt,name=cancel_request,oneof"`
 }
 
 func (*WatchRequest_CreateRequest) isWatchRequest_RequestUnion() {}
@@ -1101,14 +1101,14 @@ type WatchCreateRequest struct {
 	// range_end is the end of the range [key, range_end) to watch. If range_end is not given,
 	// only the key argument is watched. If range_end is equal to '\0', all keys greater than
 	// or equal to the key argument are watched.
-	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,proto3" json:"range_end,omitempty"`
 	// start_revision is an optional revision to watch from (inclusive). No start_revision is "now".
-	StartRevision int64 `protobuf:"varint,3,opt,name=start_revision,json=startRevision,proto3" json:"start_revision,omitempty"`
+	StartRevision int64 `protobuf:"varint,3,opt,name=start_revision,proto3" json:"start_revision,omitempty"`
 	// progress_notify is set so that the etcd server will periodically send a WatchResponse with
 	// no events to the new watcher if there are no recent events. It is useful when clients
 	// wish to recover a disconnected watcher starting from a recent known revision.
 	// The etcd server may decide how often it will send notifications based on current load.
-	ProgressNotify bool `protobuf:"varint,4,opt,name=progress_notify,json=progressNotify,proto3" json:"progress_notify,omitempty"`
+	ProgressNotify bool `protobuf:"varint,4,opt,name=progress_notify,proto3" json:"progress_notify,omitempty"`
 }
 
 func (m *WatchCreateRequest) Reset()                    { *m = WatchCreateRequest{} }
@@ -1118,7 +1118,7 @@ func (*WatchCreateRequest) Descriptor() ([]byte, []int) { return fileDescriptorR
 
 type WatchCancelRequest struct {
 	// watch_id is the watcher id to cancel so that no more events are transmitted.
-	WatchId int64 `protobuf:"varint,1,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"`
+	WatchId int64 `protobuf:"varint,1,opt,name=watch_id,proto3" json:"watch_id,omitempty"`
 }
 
 func (m *WatchCancelRequest) Reset()                    { *m = WatchCancelRequest{} }
@@ -1129,7 +1129,7 @@ func (*WatchCancelRequest) Descriptor() ([]byte, []int) { return fileDescriptorR
 type WatchResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	// watch_id is the ID of the watcher that corresponds to the response.
-	WatchId int64 `protobuf:"varint,2,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"`
+	WatchId int64 `protobuf:"varint,2,opt,name=watch_id,proto3" json:"watch_id,omitempty"`
 	// created is set to true if the response is for a create watch request.
 	// The client should record the watch_id and expect to receive events for
 	// the created watcher from the same stream.
@@ -1146,8 +1146,8 @@ type WatchResponse struct {
 	//
 	// The client should treat the watcher as canceled and should not try to create any
 	// watcher with the same start_revision again.
-	CompactRevision int64              `protobuf:"varint,5,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"`
-	Events          []*storagepb.Event `protobuf:"bytes,11,rep,name=events" json:"events,omitempty"`
+	CompactRevision int64           `protobuf:"varint,5,opt,name=compact_revision,proto3" json:"compact_revision,omitempty"`
+	Events          []*mvccpb.Event `protobuf:"bytes,11,rep,name=events" json:"events,omitempty"`
 }
 
 func (m *WatchResponse) Reset()                    { *m = WatchResponse{} }
@@ -1162,7 +1162,7 @@ func (m *WatchResponse) GetHeader() *ResponseHeader {
 	return nil
 }
 
-func (m *WatchResponse) GetEvents() []*storagepb.Event {
+func (m *WatchResponse) GetEvents() []*mvccpb.Event {
 	if m != nil {
 		return m.Events
 	}
@@ -1171,9 +1171,9 @@ func (m *WatchResponse) GetEvents() []*storagepb.Event {
 
 type LeaseGrantRequest struct {
 	// TTL is the advisory time-to-live in seconds.
-	TTL int64 `protobuf:"varint,1,opt,name=TTL,json=tTL,proto3" json:"TTL,omitempty"`
+	TTL int64 `protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
 	// ID is the requested ID for the lease. If ID is set to 0, the lessor chooses an ID.
-	ID int64 `protobuf:"varint,2,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
 }
 
 func (m *LeaseGrantRequest) Reset()                    { *m = LeaseGrantRequest{} }
@@ -1184,9 +1184,9 @@ func (*LeaseGrantRequest) Descriptor() ([]byte, []int) { return fileDescriptorRp
 type LeaseGrantResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	// ID is the lease ID for the granted lease.
-	ID int64 `protobuf:"varint,2,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
 	// TTL is the server chosen lease time-to-live in seconds.
-	TTL   int64  `protobuf:"varint,3,opt,name=TTL,json=tTL,proto3" json:"TTL,omitempty"`
+	TTL   int64  `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
 	Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
 }
 
@@ -1204,7 +1204,7 @@ func (m *LeaseGrantResponse) GetHeader() *ResponseHeader {
 
 type LeaseRevokeRequest struct {
 	// ID is the lease ID to revoke. When the ID is revoked, all associated keys will be deleted.
-	ID int64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
 }
 
 func (m *LeaseRevokeRequest) Reset()                    { *m = LeaseRevokeRequest{} }
@@ -1230,7 +1230,7 @@ func (m *LeaseRevokeResponse) GetHeader() *ResponseHeader {
 
 type LeaseKeepAliveRequest struct {
 	// ID is the lease ID for the lease to keep alive.
-	ID int64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
 }
 
 func (m *LeaseKeepAliveRequest) Reset()                    { *m = LeaseKeepAliveRequest{} }
@@ -1241,9 +1241,9 @@ func (*LeaseKeepAliveRequest) Descriptor() ([]byte, []int) { return fileDescript
 type LeaseKeepAliveResponse struct {
 	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
 	// ID is the lease ID from the keep alive request.
-	ID int64 `protobuf:"varint,2,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
 	// TTL is the new time-to-live for the lease.
-	TTL int64 `protobuf:"varint,3,opt,name=TTL,json=tTL,proto3" json:"TTL,omitempty"`
+	TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
 }
 
 func (m *LeaseKeepAliveResponse) Reset()                    { *m = LeaseKeepAliveResponse{} }
@@ -1260,7 +1260,7 @@ func (m *LeaseKeepAliveResponse) GetHeader() *ResponseHeader {
 
 type Member struct {
 	// ID is the member ID for this member.
-	ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
 	// name is the human-readable name of the member. If the member is not started, the name will be an empty string.
 	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
 	// peerURLs is the list of URLs the member exposes to the cluster for communication.
@@ -1311,7 +1311,7 @@ func (m *MemberAddResponse) GetMember() *Member {
 
 type MemberRemoveRequest struct {
 	// ID is the member ID of the member to remove.
-	ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
 }
 
 func (m *MemberRemoveRequest) Reset()                    { *m = MemberRemoveRequest{} }
@@ -1337,7 +1337,7 @@ func (m *MemberRemoveResponse) GetHeader() *ResponseHeader {
 
 type MemberUpdateRequest struct {
 	// ID is the member ID of the member to update.
-	ID uint64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
+	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
 	// peerURLs is the new list of URLs the member will use to communicate with the cluster.
 	PeerURLs []string `protobuf:"bytes,2,rep,name=peerURLs" json:"peerURLs,omitempty"`
 }
@@ -7224,7 +7224,7 @@ func (m *RangeResponse) Unmarshal(data []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Kvs = append(m.Kvs, &storagepb.KeyValue{})
+			m.Kvs = append(m.Kvs, &mvccpb.KeyValue{})
 			if err := m.Kvs[len(m.Kvs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -9483,7 +9483,7 @@ func (m *WatchResponse) Unmarshal(data []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Events = append(m.Events, &storagepb.Event{})
+			m.Events = append(m.Events, &mvccpb.Event{})
 			if err := m.Events[len(m.Events)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -13966,167 +13966,152 @@ var (
 )
 
 var fileDescriptorRpc = []byte{
-	// 2577 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x5a, 0xcd, 0x72, 0x1b, 0xc7,
-	0x11, 0x26, 0x7e, 0x08, 0x10, 0x0d, 0x10, 0xa2, 0x86, 0x94, 0x4c, 0x43, 0xb6, 0x24, 0xaf, 0x24,
-	0x5b, 0x89, 0x1d, 0x2a, 0x66, 0x9c, 0x43, 0x2a, 0x2e, 0xa5, 0x40, 0x02, 0x96, 0x68, 0x52, 0xa4,
-	0xbc, 0x04, 0xa9, 0xf8, 0xc4, 0x5a, 0x02, 0x23, 0x12, 0x25, 0xfc, 0x79, 0x77, 0x41, 0x89, 0x3a,
-	0xa5, 0x52, 0x95, 0x27, 0x70, 0x4e, 0xa9, 0xbc, 0x40, 0x1e, 0x20, 0xef, 0x90, 0xca, 0x25, 0x79,
-	0x82, 0x24, 0x95, 0x63, 0x72, 0xc8, 0x3d, 0xb9, 0xa4, 0xe7, 0x77, 0x67, 0x07, 0xbb, 0x94, 0x9c,
-	0x65, 0x0e, 0x14, 0x77, 0x7a, 0xba, 0xbf, 0xe9, 0xee, 0xe9, 0xe9, 0xe9, 0x1e, 0x0a, 0x2a, 0xfe,
-	0xa4, 0xbb, 0x36, 0xf1, 0xc7, 0xe1, 0x98, 0xd4, 0x68, 0xd8, 0xed, 0x05, 0xd4, 0x3f, 0xa3, 0xfe,
-	0xe4, 0xb8, 0xb1, 0x72, 0x32, 0x3e, 0x19, 0xf3, 0x89, 0x07, 0xec, 0x4b, 0xf0, 0x34, 0x6e, 0x31,
-	0x9e, 0x07, 0x41, 0x38, 0xf6, 0xbd, 0x13, 0xaa, 0x7e, 0x4f, 0x8e, 0x1f, 0xbc, 0x38, 0x93, 0x0c,
-	0x37, 0x38, 0x83, 0x37, 0x0d, 0x4f, 0xf9, 0x3f, 0x38, 0xc5, 0x7e, 0x89, 0x49, 0xe7, 0x57, 0x39,
-	0xa8, 0xbb, 0x34, 0x98, 0x8c, 0x47, 0x01, 0x7d, 0x4c, 0xbd, 0x1e, 0xf5, 0xc9, 0xfb, 0x00, 0xdd,
-	0xc1, 0x34, 0x08, 0xa9, 0x7f, 0xd4, 0xef, 0xad, 0xe6, 0x6e, 0xe7, 0xee, 0x17, 0xdd, 0x8a, 0xa4,
-	0x6c, 0xf5, 0xc8, 0x0d, 0xa8, 0x0c, 0xe9, 0xf0, 0x58, 0xcc, 0xe6, 0xf9, 0xec, 0x82, 0x20, 0xe0,
-	0x64, 0x03, 0x16, 0x7c, 0x7a, 0xd6, 0x0f, 0xfa, 0xe3, 0xd1, 0x6a, 0x01, 0xe7, 0x0a, 0xae, 0x1e,
-	0x33, 0x41, 0xdf, 0x7b, 0x1e, 0x1e, 0x21, 0xcc, 0x70, 0xb5, 0x28, 0x04, 0x19, 0xa1, 0x83, 0x63,
-	0xe7, 0xd7, 0x05, 0xa8, 0xb9, 0xde, 0xe8, 0x84, 0xba, 0xf4, 0x9b, 0x29, 0x0d, 0x42, 0xb2, 0x04,
-	0x85, 0x17, 0xf4, 0x9c, 0x2f, 0x5f, 0x73, 0xd9, 0xa7, 0x90, 0x47, 0x8e, 0x23, 0x3a, 0x12, 0x0b,
-	0xd7, 0x98, 0x3c, 0x12, 0xda, 0xa3, 0x1e, 0x59, 0x81, 0xf9, 0x41, 0x7f, 0xd8, 0x0f, 0xe5, 0xaa,
-	0x62, 0x10, 0x53, 0xa7, 0x68, 0xa9, 0xb3, 0x09, 0x10, 0x8c, 0xfd, 0xf0, 0x68, 0xec, 0xa3, 0xd1,
-	0xab, 0xf3, 0x38, 0x5b, 0x5f, 0xbf, 0xbb, 0x66, 0x3a, 0x7c, 0xcd, 0x54, 0x68, 0x6d, 0x1f, 0x99,
-	0xf7, 0x18, 0xaf, 0x5b, 0x09, 0xd4, 0x27, 0xf9, 0x02, 0xaa, 0x1c, 0x24, 0xf4, 0xfc, 0x13, 0x1a,
-	0xae, 0x96, 0x38, 0xca, 0xbd, 0x37, 0xa0, 0x74, 0x38, 0xb3, 0xcb, 0x97, 0x17, 0xdf, 0xc4, 0x81,
-	0x1a, 0xf2, 0xf7, 0xbd, 0x41, 0xff, 0xb5, 0x77, 0x3c, 0xa0, 0xab, 0x65, 0x04, 0x5a, 0x70, 0x63,
-	0x34, 0x67, 0x0d, 0x2a, 0x5a, 0x07, 0xb2, 0x00, 0xc5, 0xdd, 0xbd, 0xdd, 0xf6, 0xd2, 0x1c, 0x01,
-	0x28, 0x35, 0xf7, 0x37, 0xdb, 0xbb, 0xad, 0xa5, 0x1c, 0xa9, 0x42, 0xb9, 0xd5, 0x16, 0x83, 0xbc,
-	0xb3, 0x01, 0x10, 0xad, 0x46, 0xca, 0x50, 0xd8, 0x6e, 0x7f, 0x8d, 0xfc, 0xc8, 0x73, 0xd8, 0x76,
-	0xf7, 0xb7, 0xf6, 0x76, 0x51, 0x00, 0x85, 0x37, 0xdd, 0x76, 0xb3, 0xd3, 0x5e, 0xca, 0x33, 0x8e,
-	0x27, 0x7b, 0xad, 0xa5, 0x02, 0xa9, 0xc0, 0xfc, 0x61, 0x73, 0xe7, 0xa0, 0xbd, 0x54, 0x74, 0x7e,
-	0x91, 0x83, 0x45, 0xa9, 0xbf, 0x88, 0x11, 0xf2, 0x19, 0x94, 0x4e, 0x79, 0x9c, 0xf0, 0xad, 0xa9,
-	0xae, 0xbf, 0x67, 0x19, 0x1b, 0x8b, 0x25, 0x57, 0xf2, 0x92, 0x7b, 0xb8, 0x9b, 0x67, 0x01, 0xee,
-	0x5a, 0x01, 0x45, 0x96, 0xd7, 0x74, 0x94, 0xae, 0x6d, 0xd3, 0xf3, 0x43, 0x6f, 0x30, 0xa5, 0x2e,
-	0x9b, 0x27, 0x04, 0x8a, 0xc3, 0xb1, 0x4f, 0xf9, 0x26, 0x2e, 0xb8, 0xfc, 0xdb, 0xf9, 0x12, 0xe0,
-	0xe9, 0x34, 0x4c, 0x0f, 0x0b, 0xdc, 0xf9, 0x33, 0x86, 0x20, 0x43, 0x42, 0x0c, 0x78, 0x3c, 0x50,
-	0x2f, 0xa0, 0x3a, 0x1e, 0xd8, 0xc0, 0xd9, 0x84, 0x2a, 0xc7, 0xca, 0x62, 0x0b, 0x82, 0x90, 0x16,
-	0x1d, 0xd0, 0x90, 0x66, 0x88, 0x57, 0x87, 0xc2, 0x72, 0x0c, 0x24, 0x93, 0x77, 0x57, 0xa1, 0xdc,
-	0xe3, 0x60, 0x62, 0x9d, 0x82, 0xab, 0x86, 0xce, 0xbf, 0x72, 0x78, 0xac, 0x84, 0x86, 0x07, 0x23,
-	0x16, 0xf5, 0x4d, 0x58, 0xf4, 0xc5, 0xf8, 0x88, 0xeb, 0x22, 0xd7, 0x69, 0xa4, 0x87, 0xec, 0xe3,
-	0x39, 0xb7, 0x26, 0x45, 0x38, 0x99, 0xfc, 0x14, 0xaa, 0x0a, 0x62, 0x32, 0x0d, 0xf9, 0x8a, 0xd5,
-	0xf5, 0xd5, 0x38, 0x40, 0xb4, 0x63, 0x28, 0x0e, 0x92, 0x1d, 0x89, 0xa4, 0x03, 0x2b, 0x4a, 0x58,
-	0xe8, 0x28, 0xd5, 0x28, 0x70, 0x94, 0xdb, 0x71, 0x94, 0x59, 0x37, 0x23, 0x1a, 0x91, 0xf2, 0xc6,
-	0xe4, 0x46, 0x05, 0xca, 0x92, 0xea, 0xfc, 0x9b, 0x45, 0xac, 0x74, 0x93, 0x30, 0xb9, 0x05, 0x75,
-	0x5f, 0x12, 0x62, 0x36, 0xdf, 0x48, 0xb4, 0x59, 0x3a, 0x78, 0xce, 0x5d, 0x54, 0x42, 0xc2, 0xea,
-	0x87, 0x50, 0xd3, 0x28, 0x91, 0xd9, 0xef, 0x26, 0x98, 0xad, 0x11, 0xaa, 0x4a, 0x80, 0x19, 0xfe,
-	0x0c, 0xae, 0x69, 0xf9, 0x04, 0xcb, 0x3f, 0xb8, 0xc0, 0x72, 0x0d, 0xb8, 0xac, 0x10, 0x4c, 0xdb,
-	0x81, 0xe5, 0x38, 0x41, 0x76, 0x7e, 0x53, 0x80, 0xf2, 0xe6, 0x78, 0x38, 0xf1, 0x7c, 0xb6, 0x4d,
-	0x25, 0xa4, 0x4f, 0x07, 0x21, 0x37, 0xb7, 0xbe, 0x7e, 0x27, 0xbe, 0x82, 0x64, 0x53, 0xbf, 0x5d,
-	0xce, 0xea, 0x4a, 0x11, 0x26, 0x2c, 0x53, 0x5a, 0xfe, 0x2d, 0x84, 0x65, 0x42, 0x93, 0x22, 0xea,
-	0x28, 0x14, 0xa2, 0xa3, 0xd0, 0x80, 0x32, 0x0a, 0x46, 0x69, 0x18, 0x6d, 0x51, 0x04, 0xf2, 0x3d,
-	0xb8, 0xd2, 0xf5, 0xa9, 0xc7, 0xfc, 0xa1, 0x52, 0xf5, 0xbc, 0xe4, 0xa9, 0x8b, 0x09, 0x57, 0xa5,
-	0xec, 0x3b, 0x50, 0x1b, 0x8e, 0x7b, 0x11, 0x5f, 0x49, 0xf2, 0x55, 0x91, 0xaa, 0x99, 0xae, 0xab,
-	0x7c, 0xc0, 0x72, 0x68, 0x0d, 0x67, 0xc5, 0xd0, 0xf9, 0x14, 0x16, 0x63, 0xb6, 0xb2, 0x34, 0xd7,
-	0xfe, 0xea, 0xa0, 0xb9, 0x23, 0x72, 0xe2, 0x23, 0x9e, 0x06, 0x5d, 0xcc, 0x89, 0x98, 0x5a, 0x77,
-	0xda, 0xfb, 0xfb, 0x98, 0x41, 0x3f, 0xd7, 0x22, 0x32, 0x89, 0x1a, 0xb9, 0x73, 0xce, 0xc8, 0x9d,
-	0x39, 0x95, 0x3b, 0xf3, 0x51, 0xee, 0x2c, 0x6c, 0xd4, 0xa1, 0x26, 0x1c, 0x72, 0x34, 0x65, 0x71,
-	0xe8, 0xfc, 0x2e, 0x07, 0xd0, 0x79, 0x35, 0x52, 0x09, 0xe3, 0x01, 0x94, 0xbb, 0x02, 0x1c, 0x37,
-	0x88, 0xa5, 0xc5, 0x6b, 0x89, 0x3e, 0x76, 0x15, 0x17, 0xe6, 0x86, 0x72, 0x30, 0xed, 0x76, 0x69,
-	0xa0, 0xf2, 0xa8, 0x7d, 0x68, 0x8d, 0x73, 0xee, 0x2a, 0x56, 0x26, 0xf5, 0xdc, 0xeb, 0x0f, 0xa6,
-	0x3c, 0xab, 0xbe, 0x51, 0x4a, 0xb2, 0x3a, 0xbf, 0xcd, 0x41, 0x95, 0xeb, 0x9a, 0x29, 0x2f, 0xbd,
-	0x07, 0x15, 0xae, 0x06, 0xed, 0xc9, 0xcc, 0xb4, 0xe0, 0x46, 0x04, 0xf2, 0x13, 0xcc, 0x8f, 0x52,
-	0x2e, 0x90, 0xba, 0xdd, 0x48, 0x86, 0x15, 0xca, 0x45, 0xdc, 0xce, 0x36, 0x5c, 0xe5, 0xee, 0xe9,
-	0x86, 0x6c, 0x42, 0x3a, 0xd4, 0xbc, 0xec, 0x73, 0xd6, 0x65, 0x8f, 0x73, 0x93, 0xd3, 0xf3, 0xa0,
-	0xdf, 0xf5, 0x06, 0x52, 0x11, 0x3d, 0xc6, 0x0b, 0x86, 0x98, 0x60, 0x99, 0xee, 0x86, 0x45, 0xa8,
-	0x3e, 0xf6, 0x82, 0x53, 0xa9, 0x92, 0xf3, 0x73, 0xa8, 0x89, 0x61, 0x26, 0x37, 0xe2, 0xad, 0x78,
-	0x8a, 0x28, 0x5c, 0xf1, 0x45, 0x97, 0x7f, 0x3b, 0x57, 0xe1, 0xca, 0xfe, 0xc8, 0x9b, 0x04, 0xa7,
-	0x63, 0x95, 0x68, 0x59, 0x29, 0xb7, 0x14, 0xd1, 0x32, 0xad, 0xf8, 0x11, 0x5c, 0xf1, 0xe9, 0xd0,
-	0xeb, 0x8f, 0xfa, 0xa3, 0x93, 0xa3, 0xe3, 0xf3, 0x90, 0x06, 0xb2, 0xd2, 0xab, 0x6b, 0xf2, 0x06,
-	0xa3, 0x32, 0xd5, 0x8e, 0x07, 0xe3, 0x63, 0x79, 0xd6, 0xf9, 0xb7, 0xf3, 0x7b, 0xbc, 0x73, 0x9e,
-	0x79, 0x61, 0x57, 0x79, 0x81, 0x6c, 0x41, 0x5d, 0x9f, 0x70, 0x4e, 0x91, 0xba, 0x58, 0xd9, 0x9e,
-	0xcb, 0x6c, 0xca, 0x13, 0xaf, 0xb2, 0xfd, 0x62, 0xd7, 0x24, 0x70, 0x28, 0x6f, 0xd4, 0xa5, 0x03,
-	0x0d, 0x95, 0x4f, 0x87, 0xe2, 0x8c, 0x26, 0x94, 0x49, 0xd8, 0xb8, 0x12, 0xdd, 0x84, 0xe2, 0x7c,
-	0x7e, 0x9b, 0x03, 0x32, 0xab, 0xc3, 0x77, 0x2d, 0x44, 0xef, 0x41, 0x3d, 0xc0, 0x63, 0x1f, 0x1e,
-	0x59, 0x75, 0xf0, 0x22, 0xa7, 0xea, 0x2c, 0x85, 0x1e, 0xc6, 0x02, 0xfc, 0x04, 0x43, 0x3a, 0x38,
-	0x1a, 0x8d, 0xc3, 0xfe, 0xf3, 0x73, 0x9e, 0x19, 0x17, 0xdc, 0xba, 0x22, 0xef, 0x72, 0xaa, 0xf3,
-	0x40, 0x29, 0x65, 0x2a, 0x4f, 0xde, 0x85, 0x85, 0x97, 0x8c, 0xaa, 0x2a, 0x74, 0xbc, 0xf2, 0xf9,
-	0x78, 0xab, 0xe7, 0xfc, 0x13, 0x2f, 0x40, 0xe9, 0xfe, 0x4c, 0x31, 0x60, 0x2e, 0x91, 0x8f, 0x2d,
-	0xc1, 0xea, 0x0d, 0xb1, 0x2d, 0x3d, 0x59, 0xa9, 0xa9, 0x21, 0x3b, 0x67, 0xc2, 0xcb, 0x38, 0x25,
-	0xec, 0xd1, 0x63, 0x4c, 0xf4, 0x4b, 0x5d, 0x71, 0xce, 0xac, 0x4c, 0xef, 0x5e, 0x91, 0x74, 0xed,
-	0x9d, 0xfb, 0x50, 0xa2, 0x67, 0x74, 0x14, 0x06, 0xab, 0x55, 0x9e, 0x17, 0x96, 0x8c, 0x8a, 0xb1,
-	0xcd, 0x26, 0x5c, 0x39, 0xef, 0xfc, 0x18, 0xae, 0xee, 0xb0, 0xd2, 0xee, 0x11, 0x6e, 0x80, 0x59,
-	0x24, 0x76, 0x3a, 0x3b, 0xd2, 0x31, 0x85, 0xb0, 0xb3, 0x43, 0xea, 0x90, 0xdf, 0x6a, 0x49, 0x33,
-	0xf2, 0xfd, 0x96, 0xf3, 0x4b, 0xdc, 0x6b, 0x53, 0x2e, 0x93, 0xa7, 0x2c, 0x70, 0xb5, 0x7c, 0x21,
-	0x5a, 0x1e, 0xab, 0x51, 0xea, 0xfb, 0x63, 0x9f, 0xfb, 0xa4, 0xe2, 0x8a, 0x81, 0x73, 0x57, 0xea,
-	0x80, 0x66, 0x8f, 0x5f, 0xe8, 0x78, 0x13, 0x68, 0x39, 0xad, 0xea, 0x36, 0x2c, 0xc7, 0xb8, 0x32,
-	0xe5, 0xa7, 0x8f, 0xe0, 0x1a, 0x07, 0xdb, 0xa6, 0x74, 0xd2, 0x1c, 0xf4, 0xcf, 0x52, 0x57, 0x9d,
-	0xc0, 0x75, 0x9b, 0xf1, 0xff, 0xeb, 0x23, 0xe7, 0x14, 0x4a, 0x4f, 0x78, 0x1b, 0x69, 0xe8, 0x52,
-	0xe4, 0xbc, 0x98, 0x64, 0x46, 0xde, 0x50, 0x14, 0xf8, 0x15, 0x97, 0x7f, 0xf3, 0x84, 0x4e, 0xa9,
-	0x7f, 0xe0, 0xee, 0x88, 0xbb, 0xa3, 0xe2, 0xea, 0x31, 0xb9, 0xc9, 0x1a, 0xd8, 0x3e, 0x86, 0x07,
-	0x9f, 0x2d, 0xf2, 0x59, 0x83, 0x82, 0x8d, 0xd4, 0x92, 0x58, 0xa9, 0xd9, 0xeb, 0x19, 0x97, 0x87,
-	0xc6, 0xcb, 0xc5, 0xf1, 0x9c, 0x97, 0x70, 0xd5, 0xe0, 0xcf, 0xe4, 0x86, 0x4f, 0xa0, 0x24, 0x7a,
-	0x65, 0x99, 0xb7, 0x56, 0xe2, 0x52, 0x62, 0x19, 0x57, 0xf2, 0x38, 0xf7, 0x60, 0x59, 0x52, 0xe8,
-	0x70, 0x9c, 0xb4, 0x57, 0xdc, 0x3f, 0xce, 0x0e, 0xac, 0xc4, 0xd9, 0x32, 0x85, 0x48, 0x53, 0x2d,
-	0x7a, 0x30, 0xe9, 0x19, 0x69, 0xd0, 0xde, 0x14, 0xd3, 0x61, 0x79, 0xcb, 0x61, 0x5a, 0x21, 0x05,
-	0x91, 0x49, 0xa1, 0x65, 0xe5, 0xfe, 0x9d, 0x7e, 0xa0, 0x2f, 0xbb, 0xd7, 0x40, 0x4c, 0x62, 0xa6,
-	0x4d, 0x59, 0x83, 0xb2, 0x70, 0xb8, 0x2a, 0xac, 0x92, 0x77, 0x45, 0x31, 0x31, 0x85, 0x5a, 0xf4,
-	0x39, 0xa6, 0xa3, 0x21, 0xd5, 0x39, 0x87, 0x55, 0x11, 0x26, 0x31, 0x93, 0xc5, 0x7f, 0xc2, 0x1b,
-	0xb4, 0x39, 0xf0, 0xfc, 0xa1, 0x72, 0xfe, 0x43, 0x28, 0x89, 0xf2, 0x44, 0xd6, 0xf2, 0x1f, 0xc6,
-	0x61, 0x4c, 0x5e, 0x31, 0x68, 0x8a, 0x62, 0x46, 0x4a, 0xb1, 0xcd, 0x92, 0x4f, 0x34, 0x2d, 0xeb,
-	0xc9, 0xa6, 0x45, 0x7e, 0x00, 0xf3, 0x1e, 0x13, 0xe1, 0x67, 0xb1, 0xbe, 0xfe, 0x4e, 0x02, 0x74,
-	0xe7, 0x7c, 0x42, 0x5d, 0xc1, 0xe5, 0x7c, 0x06, 0x55, 0x63, 0x05, 0x56, 0xf8, 0x3e, 0x6a, 0x77,
-	0xb0, 0x1a, 0xae, 0xc1, 0x42, 0x73, 0xb3, 0xb3, 0x75, 0x28, 0xea, 0xe1, 0x3a, 0x40, 0xab, 0xad,
-	0xc7, 0x79, 0x2c, 0x84, 0x84, 0x94, 0x3c, 0xe1, 0xa6, 0x3e, 0xb9, 0x34, 0x7d, 0xf2, 0x6f, 0xa5,
-	0xcf, 0x2b, 0x58, 0x94, 0xe6, 0x67, 0x8a, 0x81, 0x4f, 0xd1, 0xc3, 0x0c, 0x46, 0x85, 0xc0, 0xbb,
-	0x09, 0xcb, 0xaa, 0xd3, 0x29, 0x18, 0x1d, 0x2c, 0x20, 0xf6, 0x43, 0x2f, 0x9c, 0x06, 0x2a, 0x04,
-	0xfe, 0x98, 0x83, 0xba, 0xa2, 0x64, 0xed, 0xe7, 0x55, 0xbb, 0x24, 0x72, 0x9e, 0x6e, 0x96, 0xae,
-	0x43, 0xa9, 0x77, 0xbc, 0xdf, 0x7f, 0xad, 0xde, 0x35, 0xe4, 0x88, 0xd1, 0x07, 0x62, 0x1d, 0xf1,
-	0xb0, 0x26, 0x47, 0xac, 0x02, 0x67, 0x4f, 0x6c, 0x5b, 0xa3, 0x1e, 0x7d, 0xc5, 0x2f, 0xdb, 0xa2,
-	0x1b, 0x11, 0x78, 0xc5, 0x2c, 0x1f, 0xe0, 0x78, 0x2f, 0x65, 0x3e, 0xc8, 0x61, 0x90, 0x37, 0xa7,
-	0xe1, 0x69, 0x7b, 0xc4, 0xde, 0x9e, 0x94, 0x85, 0x2b, 0x40, 0x18, 0xb1, 0xd5, 0x0f, 0x4c, 0x6a,
-	0x1b, 0x96, 0x19, 0x15, 0xe3, 0x1e, 0xeb, 0xe9, 0x28, 0x63, 0xa8, 0xb4, 0x9d, 0xb3, 0xd2, 0xb6,
-	0x17, 0x04, 0x2f, 0xc7, 0x7e, 0x4f, 0x9a, 0xa6, 0xc7, 0x4e, 0x4b, 0x80, 0x1f, 0x04, 0xb1, 0xc4,
-	0xfc, 0x5d, 0x51, 0x56, 0x22, 0x94, 0x47, 0x54, 0x9f, 0xce, 0x8f, 0xe1, 0x9a, 0xa2, 0xca, 0xde,
-	0x39, 0x1d, 0xde, 0xd9, 0x83, 0xf7, 0x15, 0xf3, 0xe6, 0x29, 0xab, 0xeb, 0x9e, 0x4a, 0xf0, 0xff,
-	0x55, 0xa7, 0x87, 0xb0, 0xa2, 0x75, 0x32, 0xeb, 0x14, 0xc4, 0x99, 0x06, 0x32, 0x36, 0x10, 0x87,
-	0x7d, 0x33, 0x9a, 0x3f, 0x1e, 0xe8, 0xcb, 0x8e, 0x7d, 0x3b, 0xef, 0x44, 0xda, 0xc7, 0x6a, 0x05,
-	0xe7, 0xbe, 0x30, 0xd6, 0x45, 0xa6, 0x8b, 0x5d, 0xa6, 0xdc, 0xc2, 0x38, 0x0d, 0xb7, 0x48, 0x60,
-	0x46, 0x8d, 0xb9, 0xc5, 0x71, 0x85, 0xc6, 0x9c, 0xdd, 0xd2, 0x78, 0xc6, 0xf2, 0x0f, 0xa1, 0x38,
-	0xa1, 0xf2, 0xbc, 0x56, 0xd7, 0xc9, 0x9a, 0x78, 0x64, 0x5e, 0x7b, 0x8a, 0xb4, 0x7e, 0xc0, 0xa2,
-	0xd6, 0xe5, 0xf3, 0xe6, 0x62, 0x71, 0x2b, 0xbe, 0x14, 0xba, 0xa9, 0x50, 0xcb, 0x94, 0x3a, 0xb7,
-	0x45, 0x2c, 0xea, 0x08, 0xcd, 0x04, 0x76, 0x2c, 0xbc, 0x10, 0x05, 0x76, 0xa6, 0x53, 0x8d, 0x45,
-	0x60, 0x88, 0x56, 0xab, 0x33, 0x2d, 0x06, 0x4a, 0x61, 0x1d, 0xf5, 0x97, 0x61, 0xbd, 0x0e, 0xfe,
-	0x4c, 0x60, 0xbb, 0x70, 0xdd, 0x3e, 0x33, 0x99, 0xf0, 0x0e, 0xe1, 0x66, 0xda, 0xb1, 0xca, 0x84,
-	0xfb, 0x24, 0x3a, 0x1d, 0x97, 0x50, 0xcd, 0x9b, 0x66, 0x5f, 0x4a, 0xc9, 0x2d, 0xf7, 0x44, 0x9f,
-	0xd1, 0xcb, 0x02, 0xbb, 0xb4, 0x0d, 0x36, 0x4f, 0xff, 0x65, 0x6c, 0x84, 0x91, 0x34, 0x2e, 0x4b,
-	0xbd, 0xcb, 0xd8, 0x88, 0xef, 0x3b, 0x50, 0xd1, 0xd5, 0x83, 0xf1, 0xf7, 0x93, 0x2a, 0x94, 0x77,
-	0xf7, 0xf6, 0x9f, 0x36, 0x37, 0xb1, 0x6e, 0x59, 0xff, 0x47, 0x1e, 0xf2, 0xdb, 0x87, 0x64, 0x03,
-	0xe6, 0xc5, 0xab, 0xef, 0x05, 0xef, 0xe2, 0x8d, 0x8b, 0xde, 0x8f, 0x9d, 0x39, 0xf2, 0x39, 0x14,
-	0xd8, 0xbb, 0x6f, 0xea, 0xc3, 0x78, 0x23, 0xfd, 0xed, 0x18, 0xa5, 0x3b, 0x50, 0x35, 0x1e, 0x79,
-	0xc9, 0x1b, 0x1f, 0xc6, 0x1b, 0x6f, 0x7e, 0x40, 0x16, 0x3a, 0x75, 0x5e, 0x8d, 0x6c, 0x9d, 0xa2,
-	0x47, 0x49, 0x5b, 0x27, 0xe3, 0x09, 0x10, 0xa5, 0x77, 0xe5, 0xe3, 0x72, 0x37, 0x24, 0xb7, 0x12,
-	0xde, 0x2a, 0xcd, 0xc7, 0xb8, 0xc6, 0xed, 0x74, 0x06, 0x85, 0xb7, 0xbe, 0x07, 0xf3, 0xfc, 0xa1,
-	0x82, 0x7c, 0xa1, 0x3e, 0x1a, 0x09, 0xcf, 0x38, 0x29, 0xee, 0x8e, 0x3d, 0x71, 0x38, 0x73, 0xf7,
-	0x73, 0x3f, 0xcc, 0xad, 0x7f, 0x9b, 0x87, 0x79, 0xde, 0xb5, 0x92, 0xaf, 0x00, 0xa2, 0xf6, 0xde,
-	0xd6, 0x76, 0xe6, 0xc1, 0xc0, 0xd6, 0x76, 0xf6, 0x65, 0x40, 0xec, 0x88, 0xd1, 0x87, 0x93, 0x24,
-	0x91, 0xd8, 0xb5, 0x66, 0xef, 0x48, 0x42, 0x13, 0x8f, 0xa8, 0x1e, 0xd4, 0xe3, 0x7d, 0x36, 0xb9,
-	0x93, 0x20, 0x66, 0xb7, 0xeb, 0x8d, 0xbb, 0x17, 0x33, 0xc5, 0xbc, 0xf2, 0x97, 0x3c, 0xee, 0x9b,
-	0xf8, 0xf3, 0x2d, 0x6e, 0x61, 0x45, 0xb7, 0xb2, 0xe4, 0x66, 0x52, 0x9b, 0x13, 0xd5, 0x11, 0x8d,
-	0x5b, 0xa9, 0xf3, 0x5a, 0xfd, 0x67, 0x50, 0x33, 0x5b, 0x4f, 0xf2, 0x41, 0x62, 0xe7, 0x64, 0x76,
-	0xaf, 0x0d, 0xe7, 0x22, 0x96, 0x59, 0x60, 0xd1, 0x42, 0x26, 0x03, 0xc7, 0x3a, 0xd4, 0x64, 0xe0,
-	0x78, 0x07, 0x8a, 0xc0, 0x18, 0x19, 0x51, 0xe3, 0x48, 0x12, 0x4d, 0x34, 0xfa, 0x4c, 0x3b, 0x32,
-	0x66, 0x7b, 0x4e, 0x8c, 0xe3, 0xff, 0xe4, 0xa1, 0xfa, 0xc4, 0xeb, 0x8f, 0x42, 0x3a, 0x62, 0x6f,
-	0x5d, 0x2c, 0x7b, 0xf0, 0x44, 0x63, 0x87, 0xb3, 0xd9, 0xa6, 0xd9, 0xe1, 0x1c, 0xeb, 0x61, 0x50,
-	0xcd, 0x36, 0x94, 0x44, 0x2b, 0x41, 0x2c, 0xc6, 0x58, 0xcb, 0xd1, 0x78, 0x2f, 0x79, 0xd2, 0xb4,
-	0x36, 0xea, 0x4a, 0x6d, 0x6b, 0x67, 0x9a, 0xd8, 0xc6, 0xed, 0x74, 0x06, 0x0d, 0xf9, 0x33, 0x28,
-	0xb2, 0x37, 0x6d, 0x62, 0xa5, 0x0a, 0xe3, 0xd9, 0xbb, 0xd1, 0x48, 0x9a, 0xd2, 0x00, 0x4f, 0x60,
-	0x41, 0x3d, 0x53, 0x93, 0xf7, 0x2d, 0xfd, 0xe3, 0x4f, 0xda, 0x8d, 0x9b, 0x69, 0xd3, 0x0a, 0x0c,
-	0xc3, 0xfb, 0xaf, 0x15, 0x28, 0xb2, 0x7b, 0x82, 0xd9, 0x1a, 0x95, 0x91, 0xb6, 0xad, 0x33, 0xbd,
-	0x8c, 0x6d, 0xeb, 0x6c, 0x05, 0x2a, 0xce, 0xbc, 0x51, 0x4d, 0x92, 0x04, 0x91, 0x78, 0x2b, 0x64,
-	0x9f, 0xf9, 0x84, 0x52, 0x54, 0xc4, 0xb6, 0x59, 0x56, 0x92, 0x04, 0x21, 0xab, 0x97, 0xb2, 0x63,
-	0x3b, 0xa9, 0x2a, 0x45, 0xe0, 0xa7, 0x50, 0x96, 0x75, 0x64, 0x92, 0xaa, 0xf1, 0xc6, 0x2a, 0x49,
-	0x55, 0xab, 0x08, 0x8d, 0x10, 0xb1, 0xd6, 0x48, 0x43, 0x8c, 0xba, 0x89, 0x34, 0x44, 0xa3, 0x50,
-	0x41, 0xc4, 0xaf, 0x01, 0xa2, 0x8a, 0xd2, 0x4e, 0x76, 0x89, 0x3d, 0x9a, 0x9d, 0xec, 0x92, 0x8b,
-	0x52, 0x84, 0xfe, 0x06, 0xc8, 0x6c, 0x71, 0x49, 0x3e, 0x4e, 0x96, 0x4e, 0xec, 0xec, 0x1a, 0x9f,
-	0xbc, 0x1d, 0xb3, 0x5e, 0xf2, 0x10, 0x2a, 0xba, 0xee, 0x24, 0x4e, 0x8a, 0xfd, 0xe6, 0x4d, 0x73,
-	0xe7, 0x42, 0x1e, 0xdb, 0x4b, 0xf2, 0xae, 0x49, 0x11, 0x8a, 0x5f, 0x37, 0x77, 0x2f, 0x66, 0x32,
-	0xb7, 0x54, 0xd6, 0xa2, 0x49, 0x5b, 0x1a, 0x6f, 0x25, 0x93, 0xb6, 0xd4, 0x2a, 0x64, 0x23, 0xc4,
-	0x94, 0x20, 0x89, 0xb7, 0x9c, 0x69, 0x88, 0x33, 0x41, 0x12, 0x55, 0xa5, 0x49, 0xe6, 0xcf, 0x74,
-	0xac, 0x49, 0xe6, 0xcf, 0x16, 0xb6, 0x62, 0xc7, 0x74, 0x81, 0x9a, 0xb4, 0x63, 0x76, 0xcb, 0xdb,
-	0xb8, 0x73, 0x21, 0x8f, 0xad, 0x72, 0xfa, 0x8e, 0xcd, 0xf4, 0xbd, 0x69, 0x2a, 0xdb, 0x3b, 0xb6,
-	0x51, 0xfb, 0xc3, 0xdf, 0x6f, 0xe6, 0xfe, 0x8c, 0x3f, 0x7f, 0xc3, 0x9f, 0xe3, 0x12, 0xff, 0x8f,
-	0x5b, 0x3f, 0xfa, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x05, 0x71, 0xf8, 0x4c, 0x27, 0x26, 0x00,
-	0x00,
+	// 2339 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x3a, 0x4b, 0x53, 0x1b, 0xd9,
+	0xd5, 0xe8, 0x81, 0x84, 0x8e, 0x84, 0x90, 0x2f, 0xd8, 0xc6, 0xf2, 0xd8, 0x83, 0x1b, 0xec, 0x9a,
+	0xef, 0x1b, 0x17, 0xce, 0xc8, 0x99, 0x4c, 0x2a, 0x99, 0xaa, 0x89, 0x00, 0x19, 0x1c, 0x63, 0x60,
+	0x24, 0xc1, 0xd4, 0x54, 0xa5, 0x4a, 0xd5, 0x48, 0xd7, 0xd0, 0x63, 0xbd, 0xa6, 0xbb, 0xc5, 0x98,
+	0x59, 0xe4, 0x27, 0x64, 0x93, 0x54, 0xe5, 0x47, 0x64, 0x9f, 0x7d, 0x76, 0xc9, 0x2a, 0x59, 0x66,
+	0x95, 0xa4, 0xb2, 0xcc, 0x5f, 0xc8, 0x26, 0xe7, 0xbe, 0xba, 0x6f, 0xb7, 0xae, 0xc0, 0x69, 0xb2,
+	0x30, 0xd0, 0xe7, 0x9e, 0xf7, 0xeb, 0x9e, 0x73, 0x67, 0xa0, 0xe0, 0x8e, 0xbb, 0x9b, 0x63, 0x77,
+	0xe4, 0x8f, 0x48, 0x89, 0xfa, 0xdd, 0x9e, 0x47, 0xdd, 0x0b, 0xea, 0x8e, 0x4f, 0xab, 0x2b, 0x67,
+	0xa3, 0xb3, 0x11, 0x3f, 0x78, 0xc6, 0xfe, 0x12, 0x38, 0xd5, 0x7b, 0x0c, 0xe7, 0xd9, 0xe0, 0xa2,
+	0xdb, 0xe5, 0x3f, 0xc6, 0xa7, 0xcf, 0xde, 0x5e, 0xc8, 0xa3, 0xfb, 0xfc, 0xc8, 0x9e, 0xf8, 0xe7,
+	0xfc, 0x07, 0x1e, 0xb1, 0x5f, 0xe2, 0xd0, 0xfa, 0x05, 0x94, 0x9b, 0xd4, 0x1b, 0x8f, 0x86, 0x1e,
+	0xdd, 0xa3, 0x76, 0x8f, 0xba, 0x84, 0x00, 0x74, 0xfb, 0x13, 0xcf, 0xa7, 0x6e, 0xc7, 0xe9, 0xad,
+	0xa6, 0xd6, 0x52, 0x1f, 0x65, 0xc9, 0x2d, 0x28, 0x0c, 0xe8, 0xe0, 0x54, 0x80, 0xd2, 0x1c, 0x54,
+	0x81, 0x05, 0x97, 0x5e, 0x38, 0x9e, 0x33, 0x1a, 0xae, 0x66, 0x10, 0x92, 0x61, 0x48, 0xae, 0xfd,
+	0xc6, 0xef, 0x20, 0xe5, 0x60, 0x35, 0xcb, 0x90, 0xac, 0x3f, 0xa7, 0xa1, 0xd4, 0xb4, 0x87, 0x67,
+	0xb4, 0x49, 0xbf, 0x9d, 0x50, 0xcf, 0x27, 0x45, 0xc8, 0xbc, 0xa5, 0x97, 0x9c, 0x6b, 0x49, 0x10,
+	0xe0, 0x61, 0x87, 0x0e, 0x05, 0xd7, 0x12, 0x59, 0x84, 0xf9, 0xbe, 0x33, 0x70, 0x7c, 0xc9, 0x52,
+	0x17, 0x92, 0xe5, 0x90, 0x1f, 0x03, 0x78, 0x23, 0xd7, 0xef, 0x8c, 0x5c, 0xd4, 0x75, 0x75, 0x1e,
+	0x61, 0xe5, 0xda, 0xc6, 0xa6, 0xee, 0xa0, 0x4d, 0x5d, 0xe0, 0x66, 0x0b, 0x91, 0x0f, 0x19, 0x2e,
+	0xf9, 0x09, 0x14, 0x39, 0xa5, 0x6f, 0xbb, 0x67, 0xd4, 0x5f, 0xcd, 0x71, 0xd2, 0xc7, 0xd7, 0x90,
+	0xb6, 0x39, 0x32, 0x59, 0x81, 0x12, 0xe2, 0x38, 0x76, 0xdf, 0xf9, 0xde, 0x3e, 0xed, 0xd3, 0xd5,
+	0x3c, 0x12, 0x2f, 0x58, 0x9b, 0x50, 0x08, 0xd9, 0x2f, 0x40, 0xf6, 0xe0, 0xf0, 0xa0, 0x51, 0x99,
+	0x43, 0xff, 0xe5, 0xea, 0xad, 0xed, 0xc6, 0xc1, 0x4e, 0x25, 0x85, 0xf6, 0xe6, 0x77, 0x1a, 0xe2,
+	0x23, 0x6d, 0x6d, 0x01, 0x68, 0x3c, 0xf3, 0x90, 0x79, 0xd5, 0xf8, 0x1a, 0xf1, 0x11, 0xe7, 0xa4,
+	0xd1, 0x6c, 0xbd, 0x3c, 0x3c, 0x40, 0x02, 0x24, 0xde, 0x6e, 0x36, 0xea, 0xed, 0x46, 0x25, 0xcd,
+	0x30, 0x5e, 0x1f, 0xee, 0x54, 0x32, 0xa4, 0x00, 0xf3, 0x27, 0xf5, 0xfd, 0xe3, 0x46, 0x25, 0x6b,
+	0x7d, 0x03, 0x8b, 0x52, 0x49, 0x11, 0x34, 0xf2, 0x14, 0x72, 0xe7, 0x3c, 0x70, 0xdc, 0xa9, 0xc5,
+	0xda, 0x07, 0x31, 0x8b, 0xa2, 0xc1, 0x7d, 0x80, 0xfe, 0xbf, 0xf0, 0xd0, 0xd9, 0x19, 0x44, 0xad,
+	0x6c, 0x8a, 0x54, 0xd9, 0x7c, 0x45, 0x2f, 0x4f, 0xec, 0xfe, 0x84, 0x92, 0x12, 0x64, 0x07, 0x23,
+	0x97, 0x72, 0xef, 0x2f, 0x58, 0x9f, 0x01, 0x1c, 0x4d, 0x7c, 0x63, 0xe8, 0x30, 0x4e, 0x17, 0x8c,
+	0x42, 0x0b, 0x1b, 0xb5, 0x3d, 0x41, 0x98, 0xb1, 0x7e, 0x0a, 0x45, 0x4e, 0x98, 0x44, 0x45, 0xeb,
+	0x87, 0x40, 0x76, 0x68, 0x9f, 0xfa, 0xf4, 0xbf, 0x49, 0x1c, 0xab, 0x0d, 0xcb, 0x11, 0xaa, 0x44,
+	0xde, 0x59, 0x82, 0x7c, 0x8f, 0x33, 0x11, 0x5c, 0x33, 0xd6, 0x1f, 0x52, 0x98, 0xbf, 0x42, 0x83,
+	0xe3, 0x21, 0x26, 0x21, 0x79, 0x0e, 0x8b, 0xae, 0xf8, 0xee, 0x70, 0x0d, 0x24, 0xdb, 0xea, 0xec,
+	0x34, 0xda, 0x9b, 0x23, 0xcf, 0xa0, 0xa8, 0x88, 0xc6, 0x13, 0x9f, 0xb3, 0x2e, 0xd6, 0x56, 0xa3,
+	0x24, 0xa1, 0xa3, 0x91, 0xe0, 0x67, 0xb0, 0xa2, 0x08, 0x84, 0x3e, 0x52, 0x58, 0x86, 0x53, 0xae,
+	0x45, 0x29, 0xa7, 0x9d, 0xb5, 0x37, 0xb7, 0x55, 0x80, 0xbc, 0xe4, 0x60, 0xfd, 0x29, 0x85, 0x29,
+	0x23, 0xed, 0x14, 0x46, 0x7c, 0x0a, 0x65, 0x57, 0x02, 0x22, 0x56, 0xdc, 0x37, 0x5a, 0x21, 0x3d,
+	0x34, 0x47, 0x3e, 0x81, 0x52, 0x40, 0x16, 0xda, 0x71, 0xcf, 0x60, 0x47, 0x40, 0xb2, 0x05, 0xb7,
+	0x03, 0x12, 0x83, 0x25, 0x8f, 0xae, 0xb0, 0x44, 0xf1, 0xc0, 0xa2, 0x59, 0x50, 0x3c, 0xac, 0xbf,
+	0xa6, 0x21, 0xbf, 0x3d, 0x1a, 0x8c, 0x6d, 0x97, 0x62, 0x28, 0x72, 0x08, 0x9f, 0xf4, 0x7d, 0xae,
+	0x7d, 0xb9, 0xb6, 0x1e, 0x65, 0x26, 0xd1, 0xd4, 0xef, 0x26, 0x47, 0x65, 0x44, 0xb2, 0xfe, 0xd3,
+	0xef, 0x41, 0x24, 0x2b, 0x55, 0xe6, 0x5e, 0x46, 0xe6, 0x5e, 0x1e, 0x71, 0xc3, 0x8e, 0x84, 0x56,
+	0xde, 0x83, 0xa5, 0xae, 0x4b, 0x6d, 0x66, 0x9c, 0x6a, 0x56, 0xf3, 0xf2, 0xe8, 0x0e, 0x94, 0x06,
+	0xa3, 0x5e, 0x08, 0xcf, 0x49, 0xf8, 0x92, 0xaa, 0x1f, 0xd6, 0x49, 0x4a, 0x7b, 0x73, 0xd6, 0x27,
+	0xb0, 0x18, 0xd5, 0x14, 0x6b, 0xbe, 0xf1, 0xe5, 0x71, 0x7d, 0x5f, 0x34, 0x88, 0x5d, 0xde, 0x13,
+	0x9a, 0xd8, 0x20, 0xb0, 0xcf, 0xec, 0x37, 0x5a, 0x2d, 0x6c, 0x27, 0x9f, 0x07, 0x24, 0x81, 0x9e,
+	0x41, 0x23, 0x99, 0xd3, 0x1a, 0x49, 0x4a, 0x35, 0x92, 0x74, 0xd8, 0x48, 0x32, 0x5b, 0x65, 0x28,
+	0x09, 0x4f, 0x74, 0x26, 0x2c, 0x29, 0xac, 0x5f, 0xa5, 0x00, 0xda, 0xef, 0x86, 0xaa, 0xde, 0x9e,
+	0x40, 0xbe, 0x2b, 0x98, 0xa3, 0x7b, 0x59, 0xb3, 0xb8, 0x6d, 0xf4, 0x14, 0xf9, 0x18, 0xf2, 0xde,
+	0xa4, 0xdb, 0xa5, 0x9e, 0x6a, 0x2a, 0xf1, 0x52, 0xd0, 0xab, 0x07, 0x91, 0xdf, 0xd8, 0x4e, 0x7f,
+	0xc2, 0x3b, 0xcc, 0x35, 0xc8, 0xd6, 0x2f, 0xa1, 0xc8, 0xf5, 0x49, 0x54, 0xc9, 0xd8, 0x21, 0xb8,
+	0x5a, 0xb4, 0x27, 0x6b, 0x79, 0x81, 0x60, 0xb7, 0x56, 0x79, 0xe4, 0x49, 0xf1, 0xf7, 0xcd, 0x3c,
+	0x84, 0xfc, 0xcf, 0xe0, 0x16, 0x37, 0xb2, 0xeb, 0xe3, 0x97, 0x72, 0x8b, 0x7e, 0x21, 0xa5, 0xd4,
+	0x15, 0x35, 0x3e, 0xbf, 0xf4, 0x9c, 0xae, 0xdd, 0x17, 0x82, 0xb0, 0xcd, 0x13, 0x9d, 0x30, 0x51,
+	0x13, 0x5c, 0x84, 0xe2, 0x9e, 0xed, 0x9d, 0x4b, 0xb1, 0xd6, 0xcf, 0xa1, 0x24, 0x3e, 0x13, 0x39,
+	0x03, 0xbb, 0xfa, 0x39, 0x52, 0x73, 0xf5, 0x16, 0xad, 0x5b, 0xb0, 0xd4, 0x1a, 0xda, 0x63, 0xef,
+	0x7c, 0xa4, 0x3a, 0x8e, 0x75, 0x06, 0x95, 0x10, 0x94, 0x48, 0xc4, 0x5d, 0x58, 0x72, 0xe9, 0xc0,
+	0x76, 0x86, 0xce, 0xf0, 0xac, 0x73, 0x7a, 0xe9, 0x53, 0x4f, 0x8e, 0x09, 0x28, 0xfb, 0xb4, 0x3f,
+	0x3a, 0x15, 0xc5, 0x63, 0xfd, 0x16, 0xfb, 0xe9, 0x57, 0xb6, 0xdf, 0x55, 0x86, 0xe1, 0xa5, 0x5c,
+	0x0e, 0x4a, 0x87, 0x43, 0xa4, 0xb4, 0x58, 0x8f, 0xe3, 0x34, 0xdb, 0x1c, 0x31, 0xec, 0x92, 0x8c,
+	0xd6, 0x1e, 0x76, 0x69, 0x3f, 0xa0, 0x4d, 0xcf, 0xa6, 0xe5, 0x88, 0x61, 0x7f, 0x5c, 0x0a, 0xfb,
+	0xb8, 0x48, 0x7f, 0x0a, 0x64, 0x5a, 0xc8, 0xb5, 0xe3, 0xca, 0x1d, 0x28, 0x7b, 0x58, 0x45, 0x7e,
+	0x27, 0x36, 0x0a, 0xa1, 0x3b, 0x70, 0xbc, 0x3a, 0xc3, 0x7c, 0xf3, 0x3a, 0xc3, 0x91, 0xef, 0xbc,
+	0xb9, 0xe4, 0xcd, 0x62, 0xc1, 0x7a, 0xa2, 0xc4, 0xe8, 0xfa, 0xb0, 0x1c, 0xfa, 0x8e, 0x41, 0xd5,
+	0xc0, 0x95, 0xb1, 0x7e, 0x87, 0x4d, 0x5b, 0x3a, 0x2a, 0x51, 0x3c, 0x74, 0x8e, 0xfc, 0x2a, 0x63,
+	0x77, 0x9b, 0xf0, 0x74, 0x4f, 0xdc, 0xee, 0x0c, 0x45, 0xb8, 0x0f, 0x21, 0x5c, 0x39, 0xb2, 0x0a,
+	0x95, 0xae, 0x48, 0xdc, 0x58, 0x23, 0xc3, 0xb1, 0x21, 0x47, 0x2f, 0xe8, 0xd0, 0xf7, 0x56, 0x8b,
+	0xbc, 0x70, 0x16, 0xd5, 0xe4, 0xd0, 0x60, 0x50, 0xeb, 0x29, 0xdc, 0xda, 0x67, 0xd7, 0xff, 0x2e,
+	0xfa, 0x47, 0x9f, 0x17, 0xda, 0xed, 0x7d, 0x59, 0x25, 0x00, 0xe9, 0x97, 0x3b, 0xf2, 0x52, 0xfd,
+	0x06, 0x88, 0x8e, 0x9d, 0xc8, 0x3e, 0x8d, 0x9f, 0x12, 0x24, 0x3c, 0x8f, 0x93, 0x08, 0x75, 0xdd,
+	0x91, 0xcb, 0x4d, 0x2a, 0x58, 0x6b, 0x52, 0x56, 0x93, 0x5e, 0x8c, 0xde, 0x06, 0x61, 0x15, 0xd4,
+	0xc2, 0xd3, 0xdb, 0xb0, 0x1c, 0xc1, 0x48, 0x54, 0xae, 0xeb, 0x70, 0x9b, 0x33, 0x79, 0x45, 0xe9,
+	0xb8, 0xde, 0x77, 0x2e, 0x8c, 0x92, 0x3a, 0x70, 0x27, 0x8e, 0xf4, 0x3f, 0xb5, 0xdd, 0xda, 0x83,
+	0xdc, 0x6b, 0x3e, 0xa5, 0x6b, 0x62, 0x79, 0x05, 0x0e, 0xed, 0x81, 0x98, 0xd4, 0x0a, 0xbc, 0x5d,
+	0x51, 0xea, 0x1e, 0x37, 0xf7, 0x45, 0x13, 0x2c, 0x88, 0x79, 0xdf, 0xc1, 0x30, 0x72, 0x58, 0x96,
+	0xc1, 0xac, 0x0d, 0xa8, 0x08, 0x4e, 0xf5, 0x5e, 0x4f, 0x4b, 0xd2, 0x80, 0x32, 0xc5, 0xb1, 0xce,
+	0xe0, 0x96, 0x86, 0x95, 0xc8, 0x96, 0x0d, 0xc8, 0x89, 0xc5, 0x42, 0xd6, 0xee, 0x4a, 0x14, 0x5b,
+	0xb0, 0xb7, 0x1e, 0xc1, 0xb2, 0xf8, 0xab, 0x49, 0x07, 0x23, 0x93, 0x73, 0xb3, 0xd6, 0x0e, 0xac,
+	0x44, 0x51, 0x12, 0xc5, 0xf1, 0xb9, 0x12, 0x74, 0x3c, 0xee, 0x69, 0x6d, 0x40, 0x77, 0xa7, 0xee,
+	0x86, 0x34, 0x77, 0x43, 0x20, 0x5a, 0x11, 0x25, 0x12, 0xbd, 0xac, 0x9c, 0xb9, 0xef, 0x78, 0x41,
+	0x63, 0x76, 0x80, 0xe8, 0xc0, 0x44, 0x2e, 0x7e, 0x0c, 0x79, 0xe1, 0x62, 0x75, 0x43, 0x9b, 0x7d,
+	0x8c, 0xf2, 0x77, 0xe8, 0x1b, 0xd7, 0x3e, 0x1b, 0xd0, 0xa0, 0x86, 0xd9, 0x55, 0xa6, 0x03, 0x13,
+	0x19, 0xf6, 0x7b, 0xec, 0xf9, 0xf5, 0xbe, 0xed, 0x0e, 0x94, 0x37, 0x7f, 0x04, 0x39, 0x71, 0x37,
+	0xca, 0xc1, 0xed, 0x49, 0x94, 0x5c, 0xc7, 0x15, 0x1f, 0x75, 0x8e, 0xcd, 0x3c, 0x2f, 0x0c, 0x91,
+	0xd9, 0x9f, 0xc5, 0x21, 0x65, 0xde, 0x66, 0x08, 0x3c, 0xff, 0xcb, 0xb5, 0xbb, 0x06, 0x46, 0xed,
+	0xcb, 0x31, 0xc5, 0x95, 0xa2, 0xa8, 0x33, 0xc2, 0x71, 0x68, 0xb7, 0xd1, 0xc6, 0x19, 0xa9, 0x04,
+	0x0b, 0xf5, 0xed, 0xf6, 0xcb, 0x13, 0x31, 0x25, 0x95, 0x01, 0x76, 0x1a, 0xc1, 0x77, 0xda, 0xda,
+	0x95, 0x54, 0xb2, 0xa6, 0x74, 0xf1, 0xa9, 0xa8, 0xf8, 0xf4, 0xd5, 0xe2, 0xcf, 0x61, 0x51, 0x1a,
+	0x95, 0x28, 0x80, 0xff, 0x87, 0xfe, 0x62, 0xe4, 0x2a, 0x7e, 0xf7, 0x0c, 0x72, 0x64, 0x10, 0xf1,
+	0x5a, 0x6b, 0xf9, 0xb6, 0x3f, 0xf1, 0x54, 0x00, 0x7f, 0x93, 0x82, 0xb2, 0x82, 0x24, 0x5d, 0x89,
+	0xd4, 0xb8, 0x2b, 0x1a, 0x48, 0x19, 0x72, 0xbd, 0xd3, 0x96, 0xf3, 0xbd, 0xdc, 0xf5, 0xd8, 0x77,
+	0x5f, 0xb0, 0xcb, 0xaa, 0xa7, 0x02, 0xf6, 0x0a, 0xf0, 0x72, 0xd8, 0xa3, 0xef, 0xf8, 0xed, 0x21,
+	0x9e, 0x0a, 0x10, 0xd4, 0x66, 0xef, 0x02, 0x39, 0x5e, 0xad, 0x98, 0x6c, 0xf5, 0x89, 0x7f, 0xde,
+	0x18, 0xb2, 0x6d, 0x5a, 0xe9, 0xba, 0x02, 0x84, 0x01, 0x77, 0x1c, 0x4f, 0x87, 0x7e, 0x0a, 0xcb,
+	0x0c, 0x8a, 0xf9, 0x87, 0x23, 0x56, 0x58, 0x92, 0xaa, 0xab, 0xa5, 0x82, 0xae, 0x66, 0x7b, 0xde,
+	0x77, 0x23, 0x57, 0x5c, 0x77, 0x05, 0xb6, 0x45, 0x32, 0xb2, 0x63, 0x2f, 0xd2, 0xc3, 0xae, 0xa3,
+	0x5a, 0x09, 0xa9, 0x76, 0x69, 0x50, 0x05, 0x8f, 0xe1, 0xb6, 0x82, 0xca, 0x15, 0xc5, 0xc4, 0xce,
+	0xfa, 0x02, 0x1e, 0x28, 0xb4, 0xed, 0x73, 0x36, 0x28, 0x1c, 0x49, 0xe6, 0xef, 0x2b, 0xbd, 0x06,
+	0x2b, 0x81, 0x74, 0xfd, 0x26, 0x45, 0xba, 0x89, 0x27, 0xe3, 0x55, 0x60, 0x5f, 0xee, 0xa8, 0x2f,
+	0xfb, 0xb9, 0x75, 0x37, 0xd4, 0x2d, 0x72, 0xc7, 0x59, 0x96, 0x30, 0xa5, 0x89, 0xa8, 0xb3, 0x1c,
+	0xa0, 0xcc, 0x65, 0x38, 0x9a, 0xb9, 0x92, 0x25, 0x83, 0x46, 0xcc, 0xb5, 0x5e, 0x08, 0xfd, 0x38,
+	0x7a, 0x4c, 0x3f, 0xcd, 0xae, 0x35, 0xc8, 0x8e, 0xa9, 0x2c, 0x8a, 0x62, 0x8d, 0x6c, 0x8a, 0x37,
+	0xa7, 0xcd, 0x23, 0x84, 0x39, 0x1e, 0x4b, 0x24, 0x5d, 0x40, 0x54, 0xe7, 0x2d, 0xa1, 0x8f, 0x4a,
+	0x8b, 0x44, 0xed, 0x66, 0x5b, 0xe4, 0x4b, 0x90, 0x45, 0x89, 0x98, 0xb4, 0x84, 0xa5, 0x61, 0xd2,
+	0x25, 0xaa, 0x1d, 0x9c, 0x45, 0x7c, 0xb4, 0x4e, 0x56, 0x8e, 0xd2, 0x2c, 0x48, 0xc9, 0x9b, 0x98,
+	0x17, 0x64, 0x68, 0x22, 0x26, 0x2f, 0xe0, 0x4e, 0x3c, 0xa1, 0x13, 0xf1, 0x39, 0x80, 0x87, 0xb3,
+	0x32, 0x3e, 0x11, 0xbf, 0x46, 0x98, 0xcc, 0x37, 0x18, 0x0e, 0x75, 0xf3, 0x6e, 0x34, 0xd5, 0x49,
+	0x5f, 0x07, 0x25, 0x74, 0x53, 0x26, 0x37, 0x0e, 0x98, 0x5e, 0x92, 0x37, 0x71, 0xb0, 0x56, 0xc1,
+	0x37, 0x55, 0xe7, 0x26, 0x0e, 0xfe, 0x7f, 0x0b, 0x0a, 0xc1, 0x2d, 0xa9, 0x3d, 0xa0, 0x16, 0x21,
+	0x7f, 0x70, 0xd8, 0x3a, 0xaa, 0x6f, 0xe3, 0xad, 0x5c, 0xfb, 0x57, 0x1a, 0xd2, 0xaf, 0x4e, 0xc8,
+	0x16, 0xcc, 0xf3, 0x87, 0x21, 0x72, 0xc5, 0x53, 0x5b, 0xf5, 0xaa, 0x07, 0x2c, 0x6b, 0x8e, 0x7c,
+	0x0e, 0x99, 0xa3, 0x89, 0x4f, 0x66, 0xbe, 0xbc, 0x55, 0x67, 0xbf, 0x65, 0x21, 0x75, 0x1b, 0x8a,
+	0xda, 0x03, 0x15, 0xb9, 0xf6, 0x15, 0xae, 0x7a, 0xfd, 0xeb, 0x96, 0xd0, 0xa9, 0xfd, 0x6e, 0x18,
+	0xd7, 0x29, 0x7c, 0x88, 0x89, 0xeb, 0xa4, 0x3d, 0x89, 0x20, 0xf5, 0x81, 0x7c, 0x0e, 0xeb, 0xfa,
+	0xe4, 0x43, 0xc3, 0xfb, 0x8c, 0xfe, 0x74, 0x51, 0x5d, 0x9b, 0x8d, 0xa0, 0xf8, 0xd5, 0x0e, 0x61,
+	0x9e, 0x6f, 0x9d, 0xe4, 0x85, 0xfa, 0xa3, 0x6a, 0x58, 0xa6, 0x67, 0xb8, 0x3b, 0xb2, 0xaf, 0x5a,
+	0x73, 0x1f, 0xa5, 0x7e, 0x90, 0xaa, 0xfd, 0x3a, 0x0d, 0xf3, 0x7c, 0xe9, 0x21, 0x5f, 0x02, 0x84,
+	0x5b, 0x5f, 0x5c, 0xdb, 0xa9, 0xed, 0x31, 0xae, 0xed, 0xf4, 0xc2, 0x28, 0x22, 0xa2, 0xad, 0x6e,
+	0xc4, 0x44, 0x12, 0xb9, 0x5f, 0xe2, 0x11, 0x31, 0xec, 0x7d, 0xc8, 0xd5, 0x86, 0x72, 0x74, 0x4d,
+	0x23, 0xeb, 0x06, 0xb2, 0xf8, 0xa6, 0x57, 0xdd, 0xb8, 0x1a, 0x29, 0xe2, 0x95, 0xbf, 0xb1, 0x67,
+	0x4c, 0xf1, 0xdf, 0x58, 0x30, 0x84, 0x85, 0x60, 0x89, 0x22, 0x0f, 0x4d, 0xa3, 0x79, 0x78, 0x7d,
+	0x57, 0x3f, 0x9c, 0x79, 0x1e, 0xa8, 0xff, 0x15, 0x94, 0xf4, 0x45, 0x88, 0x3c, 0x32, 0x91, 0x44,
+	0xf6, 0xa8, 0xaa, 0x75, 0x15, 0xca, 0x34, 0x63, 0xb1, 0xe6, 0x98, 0x19, 0x47, 0xf6, 0x26, 0x33,
+	0xe3, 0xe8, 0x96, 0x84, 0x8c, 0x31, 0x33, 0xc2, 0x25, 0x87, 0x18, 0x4d, 0xd4, 0x76, 0xa2, 0x78,
+	0x66, 0x4c, 0xef, 0x47, 0x98, 0xc7, 0xff, 0x4e, 0x43, 0xf1, 0xb5, 0xed, 0x0c, 0x7d, 0x3a, 0x64,
+	0x4f, 0x1c, 0xac, 0x7b, 0xf0, 0x46, 0x13, 0x4f, 0x67, 0x7d, 0xd7, 0x88, 0xa7, 0x73, 0x64, 0x64,
+	0x47, 0x35, 0x1b, 0x90, 0x13, 0x93, 0x34, 0x89, 0x21, 0x46, 0x26, 0xee, 0xea, 0x07, 0xe6, 0x43,
+	0xdd, 0xda, 0x70, 0xa5, 0x8a, 0x5b, 0x3b, 0xb5, 0x81, 0x55, 0xd7, 0x66, 0x23, 0x04, 0x2c, 0xbf,
+	0x80, 0x2c, 0x7b, 0x1d, 0x24, 0xb1, 0x56, 0xa1, 0x3d, 0x20, 0x56, 0xab, 0xa6, 0xa3, 0x80, 0xc1,
+	0x6b, 0x58, 0x50, 0xef, 0x7f, 0xe4, 0x41, 0x4c, 0xff, 0xe8, 0x53, 0x61, 0xf5, 0xe1, 0xac, 0x63,
+	0xc5, 0x0c, 0xd3, 0xfb, 0xef, 0x05, 0xc8, 0xb2, 0xfb, 0x81, 0xd9, 0x1a, 0xce, 0x73, 0x71, 0x5b,
+	0xa7, 0x16, 0x80, 0xb8, 0xad, 0xd3, 0xa3, 0xa0, 0xa8, 0x79, 0x6d, 0xbc, 0x23, 0x06, 0x92, 0xe8,
+	0xfe, 0x10, 0xaf, 0x79, 0xc3, 0x6c, 0x28, 0x72, 0x5b, 0x9f, 0xf7, 0x88, 0x81, 0x28, 0xb6, 0x80,
+	0xc4, 0x73, 0xdb, 0x34, 0x2e, 0x22, 0xe3, 0x23, 0xc8, 0xcb, 0x79, 0xcf, 0xa4, 0x6a, 0x74, 0x3b,
+	0x31, 0xa9, 0x1a, 0x1b, 0x16, 0x43, 0x8e, 0x38, 0x4b, 0xcc, 0xe2, 0x18, 0x8e, 0xf2, 0xb3, 0x38,
+	0x6a, 0x83, 0x08, 0x72, 0xfc, 0x1a, 0x20, 0x9c, 0x04, 0xe3, 0xcd, 0xce, 0xb8, 0xf8, 0xc4, 0x9b,
+	0x9d, 0x79, 0x98, 0x44, 0xd6, 0xdf, 0x02, 0x99, 0x1e, 0x0e, 0xc9, 0xc7, 0x66, 0x6a, 0xe3, 0xd2,
+	0x54, 0x7d, 0xfa, 0x7e, 0xc8, 0x81, 0xc8, 0x13, 0x28, 0x04, 0xf3, 0x23, 0xb1, 0x66, 0xd8, 0xaf,
+	0xdf, 0x34, 0xeb, 0x57, 0xe2, 0xc4, 0xbd, 0x24, 0xef, 0x9a, 0x19, 0x44, 0xd1, 0xeb, 0x66, 0xe3,
+	0x6a, 0x24, 0x3d, 0xa4, 0x72, 0xc6, 0x34, 0x85, 0x34, 0xba, 0xc1, 0x99, 0x42, 0x1a, 0x1b, 0x50,
+	0x43, 0x8e, 0x33, 0x92, 0x24, 0xba, 0xef, 0xcd, 0xe2, 0x38, 0x95, 0x24, 0xe1, 0xf4, 0x69, 0x32,
+	0x7f, 0x6a, 0x5d, 0x34, 0x99, 0x3f, 0x3d, 0xc0, 0x8a, 0x88, 0x05, 0x03, 0xa9, 0x29, 0x62, 0xf1,
+	0x7d, 0xb3, 0xba, 0x7e, 0x25, 0x4e, 0x5c, 0xe5, 0xd9, 0x11, 0x9b, 0x5a, 0x40, 0x67, 0xa9, 0x1c,
+	0x8f, 0xd8, 0x56, 0xe9, 0x8f, 0xff, 0x7c, 0x98, 0xfa, 0x0b, 0xfe, 0xfb, 0x07, 0xfe, 0x3b, 0xcd,
+	0xf1, 0xff, 0x95, 0xe2, 0xf9, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x6e, 0x06, 0x62, 0xb3,
+	0x21, 0x00, 0x00,
 }

etcdserver/etcdserverpb/rpc.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 package etcdserverpb;
 
 import "gogoproto/gogo.proto";
-import "etcd/storage/storagepb/kv.proto";
+import "etcd/mvcc/mvccpb/kv.proto";
 import "etcd/auth/authpb/auth.proto";
 
 option (gogoproto.marshaler_all) = true;
@@ -192,7 +192,7 @@ message RangeRequest {
 message RangeResponse {
   ResponseHeader header = 1;
   // kvs is the list of key-value pairs matched by the range request.
-  repeated storagepb.KeyValue kvs = 2;
+  repeated mvccpb.KeyValue kvs = 2;
   // more indicates if there are more keys to return in the requested range.
   bool more = 3;
 }
@@ -401,7 +401,7 @@ message WatchResponse {
   // watcher with the same start_revision again.
   int64 compact_revision  = 5;
 
-  repeated storagepb.Event events = 11;
+  repeated mvccpb.Event events = 11;
 }
 
 message LeaseGrantRequest {

etcdserver/membership/cluster.go

@@ -25,11 +25,11 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/netutil"
 	"github.com/coreos/etcd/pkg/types"
 	"github.com/coreos/etcd/raft"
 	"github.com/coreos/etcd/raft/raftpb"
-	"github.com/coreos/etcd/storage/backend"
 	"github.com/coreos/etcd/store"
 	"github.com/coreos/etcd/version"
 	"github.com/coreos/go-semver/semver"

etcdserver/membership/store.go

@@ -19,8 +19,8 @@ import (
 	"fmt"
 	"path"
 
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/types"
-	"github.com/coreos/etcd/storage/backend"
 	"github.com/coreos/etcd/store"
 
 	"github.com/coreos/go-semver/semver"

etcdserver/quota.go

@@ -16,7 +16,7 @@ package etcdserver
 
 import (
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 // Quota represents an arbitrary quota against arbitrary requests. Each request

etcdserver/server.go

@@ -36,6 +36,8 @@ import (
 	"github.com/coreos/etcd/etcdserver/membership"
 	"github.com/coreos/etcd/etcdserver/stats"
 	"github.com/coreos/etcd/lease"
+	"github.com/coreos/etcd/mvcc"
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/fileutil"
 	"github.com/coreos/etcd/pkg/idutil"
 	"github.com/coreos/etcd/pkg/pbutil"
@@ -47,8 +49,6 @@ import (
 	"github.com/coreos/etcd/raft/raftpb"
 	"github.com/coreos/etcd/rafthttp"
 	"github.com/coreos/etcd/snap"
-	dstorage "github.com/coreos/etcd/storage"
-	"github.com/coreos/etcd/storage/backend"
 	"github.com/coreos/etcd/store"
 	"github.com/coreos/etcd/version"
 	"github.com/coreos/etcd/wal"
@@ -181,7 +181,7 @@ type EtcdServer struct {
 	applyV2 applierV2
 
 	applyV3    applierV3
-	kv         dstorage.ConsistentWatchableKV
+	kv         mvcc.ConsistentWatchableKV
 	lessor     lease.Lessor
 	bemu       sync.Mutex
 	be         backend.Backend
@@ -392,7 +392,7 @@ func NewServer(cfg *ServerConfig) (srv *EtcdServer, err error) {
 
 	srv.be = be
 	srv.lessor = lease.NewLessor(srv.be)
-	srv.kv = dstorage.New(srv.be, srv.lessor, &srv.consistIndex)
+	srv.kv = mvcc.New(srv.be, srv.lessor, &srv.consistIndex)
 	srv.consistIndex.setConsistentIndex(srv.kv.ConsistentIndex())
 	srv.authStore = auth.NewAuthStore(srv.be)
 	if h := cfg.AutoCompactionRetention; h != 0 {
@@ -1258,7 +1258,7 @@ func (s *EtcdServer) parseProposeCtxErr(err error, start time.Time) error {
 	}
 }
 
-func (s *EtcdServer) KV() dstorage.ConsistentWatchableKV { return s.kv }
+func (s *EtcdServer) KV() mvcc.ConsistentWatchableKV { return s.kv }
 func (s *EtcdServer) Backend() backend.Backend {
 	s.bemu.Lock()
 	defer s.bemu.Unlock()

etcdserver/server_test.go

@@ -27,6 +27,8 @@ import (
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/etcdserver/membership"
 	"github.com/coreos/etcd/lease"
+	"github.com/coreos/etcd/mvcc"
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/pkg/idutil"
 	"github.com/coreos/etcd/pkg/mock/mockstorage"
 	"github.com/coreos/etcd/pkg/mock/mockstore"
@@ -38,8 +40,6 @@ import (
 	"github.com/coreos/etcd/raft"
 	"github.com/coreos/etcd/raft/raftpb"
 	"github.com/coreos/etcd/rafthttp"
-	dstorage "github.com/coreos/etcd/storage"
-	"github.com/coreos/etcd/storage/backend"
 	"github.com/coreos/etcd/store"
 	"golang.org/x/net/context"
 )
@@ -855,7 +855,7 @@ func TestSnapshot(t *testing.T) {
 		},
 		store: st,
 	}
-	srv.kv = dstorage.New(be, &lease.FakeLessor{}, &srv.consistIndex)
+	srv.kv = mvcc.New(be, &lease.FakeLessor{}, &srv.consistIndex)
 	srv.be = be
 
 	srv.snapshot(1, raftpb.ConfState{Nodes: []uint64{1}})
@@ -902,7 +902,7 @@ func TestTriggerSnap(t *testing.T) {
 	}
 	srv.applyV2 = &applierV2store{srv}
 
-	srv.kv = dstorage.New(be, &lease.FakeLessor{}, &srv.consistIndex)
+	srv.kv = mvcc.New(be, &lease.FakeLessor{}, &srv.consistIndex)
 	srv.be = be
 
 	srv.start()
@@ -974,7 +974,7 @@ func TestConcurrentApplyAndSnapshotV3(t *testing.T) {
 	defer func() {
 		os.RemoveAll(tmpPath)
 	}()
-	s.kv = dstorage.New(be, &lease.FakeLessor{}, &s.consistIndex)
+	s.kv = mvcc.New(be, &lease.FakeLessor{}, &s.consistIndex)
 	s.be = be
 
 	s.start()

etcdserver/snapshot_merge.go

@@ -18,9 +18,9 @@ import (
 	"io"
 	"log"
 
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/coreos/etcd/raft/raftpb"
 	"github.com/coreos/etcd/snap"
-	"github.com/coreos/etcd/storage/backend"
 )
 
 // createMergedSnapshotMessage creates a snapshot message that contains: raft status (term, conf),

etcdserver/v3_server.go

@@ -20,7 +20,7 @@ import (
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
 	"github.com/coreos/etcd/lease"
 	"github.com/coreos/etcd/lease/leasehttp"
-	dstorage "github.com/coreos/etcd/storage"
+	"github.com/coreos/etcd/mvcc"
 	"golang.org/x/net/context"
 )
 
@@ -297,4 +297,4 @@ func (s *EtcdServer) processInternalRaftRequest(ctx context.Context, r pb.Intern
 }
 
 // Watchable returns a watchable interface attached to the etcdserver.
-func (s *EtcdServer) Watchable() dstorage.Watchable { return s.KV() }
+func (s *EtcdServer) Watchable() mvcc.Watchable { return s.KV() }

integration/v3_lease_test.go

@@ -21,8 +21,8 @@ import (
 
 	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/testutil"
-	"github.com/coreos/etcd/storage/storagepb"
 	"golang.org/x/net/context"
 )
 
@@ -158,7 +158,7 @@ func TestV3LeaseExpire(t *testing.T) {
 				errc <- err
 			case len(resp.Events) != 1:
 				fallthrough
-			case resp.Events[0].Type != storagepb.DELETE:
+			case resp.Events[0].Type != mvccpb.DELETE:
 				errc <- fmt.Errorf("expected key delete, got %v", resp)
 			default:
 				errc <- nil

integration/v3_watch_test.go

@@ -25,8 +25,8 @@ import (
 
 	"github.com/coreos/etcd/etcdserver/api/v3rpc"
 	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/testutil"
-	"github.com/coreos/etcd/storage/storagepb"
 	"golang.org/x/net/context"
 )
 
@@ -50,10 +50,10 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
 				{
 					Header:  &pb.ResponseHeader{Revision: 2},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 						},
 					},
 				},
@@ -80,10 +80,10 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
 				{
 					Header:  &pb.ResponseHeader{Revision: 2},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("fooLong"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("fooLong"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 						},
 					},
 				},
@@ -111,10 +111,10 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
 				{
 					Header:  &pb.ResponseHeader{Revision: 2},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("fooLong"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("fooLong"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 						},
 					},
 				},
@@ -131,30 +131,30 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
 				{
 					Header:  &pb.ResponseHeader{Revision: 2},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 						},
 					},
 				},
 				{
 					Header:  &pb.ResponseHeader{Revision: 3},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 2},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 2},
 						},
 					},
 				},
 				{
 					Header:  &pb.ResponseHeader{Revision: 4},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 4, Version: 3},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 4, Version: 3},
 						},
 					},
 				},
@@ -172,30 +172,30 @@ func TestV3WatchFromCurrentRevision(t *testing.T) {
 				{
 					Header:  &pb.ResponseHeader{Revision: 2},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 						},
 					},
 				},
 				{
 					Header:  &pb.ResponseHeader{Revision: 3},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 2},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 2},
 						},
 					},
 				},
 				{
 					Header:  &pb.ResponseHeader{Revision: 4},
 					Created: false,
-					Events: []*storagepb.Event{
+					Events: []*mvccpb.Event{
 						{
-							Type: storagepb.PUT,
-							Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 4, Version: 3},
+							Type: mvccpb.PUT,
+							Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 4, Version: 3},
 						},
 					},
 				},
@@ -527,10 +527,10 @@ func TestV3WatchEmptyKey(t *testing.T) {
 	if rerr != nil {
 		t.Fatal(rerr)
 	}
-	wevs := []*storagepb.Event{
+	wevs := []*mvccpb.Event{
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo"), CreateRevision: 2, ModRevision: 2, Version: 1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo"), CreateRevision: 2, ModRevision: 2, Version: 1},
 		},
 	}
 	if !reflect.DeepEqual(resp.Events, wevs) {
@@ -691,7 +691,7 @@ func testV3WatchMultipleEventsTxn(t *testing.T, startRev int64) {
 		t.Fatalf("kvc.Txn failed: %+v", tresp)
 	}
 
-	events := []*storagepb.Event{}
+	events := []*mvccpb.Event{}
 	for len(events) < 3 {
 		resp, err := wStream.Recv()
 		if err != nil {
@@ -704,18 +704,18 @@ func testV3WatchMultipleEventsTxn(t *testing.T, startRev int64) {
 	}
 	sort.Sort(eventsSortByKey(events))
 
-	wevents := []*storagepb.Event{
+	wevents := []*mvccpb.Event{
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo0"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo0"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo1"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo1"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo2"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo2"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 		},
 	}
 
@@ -732,7 +732,7 @@ func testV3WatchMultipleEventsTxn(t *testing.T, startRev int64) {
 	clus.Terminate(t)
 }
 
-type eventsSortByKey []*storagepb.Event
+type eventsSortByKey []*mvccpb.Event
 
 func (evs eventsSortByKey) Len() int           { return len(evs) }
 func (evs eventsSortByKey) Swap(i, j int)      { evs[i], evs[j] = evs[j], evs[i] }
@@ -773,26 +773,26 @@ func TestV3WatchMultipleEventsPutUnsynced(t *testing.T) {
 		t.Fatalf("couldn't put key (%v)", err)
 	}
 
-	allWevents := []*storagepb.Event{
+	allWevents := []*mvccpb.Event{
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo0"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo0"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo1"), Value: []byte("bar"), CreateRevision: 3, ModRevision: 3, Version: 1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo1"), Value: []byte("bar"), CreateRevision: 3, ModRevision: 3, Version: 1},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo0"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 4, Version: 2},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo0"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 4, Version: 2},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo1"), Value: []byte("bar"), CreateRevision: 3, ModRevision: 5, Version: 2},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo1"), Value: []byte("bar"), CreateRevision: 3, ModRevision: 5, Version: 2},
 		},
 	}
 
-	events := []*storagepb.Event{}
+	events := []*mvccpb.Event{}
 	for len(events) < 4 {
 		resp, err := wStream.Recv()
 		if err != nil {
@@ -866,10 +866,10 @@ func testV3WatchMultipleStreams(t *testing.T, startRev int64) {
 
 	var wg sync.WaitGroup
 	wg.Add(len(streams))
-	wevents := []*storagepb.Event{
+	wevents := []*mvccpb.Event{
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1},
 		},
 	}
 	for i := range streams {

lease/leasepb/lease.pb.go

@@ -33,8 +33,8 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion1
 
 type Lease struct {
-	ID  int64 `protobuf:"varint,1,opt,name=ID,json=iD,proto3" json:"ID,omitempty"`
-	TTL int64 `protobuf:"varint,2,opt,name=TTL,json=tTL,proto3" json:"TTL,omitempty"`
+	ID  int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	TTL int64 `protobuf:"varint,2,opt,name=TTL,proto3" json:"TTL,omitempty"`
 }
 
 func (m *Lease) Reset()                    { *m = Lease{} }
@@ -319,13 +319,12 @@ var (
 )
 
 var fileDescriptorLease = []byte{
-	// 117 bytes of a gzipped FileDescriptorProto
+	// 108 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0xce, 0x49, 0x4d, 0x2c,
 	0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x07, 0x73, 0x0a, 0x92, 0xa4, 0x44, 0xd2,
-	0xf3, 0xd3, 0xf3, 0xc1, 0x62, 0xfa, 0x20, 0x16, 0x44, 0x5a, 0x49, 0x93, 0x8b, 0xd5, 0x07, 0xa4,
-	0x40, 0x88, 0x8f, 0x8b, 0xc9, 0xd3, 0x45, 0x82, 0x51, 0x81, 0x51, 0x83, 0x39, 0x88, 0x29, 0xd3,
-	0x45, 0x48, 0x80, 0x8b, 0x39, 0x24, 0xc4, 0x47, 0x82, 0x09, 0x2c, 0xc0, 0x5c, 0x12, 0xe2, 0xe3,
-	0x24, 0x72, 0xe2, 0xa1, 0x1c, 0xc3, 0x05, 0x20, 0x3e, 0xf1, 0x48, 0x8e, 0xf1, 0x02, 0x10, 0x3f,
-	0x00, 0xe2, 0x24, 0x36, 0xb0, 0x39, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x1d, 0x92,
-	0xdc, 0x75, 0x00, 0x00, 0x00,
+	0xf3, 0xd3, 0xf3, 0xc1, 0x62, 0xfa, 0x20, 0x16, 0x44, 0x5a, 0x49, 0x81, 0x8b, 0xd5, 0x07, 0xa4,
+	0x40, 0x88, 0x8b, 0x8b, 0xc9, 0xd3, 0x45, 0x82, 0x51, 0x81, 0x51, 0x83, 0x59, 0x88, 0x9b, 0x8b,
+	0x39, 0x24, 0xc4, 0x47, 0x82, 0x09, 0xc4, 0x71, 0x12, 0x39, 0xf1, 0x50, 0x8e, 0xe1, 0x02, 0x10,
+	0x9f, 0x78, 0x24, 0xc7, 0x78, 0x01, 0x88, 0x1f, 0x00, 0x71, 0x12, 0x1b, 0x58, 0xbb, 0x31, 0x20,
+	0x00, 0x00, 0xff, 0xff, 0x87, 0x43, 0xe8, 0x0c, 0x6c, 0x00, 0x00, 0x00,
 }

lease/lessor.go

@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease/leasepb"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 const (
@@ -47,7 +47,7 @@ type LeaseID int64
 
 // RangeDeleter defines an interface with DeleteRange method.
 // We define this interface only for lessor to limit the number
-// of methods of storage.KV to what lessor actually needs.
+// of methods of mvcc.KV to what lessor actually needs.
 //
 // Having a minimum interface makes testing easy.
 type RangeDeleter interface {

lease/lessor_test.go

@@ -22,7 +22,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 // TestLessorGrant ensures Lessor can grant wanted lease.

storage/backend/batch_tx.go → mvcc/backend/batch_tx.go

@@ -52,7 +52,7 @@ func newBatchTx(backend *backend) *batchTx {
 func (t *batchTx) UnsafeCreateBucket(name []byte) {
 	_, err := t.tx.CreateBucket(name)
 	if err != nil && err != bolt.ErrBucketExists {
-		log.Fatalf("storage: cannot create bucket %s (%v)", string(name), err)
+		log.Fatalf("mvcc: cannot create bucket %s (%v)", string(name), err)
 	}
 	t.pending++
 }
@@ -70,7 +70,7 @@ func (t *batchTx) UnsafeSeqPut(bucketName []byte, key []byte, value []byte) {
 func (t *batchTx) unsafePut(bucketName []byte, key []byte, value []byte, seq bool) {
 	bucket := t.tx.Bucket(bucketName)
 	if bucket == nil {
-		log.Fatalf("storage: bucket %s does not exist", string(bucketName))
+		log.Fatalf("mvcc: bucket %s does not exist", string(bucketName))
 	}
 	if seq {
 		// it is useful to increase fill percent when the workloads are mostly append-only.
@@ -78,7 +78,7 @@ func (t *batchTx) unsafePut(bucketName []byte, key []byte, value []byte, seq boo
 		bucket.FillPercent = 0.9
 	}
 	if err := bucket.Put(key, value); err != nil {
-		log.Fatalf("storage: cannot put key into bucket (%v)", err)
+		log.Fatalf("mvcc: cannot put key into bucket (%v)", err)
 	}
 	t.pending++
 }
@@ -87,7 +87,7 @@ func (t *batchTx) unsafePut(bucketName []byte, key []byte, value []byte, seq boo
 func (t *batchTx) UnsafeRange(bucketName []byte, key, endKey []byte, limit int64) (keys [][]byte, vs [][]byte) {
 	bucket := t.tx.Bucket(bucketName)
 	if bucket == nil {
-		log.Fatalf("storage: bucket %s does not exist", string(bucketName))
+		log.Fatalf("mvcc: bucket %s does not exist", string(bucketName))
 	}
 
 	if len(endKey) == 0 {
@@ -114,11 +114,11 @@ func (t *batchTx) UnsafeRange(bucketName []byte, key, endKey []byte, limit int64
 func (t *batchTx) UnsafeDelete(bucketName []byte, key []byte) {
 	bucket := t.tx.Bucket(bucketName)
 	if bucket == nil {
-		log.Fatalf("storage: bucket %s does not exist", string(bucketName))
+		log.Fatalf("mvcc: bucket %s does not exist", string(bucketName))
 	}
 	err := bucket.Delete(key)
 	if err != nil {
-		log.Fatalf("storage: cannot delete key from bucket (%v)", err)
+		log.Fatalf("mvcc: cannot delete key from bucket (%v)", err)
 	}
 	t.pending++
 }
@@ -170,7 +170,7 @@ func (t *batchTx) commit(stop bool) {
 
 		t.pending = 0
 		if err != nil {
-			log.Fatalf("storage: cannot commit tx (%s)", err)
+			log.Fatalf("mvcc: cannot commit tx (%s)", err)
 		}
 	}
 
@@ -183,7 +183,7 @@ func (t *batchTx) commit(stop bool) {
 	// begin a new tx
 	t.tx, err = t.backend.db.Begin(true)
 	if err != nil {
-		log.Fatalf("storage: cannot begin tx (%s)", err)
+		log.Fatalf("mvcc: cannot begin tx (%s)", err)
 	}
 	atomic.StoreInt64(&t.backend.size, t.tx.Size())
 }

storage/backend/doc.go → mvcc/backend/doc.go

@@ -12,5 +12,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package backend defines a standard interface for etcd's backend storage.
+// Package backend defines a standard interface for etcd's backend MVCC storage.
 package backend

storage/doc.go → mvcc/doc.go

@@ -12,5 +12,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package storage defines etcd's stable storage.
-package storage
+// Package mvcc defines etcd's stable MVCC storage.
+package mvcc

storage/index.go → mvcc/index.go

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

storage/index_test.go → mvcc/index_test.go

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

storage/key_index.go → mvcc/key_index.go

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

storage/key_index_test.go → mvcc/key_index_test.go

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

storage/kv.go → mvcc/kv.go

@@ -12,12 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/backend"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
 type KV interface {
@@ -37,7 +37,7 @@ type KV interface {
 	// If `end` is not nil and empty, it gets the keys greater than or equal to key.
 	// Limit limits the number of keys returned.
 	// If the required rev is compacted, ErrCompacted will be returned.
-	Range(key, end []byte, limit, rangeRev int64) (kvs []storagepb.KeyValue, rev int64, err error)
+	Range(key, end []byte, limit, rangeRev int64) (kvs []mvccpb.KeyValue, rev int64, err error)
 
 	// Put puts the given key, value into the store. Put also takes additional argument lease to
 	// attach a lease to a key-value pair as meta-data. KV implementation does not validate the lease
@@ -63,7 +63,7 @@ type KV interface {
 	// TxnEnd ends the on-going txn with txn ID. If the on-going txn ID is not matched, error is returned.
 	TxnEnd(txnID int64) error
 	// TxnRange returns the current revision of the KV when the operation is executed.
-	TxnRange(txnID int64, key, end []byte, limit, rangeRev int64) (kvs []storagepb.KeyValue, rev int64, err error)
+	TxnRange(txnID int64, key, end []byte, limit, rangeRev int64) (kvs []mvccpb.KeyValue, rev int64, err error)
 	TxnPut(txnID int64, key, value []byte, lease lease.LeaseID) (rev int64, err error)
 	TxnDeleteRange(txnID int64, key, end []byte) (n, rev int64, err error)
 

storage/kv_test.go → mvcc/kv_test.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"fmt"
@@ -22,9 +22,9 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease"
+	"github.com/coreos/etcd/mvcc/backend"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/testutil"
-	"github.com/coreos/etcd/storage/backend"
-	"github.com/coreos/etcd/storage/storagepb"
 )
 
 // Functional tests for features implemented in v3 store. It treats v3 store
@@ -33,16 +33,16 @@ import (
 // TODO: add similar tests on operations in one txn/rev
 
 type (
-	rangeFunc       func(kv KV, key, end []byte, limit, rangeRev int64) ([]storagepb.KeyValue, int64, error)
+	rangeFunc       func(kv KV, key, end []byte, limit, rangeRev int64) ([]mvccpb.KeyValue, int64, error)
 	putFunc         func(kv KV, key, value []byte, lease lease.LeaseID) int64
 	deleteRangeFunc func(kv KV, key, end []byte) (n, rev int64)
 )
 
 var (
-	normalRangeFunc = func(kv KV, key, end []byte, limit, rangeRev int64) ([]storagepb.KeyValue, int64, error) {
+	normalRangeFunc = func(kv KV, key, end []byte, limit, rangeRev int64) ([]mvccpb.KeyValue, int64, error) {
 		return kv.Range(key, end, limit, rangeRev)
 	}
-	txnRangeFunc = func(kv KV, key, end []byte, limit, rangeRev int64) ([]storagepb.KeyValue, int64, error) {
+	txnRangeFunc = func(kv KV, key, end []byte, limit, rangeRev int64) ([]mvccpb.KeyValue, int64, error) {
 		id := kv.TxnBegin()
 		defer kv.TxnEnd(id)
 		return kv.TxnRange(id, key, end, limit, rangeRev)
@@ -88,7 +88,7 @@ func testKVRange(t *testing.T, f rangeFunc) {
 	wrev := int64(4)
 	tests := []struct {
 		key, end []byte
-		wkvs     []storagepb.KeyValue
+		wkvs     []mvccpb.KeyValue
 	}{
 		// get no keys
 		{
@@ -154,7 +154,7 @@ func testKVRangeRev(t *testing.T, f rangeFunc) {
 	tests := []struct {
 		rev  int64
 		wrev int64
-		wkvs []storagepb.KeyValue
+		wkvs []mvccpb.KeyValue
 	}{
 		{-1, 4, kvs},
 		{0, 4, kvs},
@@ -223,7 +223,7 @@ func testKVRangeLimit(t *testing.T, f rangeFunc) {
 	wrev := int64(4)
 	tests := []struct {
 		limit int64
-		wkvs  []storagepb.KeyValue
+		wkvs  []mvccpb.KeyValue
 	}{
 		// no limit
 		{-1, kvs},
@@ -268,7 +268,7 @@ func testKVPutMultipleTimes(t *testing.T, f putFunc) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		wkvs := []storagepb.KeyValue{
+		wkvs := []mvccpb.KeyValue{
 			{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: base + 1, Version: base, Lease: base},
 		}
 		if !reflect.DeepEqual(kvs, wkvs) {
@@ -372,7 +372,7 @@ func TestKVOperationInSequence(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		wkvs := []storagepb.KeyValue{
+		wkvs := []mvccpb.KeyValue{
 			{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: base + 1, ModRevision: base + 1, Version: 1, Lease: int64(lease.NoLease)},
 		}
 		if !reflect.DeepEqual(kvs, wkvs) {
@@ -494,7 +494,7 @@ func TestKVTxnOperationInSequence(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		wkvs := []storagepb.KeyValue{
+		wkvs := []mvccpb.KeyValue{
 			{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: base + 1, ModRevision: base + 1, Version: 1, Lease: int64(lease.NoLease)},
 		}
 		if !reflect.DeepEqual(kvs, wkvs) {
@@ -542,17 +542,17 @@ func TestKVCompactReserveLastValue(t *testing.T) {
 	tests := []struct {
 		rev int64
 		// wanted kvs right after the compacted rev
-		wkvs []storagepb.KeyValue
+		wkvs []mvccpb.KeyValue
 	}{
 		{
 			1,
-			[]storagepb.KeyValue{
+			[]mvccpb.KeyValue{
 				{Key: []byte("foo"), Value: []byte("bar0"), CreateRevision: 2, ModRevision: 2, Version: 1, Lease: 1},
 			},
 		},
 		{
 			2,
-			[]storagepb.KeyValue{
+			[]mvccpb.KeyValue{
 				{Key: []byte("foo"), Value: []byte("bar1"), CreateRevision: 2, ModRevision: 3, Version: 2, Lease: 2},
 			},
 		},
@@ -562,7 +562,7 @@ func TestKVCompactReserveLastValue(t *testing.T) {
 		},
 		{
 			4,
-			[]storagepb.KeyValue{
+			[]mvccpb.KeyValue{
 				{Key: []byte("foo"), Value: []byte("bar2"), CreateRevision: 5, ModRevision: 5, Version: 1, Lease: 3},
 			},
 		},
@@ -656,7 +656,7 @@ func TestKVRestore(t *testing.T) {
 		b, tmpPath := backend.NewDefaultTmpBackend()
 		s := NewStore(b, &lease.FakeLessor{}, nil)
 		tt(s)
-		var kvss [][]storagepb.KeyValue
+		var kvss [][]mvccpb.KeyValue
 		for k := int64(0); k < 10; k++ {
 			kvs, _, _ := s.Range([]byte("a"), []byte("z"), 0, k)
 			kvss = append(kvss, kvs)
@@ -667,7 +667,7 @@ func TestKVRestore(t *testing.T) {
 		ns := NewStore(b, &lease.FakeLessor{}, nil)
 		// wait for possible compaction to finish
 		testutil.WaitSchedule()
-		var nkvss [][]storagepb.KeyValue
+		var nkvss [][]mvccpb.KeyValue
 		for k := int64(0); k < 10; k++ {
 			nkvs, _, _ := ns.Range([]byte("a"), []byte("z"), 0, k)
 			nkvss = append(nkvss, nkvs)
@@ -726,9 +726,9 @@ func TestWatchableKVWatch(t *testing.T) {
 
 	wid := w.Watch([]byte("foo"), []byte("fop"), 0)
 
-	wev := []storagepb.Event{
-		{Type: storagepb.PUT,
-			Kv: &storagepb.KeyValue{
+	wev := []mvccpb.Event{
+		{Type: mvccpb.PUT,
+			Kv: &mvccpb.KeyValue{
 				Key:            []byte("foo"),
 				Value:          []byte("bar"),
 				CreateRevision: 2,
@@ -738,8 +738,8 @@ func TestWatchableKVWatch(t *testing.T) {
 			},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv: &storagepb.KeyValue{
+			Type: mvccpb.PUT,
+			Kv: &mvccpb.KeyValue{
 				Key:            []byte("foo1"),
 				Value:          []byte("bar1"),
 				CreateRevision: 3,
@@ -749,8 +749,8 @@ func TestWatchableKVWatch(t *testing.T) {
 			},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv: &storagepb.KeyValue{
+			Type: mvccpb.PUT,
+			Kv: &mvccpb.KeyValue{
 				Key:            []byte("foo1"),
 				Value:          []byte("bar11"),
 				CreateRevision: 3,
@@ -827,11 +827,11 @@ func cleanup(s KV, b backend.Backend, path string) {
 	os.Remove(path)
 }
 
-func put3TestKVs(s KV) []storagepb.KeyValue {
+func put3TestKVs(s KV) []mvccpb.KeyValue {
 	s.Put([]byte("foo"), []byte("bar"), 1)
 	s.Put([]byte("foo1"), []byte("bar1"), 2)
 	s.Put([]byte("foo2"), []byte("bar2"), 3)
-	return []storagepb.KeyValue{
+	return []mvccpb.KeyValue{
 		{Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1, Lease: 1},
 		{Key: []byte("foo1"), Value: []byte("bar1"), CreateRevision: 3, ModRevision: 3, Version: 1, Lease: 2},
 		{Key: []byte("foo2"), Value: []byte("bar2"), CreateRevision: 4, ModRevision: 4, Version: 1, Lease: 3},

storage/kvstore.go → mvcc/kvstore.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"encoding/binary"
@@ -24,9 +24,9 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease"
+	"github.com/coreos/etcd/mvcc/backend"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/schedule"
-	"github.com/coreos/etcd/storage/backend"
-	"github.com/coreos/etcd/storage/storagepb"
 	"golang.org/x/net/context"
 )
 
@@ -45,10 +45,10 @@ var (
 	scheduledCompactKeyName = []byte("scheduledCompactRev")
 	finishedCompactKeyName  = []byte("finishedCompactRev")
 
-	ErrTxnIDMismatch = errors.New("storage: txn id mismatch")
-	ErrCompacted     = errors.New("storage: required revision has been compacted")
-	ErrFutureRev     = errors.New("storage: required revision is a future revision")
-	ErrCanceled      = errors.New("storage: watcher is canceled")
+	ErrTxnIDMismatch = errors.New("mvcc: txn id mismatch")
+	ErrCompacted     = errors.New("mvcc: required revision has been compacted")
+	ErrFutureRev     = errors.New("mvcc: required revision is a future revision")
+	ErrCanceled      = errors.New("mvcc: watcher is canceled")
 )
 
 // ConsistentIndexGetter is an interface that wraps the Get method.
@@ -75,14 +75,14 @@ type store struct {
 	tx    backend.BatchTx
 	txnID int64 // tracks the current txnID to verify txn operations
 
-	changes   []storagepb.KeyValue
+	changes   []mvccpb.KeyValue
 	fifoSched schedule.Scheduler
 
 	stopc chan struct{}
 }
 
 // NewStore returns a new store. It is useful to create a store inside
-// storage pkg. It should only be used for testing externally.
+// mvcc pkg. It should only be used for testing externally.
 func NewStore(b backend.Backend, le lease.Lessor, ig ConsistentIndexGetter) *store {
 	s := &store{
 		b:       b,
@@ -142,7 +142,7 @@ func (s *store) Put(key, value []byte, lease lease.LeaseID) int64 {
 	return int64(s.currentRev.main)
 }
 
-func (s *store) Range(key, end []byte, limit, rangeRev int64) (kvs []storagepb.KeyValue, rev int64, err error) {
+func (s *store) Range(key, end []byte, limit, rangeRev int64) (kvs []mvccpb.KeyValue, rev int64, err error) {
 	id := s.TxnBegin()
 	kvs, rev, err = s.rangeKeys(key, end, limit, rangeRev)
 	s.txnEnd(id)
@@ -201,7 +201,7 @@ func (s *store) txnEnd(txnID int64) error {
 	return nil
 }
 
-func (s *store) TxnRange(txnID int64, key, end []byte, limit, rangeRev int64) (kvs []storagepb.KeyValue, rev int64, err error) {
+func (s *store) TxnRange(txnID int64, key, end []byte, limit, rangeRev int64) (kvs []mvccpb.KeyValue, rev int64, err error) {
 	if txnID != s.txnID {
 		return nil, 0, ErrTxnIDMismatch
 	}
@@ -330,15 +330,15 @@ func (s *store) restore() error {
 	_, finishedCompactBytes := tx.UnsafeRange(metaBucketName, finishedCompactKeyName, nil, 0)
 	if len(finishedCompactBytes) != 0 {
 		s.compactMainRev = bytesToRev(finishedCompactBytes[0]).main
-		log.Printf("storage: restore compact to %d", s.compactMainRev)
+		log.Printf("mvcc: restore compact to %d", s.compactMainRev)
 	}
 
 	// TODO: limit N to reduce max memory usage
 	keys, vals := tx.UnsafeRange(keyBucketName, min, max, 0)
 	for i, key := range keys {
-		var kv storagepb.KeyValue
+		var kv mvccpb.KeyValue
 		if err := kv.Unmarshal(vals[i]); err != nil {
-			log.Fatalf("storage: cannot unmarshal event: %v", err)
+			log.Fatalf("mvcc: cannot unmarshal event: %v", err)
 		}
 
 		rev := bytesToRev(key[:revBytesLen])
@@ -350,7 +350,7 @@ func (s *store) restore() error {
 			if lease.LeaseID(kv.Lease) != lease.NoLease {
 				err := s.le.Detach(lease.LeaseID(kv.Lease), []lease.LeaseItem{{Key: string(kv.Key)}})
 				if err != nil && err != lease.ErrLeaseNotFound {
-					log.Fatalf("storage: unexpected Detach error %v", err)
+					log.Fatalf("mvcc: unexpected Detach error %v", err)
 				}
 			}
 		default:
@@ -387,7 +387,7 @@ func (s *store) restore() error {
 
 	if scheduledCompact != 0 {
 		s.Compact(scheduledCompact)
-		log.Printf("storage: resume scheduled compaction at %d", scheduledCompact)
+		log.Printf("mvcc: resume scheduled compaction at %d", scheduledCompact)
 	}
 
 	return nil
@@ -410,7 +410,7 @@ func (a *store) Equal(b *store) bool {
 }
 
 // range is a keyword in Go, add Keys suffix.
-func (s *store) rangeKeys(key, end []byte, limit, rangeRev int64) (kvs []storagepb.KeyValue, curRev int64, err error) {
+func (s *store) rangeKeys(key, end []byte, limit, rangeRev int64) (kvs []mvccpb.KeyValue, curRev int64, err error) {
 	curRev = int64(s.currentRev.main)
 	if s.currentRev.sub > 0 {
 		curRev += 1
@@ -439,12 +439,12 @@ func (s *store) rangeKeys(key, end []byte, limit, rangeRev int64) (kvs []storage
 
 		_, vs := s.tx.UnsafeRange(keyBucketName, start, end, 0)
 		if len(vs) != 1 {
-			log.Fatalf("storage: range cannot find rev (%d,%d)", revpair.main, revpair.sub)
+			log.Fatalf("mvcc: range cannot find rev (%d,%d)", revpair.main, revpair.sub)
 		}
 
-		var kv storagepb.KeyValue
+		var kv mvccpb.KeyValue
 		if err := kv.Unmarshal(vs[0]); err != nil {
-			log.Fatalf("storage: cannot unmarshal event: %v", err)
+			log.Fatalf("mvcc: cannot unmarshal event: %v", err)
 		}
 		kvs = append(kvs, kv)
 		if limit > 0 && len(kvs) >= int(limit) {
@@ -467,9 +467,9 @@ func (s *store) put(key, value []byte, leaseID lease.LeaseID) {
 		ibytes := newRevBytes()
 		revToBytes(grev, ibytes)
 		_, vs := s.tx.UnsafeRange(keyBucketName, ibytes, nil, 0)
-		var kv storagepb.KeyValue
+		var kv mvccpb.KeyValue
 		if err = kv.Unmarshal(vs[0]); err != nil {
-			log.Fatalf("storage: cannot unmarshal value: %v", err)
+			log.Fatalf("mvcc: cannot unmarshal value: %v", err)
 		}
 		oldLease = lease.LeaseID(kv.Lease)
 	}
@@ -478,7 +478,7 @@ func (s *store) put(key, value []byte, leaseID lease.LeaseID) {
 	revToBytes(revision{main: rev, sub: s.currentRev.sub}, ibytes)
 
 	ver = ver + 1
-	kv := storagepb.KeyValue{
+	kv := mvccpb.KeyValue{
 		Key:            key,
 		Value:          value,
 		CreateRevision: c,
@@ -489,7 +489,7 @@ func (s *store) put(key, value []byte, leaseID lease.LeaseID) {
 
 	d, err := kv.Marshal()
 	if err != nil {
-		log.Fatalf("storage: cannot marshal event: %v", err)
+		log.Fatalf("mvcc: cannot marshal event: %v", err)
 	}
 
 	s.tx.UnsafeSeqPut(keyBucketName, ibytes, d)
@@ -544,19 +544,19 @@ func (s *store) delete(key []byte, rev revision) {
 	revToBytes(revision{main: mainrev, sub: s.currentRev.sub}, ibytes)
 	ibytes = appendMarkTombstone(ibytes)
 
-	kv := storagepb.KeyValue{
+	kv := mvccpb.KeyValue{
 		Key: key,
 	}
 
 	d, err := kv.Marshal()
 	if err != nil {
-		log.Fatalf("storage: cannot marshal event: %v", err)
+		log.Fatalf("mvcc: cannot marshal event: %v", err)
 	}
 
 	s.tx.UnsafeSeqPut(keyBucketName, ibytes, d)
 	err = s.kvindex.Tombstone(key, revision{main: mainrev, sub: s.currentRev.sub})
 	if err != nil {
-		log.Fatalf("storage: cannot tombstone an existing key (%s): %v", string(key), err)
+		log.Fatalf("mvcc: cannot tombstone an existing key (%s): %v", string(key), err)
 	}
 	s.changes = append(s.changes, kv)
 	s.currentRev.sub += 1
@@ -567,20 +567,20 @@ func (s *store) delete(key []byte, rev revision) {
 
 	kv.Reset()
 	if err = kv.Unmarshal(vs[0]); err != nil {
-		log.Fatalf("storage: cannot unmarshal value: %v", err)
+		log.Fatalf("mvcc: cannot unmarshal value: %v", err)
 	}
 
 	if lease.LeaseID(kv.Lease) != lease.NoLease {
 		err = s.le.Detach(lease.LeaseID(kv.Lease), []lease.LeaseItem{{Key: string(kv.Key)}})
 		if err != nil {
-			log.Fatalf("storage: cannot detach %v", err)
+			log.Fatalf("mvcc: cannot detach %v", err)
 		}
 	}
 }
 
-func (s *store) getChanges() []storagepb.KeyValue {
+func (s *store) getChanges() []mvccpb.KeyValue {
 	changes := s.changes
-	s.changes = make([]storagepb.KeyValue, 0, 128)
+	s.changes = make([]mvccpb.KeyValue, 0, 128)
 	return changes
 }
 

storage/kvstore_bench_test.go → mvcc/kvstore_bench_test.go

@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"log"
 	"testing"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 func BenchmarkStorePut(b *testing.B) {

storage/kvstore_compaction.go → mvcc/kvstore_compaction.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"encoding/binary"

storage/kvstore_compaction_test.go → mvcc/kvstore_compaction_test.go

@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"reflect"
 	"testing"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 func TestScheduleCompaction(t *testing.T) {

storage/kvstore_test.go → mvcc/kvstore_test.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"crypto/rand"
@@ -24,10 +24,10 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease"
+	"github.com/coreos/etcd/mvcc/backend"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/schedule"
 	"github.com/coreos/etcd/pkg/testutil"
-	"github.com/coreos/etcd/storage/backend"
-	"github.com/coreos/etcd/storage/storagepb"
 )
 
 func TestStoreRev(t *testing.T) {
@@ -45,7 +45,7 @@ func TestStoreRev(t *testing.T) {
 }
 
 func TestStorePut(t *testing.T) {
-	kv := storagepb.KeyValue{
+	kv := mvccpb.KeyValue{
 		Key:            []byte("foo"),
 		Value:          []byte("bar"),
 		CreateRevision: 1,
@@ -64,7 +64,7 @@ func TestStorePut(t *testing.T) {
 
 		wrev    revision
 		wkey    []byte
-		wkv     storagepb.KeyValue
+		wkv     mvccpb.KeyValue
 		wputrev revision
 	}{
 		{
@@ -74,7 +74,7 @@ func TestStorePut(t *testing.T) {
 
 			revision{1, 1},
 			newTestKeyBytes(revision{2, 0}, false),
-			storagepb.KeyValue{
+			mvccpb.KeyValue{
 				Key:            []byte("foo"),
 				Value:          []byte("bar"),
 				CreateRevision: 2,
@@ -91,7 +91,7 @@ func TestStorePut(t *testing.T) {
 
 			revision{1, 2},
 			newTestKeyBytes(revision{2, 1}, false),
-			storagepb.KeyValue{
+			mvccpb.KeyValue{
 				Key:            []byte("foo"),
 				Value:          []byte("bar"),
 				CreateRevision: 2,
@@ -108,7 +108,7 @@ func TestStorePut(t *testing.T) {
 
 			revision{2, 1},
 			newTestKeyBytes(revision{3, 0}, false),
-			storagepb.KeyValue{
+			mvccpb.KeyValue{
 				Key:            []byte("foo"),
 				Value:          []byte("bar"),
 				CreateRevision: 2,
@@ -169,7 +169,7 @@ func TestStorePut(t *testing.T) {
 
 func TestStoreRange(t *testing.T) {
 	key := newTestKeyBytes(revision{2, 0}, false)
-	kv := storagepb.KeyValue{
+	kv := mvccpb.KeyValue{
 		Key:            []byte("foo"),
 		Value:          []byte("bar"),
 		CreateRevision: 1,
@@ -210,7 +210,7 @@ func TestStoreRange(t *testing.T) {
 		if err != nil {
 			t.Errorf("#%d: err = %v, want nil", i, err)
 		}
-		if w := []storagepb.KeyValue{kv}; !reflect.DeepEqual(kvs, w) {
+		if w := []mvccpb.KeyValue{kv}; !reflect.DeepEqual(kvs, w) {
 			t.Errorf("#%d: kvs = %+v, want %+v", i, kvs, w)
 		}
 		if rev != wrev {
@@ -240,7 +240,7 @@ func TestStoreRange(t *testing.T) {
 
 func TestStoreDeleteRange(t *testing.T) {
 	key := newTestKeyBytes(revision{2, 0}, false)
-	kv := storagepb.KeyValue{
+	kv := mvccpb.KeyValue{
 		Key:            []byte("foo"),
 		Value:          []byte("bar"),
 		CreateRevision: 1,
@@ -298,7 +298,7 @@ func TestStoreDeleteRange(t *testing.T) {
 			t.Errorf("#%d: n = %d, want 1", i, n)
 		}
 
-		data, err := (&storagepb.KeyValue{
+		data, err := (&mvccpb.KeyValue{
 			Key: []byte("foo"),
 		}).Marshal()
 		if err != nil {
@@ -367,7 +367,7 @@ func TestStoreRestore(t *testing.T) {
 	fi := s.kvindex.(*fakeIndex)
 
 	putkey := newTestKeyBytes(revision{3, 0}, false)
-	putkv := storagepb.KeyValue{
+	putkv := mvccpb.KeyValue{
 		Key:            []byte("foo"),
 		Value:          []byte("bar"),
 		CreateRevision: 4,
@@ -379,7 +379,7 @@ func TestStoreRestore(t *testing.T) {
 		t.Fatal(err)
 	}
 	delkey := newTestKeyBytes(revision{5, 0}, true)
-	delkv := storagepb.KeyValue{
+	delkv := mvccpb.KeyValue{
 		Key: []byte("foo"),
 	}
 	delkvb, err := delkv.Marshal()

storage/metrics.go → mvcc/metrics.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"github.com/prometheus/client_golang/prometheus"
@@ -22,7 +22,7 @@ var (
 	rangeCounter = prometheus.NewCounter(
 		prometheus.CounterOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "range_total",
 			Help:      "Total number of ranges seen by this member.",
 		})
@@ -30,7 +30,7 @@ var (
 	putCounter = prometheus.NewCounter(
 		prometheus.CounterOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "put_total",
 			Help:      "Total number of puts seen by this member.",
 		})
@@ -38,7 +38,7 @@ var (
 	deleteCounter = prometheus.NewCounter(
 		prometheus.CounterOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "delete_total",
 			Help:      "Total number of deletes seen by this member.",
 		})
@@ -46,7 +46,7 @@ var (
 	txnCounter = prometheus.NewCounter(
 		prometheus.CounterOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "txn_total",
 			Help:      "Total number of txns seen by this member.",
 		})
@@ -54,7 +54,7 @@ var (
 	keysGauge = prometheus.NewGauge(
 		prometheus.GaugeOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "keys_total",
 			Help:      "Total number of keys.",
 		})
@@ -62,7 +62,7 @@ var (
 	watchStreamGauge = prometheus.NewGauge(
 		prometheus.GaugeOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "watch_stream_total",
 			Help:      "Total number of watch streams.",
 		})
@@ -70,7 +70,7 @@ var (
 	watcherGauge = prometheus.NewGauge(
 		prometheus.GaugeOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "watcher_total",
 			Help:      "Total number of watchers.",
 		})
@@ -78,7 +78,7 @@ var (
 	slowWatcherGauge = prometheus.NewGauge(
 		prometheus.GaugeOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "slow_watcher_total",
 			Help:      "Total number of unsynced slow watchers.",
 		})
@@ -86,7 +86,7 @@ var (
 	totalEventsCounter = prometheus.NewCounter(
 		prometheus.CounterOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "events_total",
 			Help:      "Total number of events sent by this member.",
 		})
@@ -94,7 +94,7 @@ var (
 	pendingEventsGauge = prometheus.NewGauge(
 		prometheus.GaugeOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "pending_events_total",
 			Help:      "Total number of pending events to be sent.",
 		})
@@ -102,7 +102,7 @@ var (
 	indexCompactionPauseDurations = prometheus.NewHistogram(
 		prometheus.HistogramOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "index_compaction_pause_duration_milliseconds",
 			Help:      "Bucketed histogram of index compaction pause duration.",
 			// 0.5ms -> 1second
@@ -112,7 +112,7 @@ var (
 	dbCompactionPauseDurations = prometheus.NewHistogram(
 		prometheus.HistogramOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "db_compaction_pause_duration_milliseconds",
 			Help:      "Bucketed histogram of db compaction pause duration.",
 			// 1ms -> 4second
@@ -122,7 +122,7 @@ var (
 	dbCompactionTotalDurations = prometheus.NewHistogram(
 		prometheus.HistogramOpts{
 			Namespace: "etcd",
-			Subsystem: "storage",
+			Subsystem: "mvcc",
 			Name:      "db_compaction_total_duration_milliseconds",
 			Help:      "Bucketed histogram of db compaction total duration.",
 			// 100ms -> 800second
@@ -131,7 +131,7 @@ var (
 
 	dbTotalSize = prometheus.NewGauge(prometheus.GaugeOpts{
 		Namespace: "etcd",
-		Subsystem: "storage",
+		Subsystem: "mvcc",
 		Name:      "db_total_size_in_bytes",
 		Help:      "Total size of the underlying database in bytes.",
 	})
@@ -156,7 +156,7 @@ func init() {
 
 // ReportEventReceived reports that an event is received.
 // This function should be called when the external systems received an
-// event from storage.Watcher.
+// event from mvcc.Watcher.
 func ReportEventReceived() {
 	pendingEventsGauge.Dec()
 	totalEventsCounter.Inc()

storage/storagepb/kv.pb.go → mvcc/mvccpb/kv.pb.go

@@ -3,7 +3,7 @@
 // DO NOT EDIT!
 
 /*
-	Package storagepb is a generated protocol buffer package.
+	Package mvccpb is a generated protocol buffer package.
 
 	It is generated from these files:
 		kv.proto
@@ -12,7 +12,7 @@
 		KeyValue
 		Event
 */
-package storagepb
+package mvccpb
 
 import (
 	"fmt"
@@ -61,9 +61,9 @@ type KeyValue struct {
 	// key is the key in bytes. An empty key is not allowed.
 	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
 	// create_revision is the revision of last creation on this key.
-	CreateRevision int64 `protobuf:"varint,2,opt,name=create_revision,json=createRevision,proto3" json:"create_revision,omitempty"`
+	CreateRevision int64 `protobuf:"varint,2,opt,name=create_revision,proto3" json:"create_revision,omitempty"`
 	// mod_revision is the revision of last modification on this key.
-	ModRevision int64 `protobuf:"varint,3,opt,name=mod_revision,json=modRevision,proto3" json:"mod_revision,omitempty"`
+	ModRevision int64 `protobuf:"varint,3,opt,name=mod_revision,proto3" json:"mod_revision,omitempty"`
 	// version is the version of the key. A deletion resets
 	// the version to zero and any modification of the key
 	// increases its version.
@@ -85,7 +85,7 @@ type Event struct {
 	// type is the kind of event. If type is a PUT, it indicates
 	// new data has been stored to the key. If type is a DELETE,
 	// it indicates the key was deleted.
-	Type Event_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=storagepb.Event_EventType" json:"type,omitempty"`
+	Type Event_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=mvccpb.Event_EventType" json:"type,omitempty"`
 	// kv holds the KeyValue for the event.
 	// A PUT event contains current kv pair.
 	// A PUT event with kv.Version=1 indicates the creation of a key.
@@ -100,9 +100,9 @@ func (*Event) ProtoMessage()               {}
 func (*Event) Descriptor() ([]byte, []int) { return fileDescriptorKv, []int{1} }
 
 func init() {
-	proto.RegisterType((*KeyValue)(nil), "storagepb.KeyValue")
-	proto.RegisterType((*Event)(nil), "storagepb.Event")
-	proto.RegisterEnum("storagepb.Event_EventType", Event_EventType_name, Event_EventType_value)
+	proto.RegisterType((*KeyValue)(nil), "mvccpb.KeyValue")
+	proto.RegisterType((*Event)(nil), "mvccpb.Event")
+	proto.RegisterEnum("mvccpb.Event_EventType", Event_EventType_name, Event_EventType_value)
 }
 func (m *KeyValue) Marshal() (data []byte, err error) {
 	size := m.Size()
@@ -662,23 +662,21 @@ var (
 )
 
 var fileDescriptorKv = []byte{
-	// 288 bytes of a gzipped FileDescriptorProto
+	// 255 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0xc8, 0x2e, 0xd3, 0x2b,
-	0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x2c, 0x2e, 0xc9, 0x2f, 0x4a, 0x4c, 0x4f, 0x2d, 0x48, 0x92,
-	0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x8b, 0xea, 0x83, 0x58, 0x10, 0x05, 0x4a, 0xeb, 0x18, 0xb9,
-	0x38, 0xbc, 0x53, 0x2b, 0xc3, 0x12, 0x73, 0x4a, 0x53, 0x85, 0x04, 0xb8, 0x98, 0xb3, 0x53, 0x2b,
-	0x25, 0x18, 0x15, 0x18, 0x35, 0x78, 0x82, 0x40, 0x4c, 0x21, 0x75, 0x2e, 0xfe, 0xe4, 0xa2, 0xd4,
-	0xc4, 0x92, 0xd4, 0xf8, 0xa2, 0xd4, 0xb2, 0xcc, 0xe2, 0xcc, 0xfc, 0x3c, 0x09, 0x26, 0xa0, 0x2c,
-	0x73, 0x10, 0x1f, 0x44, 0x38, 0x08, 0x2a, 0x2a, 0xa4, 0xc8, 0xc5, 0x93, 0x9b, 0x9f, 0x82, 0x50,
-	0xc5, 0x0c, 0x56, 0xc5, 0x0d, 0x14, 0x83, 0x2b, 0x91, 0xe0, 0x62, 0x2f, 0x4b, 0x2d, 0x02, 0xcb,
-	0xb2, 0x80, 0x65, 0x61, 0x5c, 0x21, 0x11, 0x2e, 0xd6, 0x32, 0x90, 0x03, 0x24, 0x58, 0xc1, 0x36,
-	0x43, 0x38, 0x20, 0xd1, 0x9c, 0xd4, 0xc4, 0xe2, 0x54, 0x09, 0x36, 0xb0, 0x6a, 0x08, 0x47, 0xa9,
-	0x8b, 0x91, 0x8b, 0xd5, 0xb5, 0x2c, 0x35, 0xaf, 0x44, 0x48, 0x8f, 0x8b, 0xa5, 0xa4, 0xb2, 0x20,
-	0x15, 0xec, 0x5c, 0x3e, 0x23, 0x29, 0x3d, 0xb8, 0x57, 0xf5, 0xc0, 0xf2, 0x10, 0x32, 0x04, 0xa8,
-	0x22, 0x08, 0xac, 0x4e, 0x48, 0x99, 0x8b, 0x29, 0xbb, 0x0c, 0xec, 0x7c, 0x6e, 0x23, 0x61, 0x24,
-	0xd5, 0x30, 0xef, 0x07, 0x01, 0xa5, 0x95, 0x74, 0xb8, 0x38, 0xe1, 0xfa, 0x84, 0xd8, 0xb9, 0x98,
-	0x03, 0x42, 0x43, 0x04, 0x18, 0x84, 0xb8, 0xb8, 0xd8, 0x5c, 0x5c, 0x7d, 0x5c, 0x43, 0x5c, 0x05,
-	0x18, 0x41, 0x6c, 0xd7, 0x88, 0x00, 0xcf, 0x20, 0x57, 0x01, 0x26, 0x27, 0x91, 0x13, 0x0f, 0xe5,
-	0x18, 0x2e, 0x00, 0xf1, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x80, 0xf8, 0x01, 0x10, 0x27, 0xb1, 0x81,
-	0x83, 0xd6, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x15, 0x18, 0xeb, 0x9b, 0x87, 0x01, 0x00, 0x00,
+	0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0xcb, 0x2d, 0x4b, 0x4e, 0x2e, 0x48, 0x92, 0x12, 0x49, 0xcf,
+	0x4f, 0xcf, 0x07, 0x0b, 0xe9, 0x83, 0x58, 0x10, 0x59, 0xa5, 0x52, 0x2e, 0x0e, 0xef, 0xd4, 0xca,
+	0xb0, 0xc4, 0x9c, 0xd2, 0x54, 0x21, 0x6e, 0x2e, 0xe6, 0xec, 0xd4, 0x4a, 0x09, 0x46, 0x05, 0x46,
+	0x0d, 0x1e, 0x21, 0x71, 0x2e, 0xfe, 0xe4, 0xa2, 0xd4, 0xc4, 0x92, 0xd4, 0xf8, 0xa2, 0xd4, 0xb2,
+	0xcc, 0xe2, 0xcc, 0xfc, 0x3c, 0x09, 0x26, 0xa0, 0x04, 0xb3, 0x90, 0x08, 0x17, 0x4f, 0x6e, 0x7e,
+	0x0a, 0x42, 0x94, 0x19, 0x2c, 0xca, 0xcf, 0xc5, 0x5e, 0x96, 0x5a, 0x04, 0x16, 0x60, 0x01, 0x0b,
+	0xf0, 0x72, 0xb1, 0x96, 0x81, 0x4c, 0x95, 0x60, 0x05, 0x1b, 0x07, 0xe4, 0xe6, 0xa4, 0x26, 0x16,
+	0xa7, 0x4a, 0xb0, 0x81, 0x64, 0x95, 0xaa, 0xb8, 0x58, 0x5d, 0xcb, 0x52, 0xf3, 0x4a, 0x84, 0x54,
+	0xb9, 0x58, 0x4a, 0x2a, 0x0b, 0x52, 0xc1, 0x96, 0xf2, 0x19, 0x89, 0xeb, 0x41, 0x1c, 0xab, 0x07,
+	0x96, 0x84, 0x90, 0x21, 0x40, 0x69, 0x21, 0x19, 0x2e, 0xa6, 0xec, 0x32, 0xb0, 0x03, 0xb8, 0x8d,
+	0x04, 0x60, 0x8a, 0x60, 0x0e, 0x57, 0xd2, 0xe1, 0xe2, 0x44, 0x28, 0x65, 0xe7, 0x62, 0x0e, 0x08,
+	0x0d, 0x11, 0x60, 0x10, 0xe2, 0xe2, 0x62, 0x73, 0x71, 0xf5, 0x71, 0x0d, 0x71, 0x15, 0x60, 0x04,
+	0xb1, 0x5d, 0x23, 0x02, 0x3c, 0x83, 0x5c, 0x05, 0x98, 0x9c, 0x44, 0x4e, 0x3c, 0x94, 0x63, 0xb8,
+	0x00, 0xc4, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x00, 0xe2, 0x07, 0x40, 0x9c, 0xc4, 0x06, 0x0e, 0x0f,
+	0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4a, 0x2d, 0xc3, 0x10, 0x39, 0x01, 0x00, 0x00,
 }

storage/storagepb/kv.proto → mvcc/mvccpb/kv.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package storagepb;
+package mvccpb;
 
 import "gogoproto/gogo.proto";
 

storage/revision.go → mvcc/revision.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import "encoding/binary"
 

storage/revision_test.go → mvcc/revision_test.go

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

storage/watchable_store.go → mvcc/watchable_store.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"log"
@@ -20,8 +20,8 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/backend"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
 const (
@@ -88,11 +88,11 @@ func (s *watchableStore) Put(key, value []byte, lease lease.LeaseID) (rev int64)
 		log.Panicf("unexpected len(changes) != 1 after put")
 	}
 
-	ev := storagepb.Event{
-		Type: storagepb.PUT,
+	ev := mvccpb.Event{
+		Type: mvccpb.PUT,
 		Kv:   &changes[0],
 	}
-	s.notify(rev, []storagepb.Event{ev})
+	s.notify(rev, []mvccpb.Event{ev})
 	return rev
 }
 
@@ -111,10 +111,10 @@ func (s *watchableStore) DeleteRange(key, end []byte) (n, rev int64) {
 		return n, rev
 	}
 
-	evs := make([]storagepb.Event, n)
+	evs := make([]mvccpb.Event, n)
 	for i, change := range changes {
-		evs[i] = storagepb.Event{
-			Type: storagepb.DELETE,
+		evs[i] = mvccpb.Event{
+			Type: mvccpb.DELETE,
 			Kv:   &change}
 		evs[i].Kv.ModRevision = rev
 	}
@@ -140,17 +140,17 @@ func (s *watchableStore) TxnEnd(txnID int64) error {
 	}
 
 	rev := s.store.Rev()
-	evs := make([]storagepb.Event, len(changes))
+	evs := make([]mvccpb.Event, len(changes))
 	for i, change := range changes {
 		switch change.CreateRevision {
 		case 0:
-			evs[i] = storagepb.Event{
-				Type: storagepb.DELETE,
+			evs[i] = mvccpb.Event{
+				Type: mvccpb.DELETE,
 				Kv:   &changes[i]}
 			evs[i].Kv.ModRevision = rev
 		default:
-			evs[i] = storagepb.Event{
-				Type: storagepb.PUT,
+			evs[i] = mvccpb.Event{
+				Type: mvccpb.PUT,
 				Kv:   &changes[i]}
 		}
 	}
@@ -308,34 +308,34 @@ func (s *watchableStore) syncWatchers() {
 }
 
 // kvsToEvents gets all events for the watchers from all key-value pairs
-func kvsToEvents(wg *watcherGroup, revs, vals [][]byte) (evs []storagepb.Event) {
+func kvsToEvents(wg *watcherGroup, revs, vals [][]byte) (evs []mvccpb.Event) {
 	for i, v := range vals {
-		var kv storagepb.KeyValue
+		var kv mvccpb.KeyValue
 		if err := kv.Unmarshal(v); err != nil {
-			log.Panicf("storage: cannot unmarshal event: %v", err)
+			log.Panicf("mvcc: cannot unmarshal event: %v", err)
 		}
 
 		if !wg.contains(string(kv.Key)) {
 			continue
 		}
 
-		ty := storagepb.PUT
+		ty := mvccpb.PUT
 		if isTombstone(revs[i]) {
-			ty = storagepb.DELETE
+			ty = mvccpb.DELETE
 			// patch in mod revision so watchers won't skip
 			kv.ModRevision = bytesToRev(revs[i]).main
 		}
-		evs = append(evs, storagepb.Event{Kv: &kv, Type: ty})
+		evs = append(evs, mvccpb.Event{Kv: &kv, Type: ty})
 	}
 	return evs
 }
 
 // notify notifies the fact that given event at the given rev just happened to
 // watchers that watch on the key of the event.
-func (s *watchableStore) notify(rev int64, evs []storagepb.Event) {
+func (s *watchableStore) notify(rev int64, evs []mvccpb.Event) {
 	for w, eb := range newWatcherBatch(&s.synced, evs) {
 		if eb.revs != 1 {
-			panic("unexpected multiple revisions in notification")
+			log.Panicf("mvcc: unexpected multiple revisions in notification")
 		}
 		select {
 		case w.ch <- WatchResponse{WatchID: w.id, Events: eb.evs, Revision: s.Rev()}:

storage/watchable_store_bench_test.go → mvcc/watchable_store_bench_test.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"math/rand"
@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 // Benchmarks on cancel function performance for unsynced watchers

storage/watchable_store_test.go → mvcc/watchable_store_test.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"bytes"
@@ -22,8 +22,8 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/backend"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
 func TestWatch(t *testing.T) {
@@ -206,8 +206,8 @@ func TestSyncWatchers(t *testing.T) {
 	if len(evs) != 1 {
 		t.Errorf("len(evs) got = %d, want = 1", len(evs))
 	}
-	if evs[0].Type != storagepb.PUT {
-		t.Errorf("got = %v, want = %v", evs[0].Type, storagepb.PUT)
+	if evs[0].Type != mvccpb.PUT {
+		t.Errorf("got = %v, want = %v", evs[0].Type, mvccpb.PUT)
 	}
 	if !bytes.Equal(evs[0].Kv.Key, testKey) {
 		t.Errorf("got = %s, want = %s", evs[0].Kv.Key, testKey)
@@ -334,32 +334,32 @@ func TestNewMapwatcherToEventMap(t *testing.T) {
 
 	ws := []*watcher{{key: k0}, {key: k1}, {key: k2}}
 
-	evs := []storagepb.Event{
+	evs := []mvccpb.Event{
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: k0, Value: v0},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: k0, Value: v0},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: k1, Value: v1},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: k1, Value: v1},
 		},
 		{
-			Type: storagepb.PUT,
-			Kv:   &storagepb.KeyValue{Key: k2, Value: v2},
+			Type: mvccpb.PUT,
+			Kv:   &mvccpb.KeyValue{Key: k2, Value: v2},
 		},
 	}
 
 	tests := []struct {
 		sync []*watcher
-		evs  []storagepb.Event
+		evs  []mvccpb.Event
 
-		wwe map[*watcher][]storagepb.Event
+		wwe map[*watcher][]mvccpb.Event
 	}{
 		// no watcher in sync, some events should return empty wwe
 		{
 			nil,
 			evs,
-			map[*watcher][]storagepb.Event{},
+			map[*watcher][]mvccpb.Event{},
 		},
 
 		// one watcher in sync, one event that does not match the key of that
@@ -367,7 +367,7 @@ func TestNewMapwatcherToEventMap(t *testing.T) {
 		{
 			[]*watcher{ws[2]},
 			evs[:1],
-			map[*watcher][]storagepb.Event{},
+			map[*watcher][]mvccpb.Event{},
 		},
 
 		// one watcher in sync, one event that matches the key of that
@@ -375,7 +375,7 @@ func TestNewMapwatcherToEventMap(t *testing.T) {
 		{
 			[]*watcher{ws[1]},
 			evs[1:2],
-			map[*watcher][]storagepb.Event{
+			map[*watcher][]mvccpb.Event{
 				ws[1]: evs[1:2],
 			},
 		},
@@ -386,7 +386,7 @@ func TestNewMapwatcherToEventMap(t *testing.T) {
 		{
 			[]*watcher{ws[0], ws[2]},
 			evs[2:],
-			map[*watcher][]storagepb.Event{
+			map[*watcher][]mvccpb.Event{
 				ws[2]: evs[2:],
 			},
 		},
@@ -396,7 +396,7 @@ func TestNewMapwatcherToEventMap(t *testing.T) {
 		{
 			[]*watcher{ws[0], ws[1]},
 			evs[:2],
-			map[*watcher][]storagepb.Event{
+			map[*watcher][]mvccpb.Event{
 				ws[0]: evs[:1],
 				ws[1]: evs[1:2],
 			},

storage/watcher.go → mvcc/watcher.go

@@ -12,17 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"errors"
 	"sync"
 
-	"github.com/coreos/etcd/storage/storagepb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
 var (
-	ErrWatcherNotExist = errors.New("storage: watcher does not exist")
+	ErrWatcherNotExist = errors.New("mvcc: watcher does not exist")
 )
 
 type WatchID int64
@@ -66,7 +66,7 @@ type WatchResponse struct {
 	WatchID WatchID
 
 	// Events contains all the events that needs to send.
-	Events []storagepb.Event
+	Events []mvccpb.Event
 
 	// Revision is the revision of the KV when the watchResponse is created.
 	// For a normal response, the revision should be the same as the last

storage/watcher_bench_test.go → mvcc/watcher_bench_test.go

@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"fmt"
 	"testing"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 func BenchmarkKVWatcherMemoryUsage(b *testing.B) {

storage/watcher_group.go → mvcc/watcher_group.go

@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"math"
 
+	"github.com/coreos/etcd/mvcc/mvccpb"
 	"github.com/coreos/etcd/pkg/adt"
-	"github.com/coreos/etcd/storage/storagepb"
 )
 
 var (
@@ -30,14 +30,14 @@ var (
 
 type eventBatch struct {
 	// evs is a batch of revision-ordered events
-	evs []storagepb.Event
+	evs []mvccpb.Event
 	// revs is the minimum unique revisions observed for this batch
 	revs int
 	// moreRev is first revision with more events following this batch
 	moreRev int64
 }
 
-func (eb *eventBatch) add(ev storagepb.Event) {
+func (eb *eventBatch) add(ev mvccpb.Event) {
 	if eb.revs > watchBatchMaxRevs {
 		// maxed out batch size
 		return
@@ -66,7 +66,7 @@ func (eb *eventBatch) add(ev storagepb.Event) {
 
 type watcherBatch map[*watcher]*eventBatch
 
-func (wb watcherBatch) add(w *watcher, ev storagepb.Event) {
+func (wb watcherBatch) add(w *watcher, ev mvccpb.Event) {
 	eb := wb[w]
 	if eb == nil {
 		eb = &eventBatch{}
@@ -82,7 +82,7 @@ func (wb watcherBatch) contains(w *watcher) bool {
 
 // newWatcherBatch maps watchers to their matched events. It enables quick
 // events look up by watcher.
-func newWatcherBatch(wg *watcherGroup, evs []storagepb.Event) watcherBatch {
+func newWatcherBatch(wg *watcherGroup, evs []mvccpb.Event) watcherBatch {
 	wb := make(watcherBatch)
 	for _, ev := range evs {
 		for w := range wg.watcherSetByKey(string(ev.Kv.Key)) {

storage/watcher_test.go → mvcc/watcher_test.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package storage
+package mvcc
 
 import (
 	"bytes"
@@ -22,7 +22,7 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc/backend"
 )
 
 // TestWatcherWatchID tests that each watcher provides unique watchID,

raft/raftpb/raft.pb.go

@@ -183,10 +183,10 @@ func (x *ConfChangeType) UnmarshalJSON(data []byte) error {
 func (ConfChangeType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaft, []int{2} }
 
 type Entry struct {
-	Type             EntryType `protobuf:"varint,1,opt,name=Type,json=type,enum=raftpb.EntryType" json:"Type"`
-	Term             uint64    `protobuf:"varint,2,opt,name=Term,json=term" json:"Term"`
-	Index            uint64    `protobuf:"varint,3,opt,name=Index,json=index" json:"Index"`
-	Data             []byte    `protobuf:"bytes,4,opt,name=Data,json=data" json:"Data,omitempty"`
+	Type             EntryType `protobuf:"varint,1,opt,name=Type,enum=raftpb.EntryType" json:"Type"`
+	Term             uint64    `protobuf:"varint,2,opt,name=Term" json:"Term"`
+	Index            uint64    `protobuf:"varint,3,opt,name=Index" json:"Index"`
+	Data             []byte    `protobuf:"bytes,4,opt,name=Data" json:"Data,omitempty"`
 	XXX_unrecognized []byte    `json:"-"`
 }
 
@@ -196,7 +196,7 @@ func (*Entry) ProtoMessage()               {}
 func (*Entry) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{0} }
 
 type SnapshotMetadata struct {
-	ConfState        ConfState `protobuf:"bytes,1,opt,name=conf_state,json=confState" json:"conf_state"`
+	ConfState        ConfState `protobuf:"bytes,1,opt,name=conf_state" json:"conf_state"`
 	Index            uint64    `protobuf:"varint,2,opt,name=index" json:"index"`
 	Term             uint64    `protobuf:"varint,3,opt,name=term" json:"term"`
 	XXX_unrecognized []byte    `json:"-"`
@@ -261,10 +261,10 @@ func (*ConfState) ProtoMessage()               {}
 func (*ConfState) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{5} }
 
 type ConfChange struct {
-	ID               uint64         `protobuf:"varint,1,opt,name=ID,json=iD" json:"ID"`
-	Type             ConfChangeType `protobuf:"varint,2,opt,name=Type,json=type,enum=raftpb.ConfChangeType" json:"Type"`
-	NodeID           uint64         `protobuf:"varint,3,opt,name=NodeID,json=nodeID" json:"NodeID"`
-	Context          []byte         `protobuf:"bytes,4,opt,name=Context,json=context" json:"Context,omitempty"`
+	ID               uint64         `protobuf:"varint,1,opt,name=ID" json:"ID"`
+	Type             ConfChangeType `protobuf:"varint,2,opt,name=Type,enum=raftpb.ConfChangeType" json:"Type"`
+	NodeID           uint64         `protobuf:"varint,3,opt,name=NodeID" json:"NodeID"`
+	Context          []byte         `protobuf:"bytes,4,opt,name=Context" json:"Context,omitempty"`
 	XXX_unrecognized []byte         `json:"-"`
 }
 
@@ -1788,51 +1788,47 @@ var (
 )
 
 var fileDescriptorRaft = []byte{
-	// 735 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x54, 0x4d, 0x6f, 0xd3, 0x4a,
-	0x14, 0xad, 0x13, 0xe7, 0xeb, 0xa6, 0x4d, 0xa7, 0xd3, 0xbc, 0x27, 0xab, 0x7a, 0xea, 0xeb, 0xb3,
-	0xde, 0x02, 0x15, 0xb5, 0x40, 0x17, 0x2c, 0xd8, 0xf5, 0x03, 0xa9, 0x95, 0x68, 0x05, 0x69, 0xcb,
-	0x02, 0x84, 0xd0, 0xd4, 0x9e, 0x38, 0x81, 0xda, 0x63, 0x8d, 0x27, 0xa5, 0xdd, 0x20, 0x24, 0x16,
-	0x6c, 0xf8, 0x61, 0x5d, 0xf6, 0x17, 0x20, 0xe0, 0x97, 0x70, 0x67, 0x3c, 0x4e, 0xec, 0x66, 0x11,
-	0x69, 0xe6, 0x9c, 0xfb, 0x71, 0xee, 0x99, 0xeb, 0x00, 0x48, 0x36, 0x54, 0xdb, 0xa9, 0x14, 0x4a,
-	0xd0, 0xa6, 0x3e, 0xa7, 0x17, 0x6b, 0xfd, 0x48, 0x44, 0xc2, 0x40, 0x8f, 0xf4, 0x29, 0x67, 0xfd,
-	0xcf, 0xd0, 0x78, 0x9e, 0x28, 0x79, 0x43, 0x1f, 0x82, 0x7b, 0x76, 0x93, 0x72, 0xcf, 0xd9, 0x70,
-	0x1e, 0xf4, 0x76, 0x56, 0xb6, 0xf3, 0xac, 0x6d, 0x43, 0x6a, 0x62, 0xcf, 0xbd, 0xfd, 0xf1, 0xef,
-	0xc2, 0xc0, 0x55, 0x78, 0xa6, 0x1e, 0x06, 0x73, 0x19, 0x7b, 0x35, 0x0c, 0x76, 0xa7, 0x0c, 0x22,
-	0x74, 0x0d, 0x1a, 0x47, 0x49, 0xc8, 0xaf, 0xbd, 0x7a, 0x89, 0x6a, 0x8c, 0x35, 0x44, 0x29, 0xb8,
-	0x07, 0x4c, 0x31, 0xcf, 0x45, 0x6a, 0x71, 0xe0, 0x86, 0x78, 0xf6, 0xbf, 0x38, 0x40, 0x4e, 0x13,
-	0x96, 0x66, 0x23, 0xa1, 0x8e, 0xb9, 0x62, 0x1a, 0xa4, 0x4f, 0x01, 0x02, 0x91, 0x0c, 0xdf, 0x67,
-	0x8a, 0xa9, 0x5c, 0x51, 0x77, 0xa6, 0x68, 0x1f, 0x99, 0x53, 0x4d, 0xd8, 0xe2, 0x9d, 0xa0, 0x00,
-	0x74, 0x73, 0xd3, 0xa9, 0xa2, 0xcb, 0x36, 0x47, 0xc9, 0x5a, 0x60, 0x45, 0x97, 0x41, 0xfc, 0x37,
-	0xd0, 0x2e, 0x14, 0x68, 0x89, 0x5a, 0x81, 0xe9, 0x69, 0x25, 0xd2, 0x67, 0xd0, 0x8e, 0xad, 0x32,
-	0x53, 0xb8, 0xbb, 0xe3, 0x15, 0x5a, 0xee, 0x2b, 0xb7, 0x75, 0xa7, 0xf1, 0xfe, 0xd7, 0x3a, 0xb4,
-	0x8e, 0x79, 0x96, 0xb1, 0x88, 0xd3, 0x2d, 0x30, 0xe6, 0x59, 0x87, 0x57, 0x8b, 0x1a, 0x96, 0x9e,
-	0xf3, 0xb8, 0x0f, 0x35, 0x25, 0x2a, 0x93, 0xe0, 0x5d, 0x8f, 0x31, 0x94, 0xe2, 0xde, 0x18, 0x1a,
-	0x99, 0x0e, 0xe8, 0xce, 0xbd, 0xc9, 0x3a, 0xb4, 0x2e, 0x45, 0x64, 0x1e, 0xac, 0x51, 0x22, 0x0b,
-	0x70, 0x66, 0x5b, 0x73, 0xde, 0xb6, 0x2d, 0x68, 0x71, 0x5c, 0x81, 0x31, 0xcf, 0xbc, 0xd6, 0x46,
-	0x1d, 0x67, 0x5f, 0xaa, 0x6c, 0x46, 0x51, 0xca, 0xc6, 0xd0, 0x7f, 0xa0, 0x19, 0x88, 0x38, 0x1e,
-	0x2b, 0xaf, 0x5d, 0xaa, 0x65, 0x31, 0xba, 0x03, 0xed, 0xcc, 0x3a, 0xe6, 0x75, 0x8c, 0x93, 0xe4,
-	0xbe, 0x93, 0x85, 0x83, 0x45, 0x9c, 0xae, 0x28, 0xf9, 0x07, 0x1e, 0x28, 0x0f, 0x30, 0xa3, 0x5d,
-	0x54, 0xcc, 0x31, 0xfa, 0x3f, 0xae, 0xba, 0x39, 0x1d, 0x8e, 0x13, 0xe5, 0x75, 0x4b, 0x3d, 0x4b,
-	0xb8, 0xff, 0x0e, 0x3a, 0x87, 0x4c, 0x86, 0xf9, 0x92, 0x14, 0x3e, 0x39, 0x73, 0x3e, 0x21, 0x73,
-	0x25, 0x70, 0xe1, 0x2a, 0x5b, 0xad, 0x91, 0xd2, 0x58, 0xf5, 0xf9, 0xb1, 0xfc, 0xff, 0xa0, 0x33,
-	0x5d, 0x4a, 0x7c, 0xb6, 0x46, 0x22, 0x42, 0xb4, 0xcb, 0x41, 0xbb, 0xdc, 0x41, 0x7e, 0xf1, 0xbf,
-	0x3b, 0x00, 0x3a, 0x66, 0x7f, 0xc4, 0x92, 0xc8, 0xbc, 0xed, 0xd1, 0x41, 0x45, 0x41, 0x6d, 0x7c,
-	0x40, 0x1f, 0xdb, 0x4f, 0xb0, 0x66, 0x16, 0xe4, 0xef, 0xf2, 0xc2, 0xe7, 0x79, 0x73, 0x3b, 0x82,
-	0xba, 0x4e, 0xb0, 0x3e, 0xd6, 0xaa, 0xe8, 0x4a, 0x0c, 0x86, 0xf3, 0xb4, 0x30, 0x57, 0xf1, 0x6b,
-	0x65, 0x3f, 0xb9, 0x56, 0x90, 0x5f, 0x37, 0x9f, 0x40, 0x67, 0xfa, 0x61, 0xd3, 0x65, 0xe8, 0x9a,
-	0xcb, 0x89, 0x90, 0x31, 0xbb, 0x24, 0x0b, 0x74, 0x15, 0x96, 0x0d, 0x30, 0x6b, 0x4c, 0x9c, 0xcd,
-	0x6f, 0x35, 0xe8, 0x96, 0x56, 0x95, 0x02, 0x34, 0x8f, 0xb3, 0xe8, 0x70, 0x92, 0x62, 0x42, 0x17,
-	0x97, 0x3c, 0x8b, 0xf6, 0x38, 0x53, 0xc4, 0xb1, 0x97, 0x97, 0x52, 0xa4, 0xa4, 0x66, 0xa3, 0x76,
-	0xd3, 0x94, 0xd4, 0x69, 0x0f, 0x20, 0x3f, 0x0f, 0x78, 0x96, 0x12, 0xd7, 0x06, 0xbe, 0x46, 0x7f,
-	0x49, 0x43, 0x8b, 0xb0, 0x17, 0xc3, 0x36, 0x2d, 0xab, 0xd7, 0x82, 0xb4, 0x28, 0x81, 0x45, 0xdd,
-	0x8c, 0x33, 0xa9, 0x2e, 0x74, 0x97, 0x36, 0x3a, 0x48, 0xca, 0x88, 0x49, 0xea, 0xe0, 0xe7, 0xdb,
-	0x43, 0xf4, 0x3c, 0x91, 0x9c, 0x05, 0x23, 0x76, 0x71, 0xc9, 0x09, 0xd0, 0x15, 0x58, 0xb2, 0x85,
-	0xf4, 0x03, 0x4d, 0x32, 0xd2, 0xb5, 0x61, 0xfb, 0x23, 0x1e, 0x7c, 0x7c, 0x35, 0x11, 0x72, 0x12,
-	0x93, 0x45, 0xfa, 0x17, 0xac, 0x20, 0x76, 0x26, 0x59, 0x92, 0x0d, 0xb9, 0x7c, 0xc1, 0x59, 0xc8,
-	0x25, 0x59, 0xb2, 0xd9, 0x67, 0xe3, 0x98, 0x8b, 0x89, 0x3a, 0x11, 0x9f, 0x48, 0x6f, 0xf3, 0x2d,
-	0xf4, 0xaa, 0x4f, 0xa2, 0x73, 0x67, 0xc8, 0x6e, 0x18, 0xea, 0x37, 0x41, 0x5b, 0x3c, 0xe8, 0xcf,
-	0xe0, 0x01, 0x8f, 0xc5, 0x15, 0x37, 0x8c, 0x53, 0x65, 0xce, 0x53, 0xfc, 0xab, 0xc8, 0x99, 0xda,
-	0x5e, 0xff, 0xf6, 0xd7, 0xfa, 0xc2, 0x1d, 0xfe, 0x6e, 0x7f, 0xaf, 0x3b, 0x77, 0xf8, 0xfb, 0x89,
-	0xbf, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x26, 0x45, 0x2d, 0xd0, 0x05, 0x00, 0x00,
+	// 657 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x53, 0xdd, 0x6e, 0xd3, 0x4c,
+	0x10, 0xad, 0x5d, 0x27, 0x76, 0xc6, 0x49, 0xba, 0x75, 0xf3, 0x7d, 0xb2, 0x7a, 0x51, 0xaa, 0x08,
+	0x44, 0x15, 0xa4, 0x02, 0x7d, 0x83, 0xfe, 0x20, 0xb5, 0x88, 0x56, 0xd0, 0x1f, 0x6e, 0xb8, 0x40,
+	0xdb, 0x78, 0xe3, 0x04, 0x6a, 0xaf, 0x59, 0x6f, 0x4a, 0xfb, 0x04, 0xbc, 0x0d, 0xcf, 0xd1, 0xcb,
+	0x3e, 0x01, 0x02, 0x9e, 0x84, 0xd9, 0xf5, 0x36, 0x5e, 0xf7, 0xc2, 0x92, 0x7d, 0xce, 0xcc, 0x9c,
+	0x99, 0x39, 0x63, 0x00, 0x41, 0x27, 0x72, 0xbb, 0x10, 0x5c, 0xf2, 0xa8, 0xad, 0xde, 0x8b, 0xcb,
+	0xf5, 0x41, 0xca, 0x53, 0xae, 0xa1, 0x97, 0xea, 0xad, 0x62, 0x87, 0x0c, 0x5a, 0x6f, 0x72, 0x29,
+	0x6e, 0xa3, 0x67, 0xe0, 0x9d, 0xdf, 0x16, 0x2c, 0x76, 0x36, 0x9d, 0xad, 0xfe, 0xce, 0xea, 0x76,
+	0x95, 0xb5, 0xad, 0x49, 0x45, 0xec, 0x79, 0x77, 0xbf, 0x9e, 0x2c, 0x45, 0x11, 0x86, 0x31, 0x91,
+	0xc5, 0x2e, 0x86, 0x79, 0x06, 0x5b, 0x83, 0xd6, 0x51, 0x9e, 0xb0, 0x9b, 0x78, 0xd9, 0x02, 0xbb,
+	0xe0, 0x1d, 0x50, 0x49, 0x63, 0x0f, 0xb1, 0xee, 0x70, 0x0a, 0xe4, 0x2c, 0xa7, 0x45, 0x39, 0xe5,
+	0xf2, 0x98, 0x49, 0x9a, 0x20, 0x13, 0xbd, 0x00, 0x18, 0xf3, 0x7c, 0xf2, 0xb9, 0x94, 0x54, 0x56,
+	0xba, 0x61, 0xad, 0xbb, 0x8f, 0xcc, 0x99, 0x22, 0x6a, 0x8d, 0x99, 0xd6, 0xb0, 0x85, 0xb1, 0x19,
+	0xa9, 0x9a, 0xb1, 0x74, 0x87, 0x6f, 0x21, 0x78, 0x50, 0x52, 0x3d, 0x28, 0x25, 0x5d, 0xbb, 0x1b,
+	0xbd, 0x82, 0x20, 0x33, 0xda, 0xba, 0x4a, 0xb8, 0x13, 0x3f, 0xa8, 0x3d, 0xee, 0xcd, 0xd4, 0xfa,
+	0xe9, 0x82, 0x7f, 0xcc, 0xca, 0x92, 0xa6, 0x2c, 0x7a, 0x8e, 0x5a, 0xf5, 0x7e, 0xd6, 0x1e, 0x32,
+	0x0d, 0x6d, 0x6d, 0x88, 0x80, 0x2b, 0xf9, 0xe3, 0x36, 0x27, 0x82, 0x37, 0xda, 0x5c, 0xb4, 0xee,
+	0x59, 0xd8, 0x7f, 0xe0, 0x5f, 0xf1, 0x54, 0xaf, 0xb7, 0xd5, 0x5c, 0x6f, 0x35, 0x7a, 0xdb, 0x02,
+	0x9f, 0x82, 0xcf, 0xd0, 0x9a, 0x19, 0x2b, 0x63, 0x7f, 0x73, 0x19, 0x67, 0xe9, 0x35, 0x1c, 0x33,
+	0x51, 0x03, 0x68, 0x8f, 0x79, 0x96, 0xcd, 0x64, 0x1c, 0x58, 0xb9, 0x5b, 0x10, 0x94, 0x66, 0xe0,
+	0xb8, 0xa3, 0x17, 0x41, 0x1e, 0x2f, 0xa2, 0xce, 0x17, 0xec, 0x0b, 0x1b, 0xcb, 0x18, 0x30, 0x2e,
+	0x30, 0x68, 0x8c, 0xf7, 0xa5, 0xd1, 0xc3, 0x59, 0x2e, 0xe3, 0xd0, 0x5a, 0xfe, 0x11, 0x74, 0x0e,
+	0xa9, 0x48, 0xb4, 0x71, 0x8b, 0x11, 0x9d, 0xe6, 0xd8, 0xd7, 0x1c, 0xdd, 0xb6, 0xd7, 0x53, 0x37,
+	0x69, 0xfb, 0xb8, 0x0e, 0x9d, 0xc5, 0x0d, 0x44, 0x3d, 0x68, 0xe5, 0x3c, 0xc1, 0x59, 0x1d, 0x9c,
+	0xd5, 0x1b, 0x7e, 0x03, 0x50, 0xdc, 0xfe, 0x94, 0xe6, 0xe8, 0x0c, 0x2e, 0xfc, 0xe8, 0xa0, 0xa1,
+	0x32, 0x32, 0xb7, 0xec, 0x6a, 0xaf, 0xfe, 0xb7, 0x6f, 0xaa, 0xca, 0xb1, 0xec, 0x42, 0xf5, 0x13,
+	0x2c, 0x8d, 0x15, 0x6c, 0x7b, 0x56, 0xc0, 0xc7, 0x68, 0xc9, 0x6e, 0x64, 0x75, 0xc0, 0xa3, 0xd7,
+	0xd0, 0x59, 0xfc, 0x0a, 0xc8, 0x86, 0xfa, 0xe3, 0x84, 0x8b, 0x8c, 0x5e, 0x11, 0x65, 0xd1, 0x8a,
+	0x06, 0x6a, 0x05, 0xe2, 0x8c, 0x7e, 0xb8, 0x10, 0x5a, 0xe7, 0x11, 0x01, 0xb4, 0x8f, 0xcb, 0xf4,
+	0x70, 0x5e, 0x60, 0x42, 0x88, 0x87, 0x55, 0xa6, 0x7b, 0x8c, 0x4a, 0xe2, 0x98, 0x8f, 0xf7, 0x82,
+	0x17, 0xc4, 0x35, 0x51, 0xbb, 0x45, 0x41, 0x96, 0xa3, 0x3e, 0x40, 0xf5, 0x7e, 0xca, 0xca, 0x82,
+	0x78, 0x26, 0xf0, 0x23, 0x2e, 0x90, 0xb4, 0x54, 0x13, 0xe6, 0x43, 0xb3, 0x6d, 0xc3, 0x2a, 0x07,
+	0x89, 0x8f, 0x4b, 0xe9, 0x2a, 0x31, 0x46, 0x85, 0xbc, 0x54, 0x2a, 0x01, 0x0e, 0x4a, 0x6c, 0x44,
+	0x27, 0x75, 0xd0, 0x90, 0x3e, 0xa2, 0x17, 0xb9, 0x60, 0x74, 0x3c, 0xa5, 0x97, 0x57, 0x8c, 0x40,
+	0xb4, 0x0a, 0x3d, 0x53, 0x48, 0x6d, 0x7f, 0x5e, 0x92, 0xd0, 0x84, 0xed, 0x4f, 0xd9, 0xf8, 0xeb,
+	0x87, 0x39, 0x17, 0xf3, 0x8c, 0x74, 0xf1, 0x5c, 0x57, 0x11, 0x3b, 0x17, 0x34, 0x2f, 0x27, 0x4c,
+	0xbc, 0x63, 0x34, 0x61, 0x82, 0xf4, 0x4c, 0xf6, 0xf9, 0x2c, 0x63, 0x7c, 0x2e, 0x4f, 0xf8, 0x77,
+	0xd2, 0x1f, 0x7d, 0x82, 0x7e, 0x73, 0xf7, 0x2a, 0xb7, 0x46, 0x76, 0x93, 0x44, 0x59, 0x40, 0xd4,
+	0x65, 0x0d, 0x6a, 0xf8, 0x94, 0x65, 0xfc, 0x9a, 0x69, 0xc6, 0x69, 0x32, 0x17, 0x05, 0xfe, 0xa4,
+	0x15, 0xe3, 0xee, 0x0d, 0xee, 0xfe, 0x6c, 0x2c, 0xdd, 0xe3, 0x73, 0xf7, 0x77, 0xc3, 0xb9, 0xc7,
+	0xe7, 0x37, 0x3e, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x3d, 0x27, 0xd9, 0xba, 0x02, 0x05, 0x00,
+	0x00,
 }

scripts/genproto.sh

@@ -17,7 +17,7 @@ if ! [[ $(protoc --version) =~ "3.0.0" ]]; then
 fi
 
 # directories containing protos to be built
-DIRS="./wal/walpb ./etcdserver/etcdserverpb ./snap/snappb ./raft/raftpb ./storage/storagepb ./lease/leasepb ./auth/authpb"
+DIRS="./wal/walpb ./etcdserver/etcdserverpb ./snap/snappb ./raft/raftpb ./mvcc/mvccpb ./lease/leasepb ./auth/authpb"
 
 # exact version of protoc-gen-gogo to build
 SHA="c3995ae437bb78d1189f4f147dfe5f87ad3596e4"
@@ -75,7 +75,7 @@ if [ "$1" = "-g" ]; then
 		echo "protodoc is updated"
 	popd
 
-	protodoc --directories="etcdserver/etcdserverpb=service_message,storage/storagepb=service_message,lease/leasepb=service_message,auth/authpb=service_message" \
+	protodoc --directories="etcdserver/etcdserverpb=service_message,mvcc/mvccpb=service_message,lease/leasepb=service_message,auth/authpb=service_message" \
 		--title="etcd API Reference" \
 		--output="Documentation/dev-guide/api_reference_v3.md" \
 		--message-only-from-this-file="etcdserver/etcdserverpb/rpc.proto"

snap/snappb/snap.pb.go

@@ -337,13 +337,12 @@ var (
 )
 
 var fileDescriptorSnap = []byte{
-	// 118 bytes of a gzipped FileDescriptorProto
+	// 112 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0xce, 0x4b, 0x2c,
 	0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0xb1, 0x0b, 0x92, 0xa4, 0x44, 0xd2, 0xf3,
-	0xd3, 0xf3, 0xc1, 0x42, 0xfa, 0x20, 0x16, 0x44, 0x56, 0xc9, 0x8c, 0x8b, 0x03, 0x24, 0x5f, 0x9c,
-	0x91, 0x5f, 0x22, 0x24, 0xc6, 0xc5, 0x9c, 0x5c, 0x94, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0xeb,
-	0xc4, 0x72, 0xe2, 0x9e, 0x3c, 0x43, 0x10, 0x48, 0x40, 0x48, 0x88, 0x8b, 0x25, 0x25, 0xb1, 0x24,
-	0x51, 0x82, 0x09, 0x28, 0xc1, 0x13, 0x04, 0x66, 0x3b, 0x09, 0x9c, 0x78, 0x28, 0xc7, 0x70, 0xe2,
-	0x91, 0x1c, 0xe3, 0x05, 0x20, 0x7e, 0x00, 0xc4, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x03,
-	0x97, 0xa7, 0x74, 0x00, 0x00, 0x00,
+	0xd3, 0xf3, 0xc1, 0x42, 0xfa, 0x20, 0x16, 0x44, 0x56, 0x49, 0x9b, 0x8b, 0x03, 0x24, 0x5f, 0x9c,
+	0x91, 0x5f, 0x22, 0x24, 0xc8, 0xc5, 0x9c, 0x5c, 0x94, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0xeb,
+	0xc4, 0x72, 0xe2, 0x9e, 0x3c, 0x83, 0x10, 0x0f, 0x17, 0x4b, 0x4a, 0x62, 0x49, 0xa2, 0x04, 0x13,
+	0x50, 0x8c, 0xc7, 0x49, 0xe0, 0xc4, 0x43, 0x39, 0x86, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x00, 0xf1,
+	0x03, 0x20, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x89, 0xff, 0x64, 0x86, 0x69, 0x00, 0x00, 0x00,
 }

test

@@ -28,7 +28,7 @@ ln -s ${PWD}/cmd/vendor $GOPATH/src
 
 # Hack: gofmt ./ will recursively check the .git directory. So use *.go for gofmt.
 PKGS=`ls pkg/*/*go  | cut -f1,2 -d/ | sort | uniq`
-TESTABLE_AND_FORMATTABLE="client clientv3 discovery error etcdctl/ctlv2 etcdctl/ctlv3 etcdmain etcdserver etcdserver/auth etcdserver/api/v2http etcdserver/api/v2http/httptypes $PKGS proxy/httpproxy proxy/tcpproxy raft snap storage storage/backend store version wal rafthttp"
+TESTABLE_AND_FORMATTABLE="client clientv3 discovery error etcdctl/ctlv2 etcdctl/ctlv3 etcdmain etcdserver etcdserver/auth etcdserver/api/v2http etcdserver/api/v2http/httptypes $PKGS proxy/httpproxy proxy/tcpproxy raft snap mvcc mvcc/backend store version wal rafthttp"
 FORMATTABLE="$TESTABLE_AND_FORMATTABLE *.go etcdctl/ integration clientv3/integration e2e alarm"
 
 # user has not provided PKG override
@@ -153,7 +153,7 @@ function dep_tests {
 	echo "Checking package dependencies..."
 	# don't pull in etcdserver package
 	pushd clientv3 >/dev/null
-	badpkg="(etcdserver|storage)"
+	badpkg="(etcdserver|mvcc)"
 	deps=`go list -f '{{ .Deps }}'  | sed 's/ /\n/g' | egrep "${badpkg}" | egrep -v "${badpkg}/" || echo ""`
 	popd >/dev/null
 	if [ ! -z "$deps" ]; then

tools/benchmark/cmd/storage-put.go → tools/benchmark/cmd/mvcc-put.go

@@ -25,12 +25,12 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// storagePutCmd represents a storage put performance benchmarking tool
-var storagePutCmd = &cobra.Command{
+// mvccPutCmd represents a storage put performance benchmarking tool
+var mvccPutCmd = &cobra.Command{
 	Use:   "put",
 	Short: "Benchmark put performance of storage",
 
-	Run: storagePutFunc,
+	Run: mvccPutFunc,
 }
 
 var (
@@ -41,16 +41,16 @@ var (
 )
 
 func init() {
-	storageCmd.AddCommand(storagePutCmd)
+	mvccCmd.AddCommand(mvccPutCmd)
 
-	storagePutCmd.Flags().IntVar(&totalNrKeys, "total", 100, "a total number of keys to put")
-	storagePutCmd.Flags().IntVar(&storageKeySize, "key-size", 64, "a size of key (Byte)")
-	storagePutCmd.Flags().IntVar(&valueSize, "value-size", 64, "a size of value (Byte)")
-	storagePutCmd.Flags().BoolVar(&txn, "txn", false, "put a key in transaction or not")
+	mvccPutCmd.Flags().IntVar(&totalNrKeys, "total", 100, "a total number of keys to put")
+	mvccPutCmd.Flags().IntVar(&storageKeySize, "key-size", 64, "a size of key (Byte)")
+	mvccPutCmd.Flags().IntVar(&valueSize, "value-size", 64, "a size of value (Byte)")
+	mvccPutCmd.Flags().BoolVar(&txn, "txn", false, "put a key in transaction or not")
 
 	// TODO: after the PR https://github.com/spf13/cobra/pull/220 is merged, the below pprof related flags should be moved to RootCmd
-	storagePutCmd.Flags().StringVar(&cpuProfPath, "cpuprofile", "", "the path of file for storing cpu profile result")
-	storagePutCmd.Flags().StringVar(&memProfPath, "memprofile", "", "the path of file for storing heap profile result")
+	mvccPutCmd.Flags().StringVar(&cpuProfPath, "cpuprofile", "", "the path of file for storing cpu profile result")
+	mvccPutCmd.Flags().StringVar(&memProfPath, "memprofile", "", "the path of file for storing heap profile result")
 
 }
 
@@ -65,7 +65,7 @@ func createBytesSlice(bytesN, sliceN int) [][]byte {
 	return rs
 }
 
-func storagePutFunc(cmd *cobra.Command, args []string) {
+func mvccPutFunc(cmd *cobra.Command, args []string) {
 	if cpuProfPath != "" {
 		f, err := os.Create(cpuProfPath)
 		if err != nil {

tools/benchmark/cmd/storage.go → tools/benchmark/cmd/mvcc.go

@@ -19,8 +19,8 @@ import (
 	"time"
 
 	"github.com/coreos/etcd/lease"
-	"github.com/coreos/etcd/storage"
-	"github.com/coreos/etcd/storage/backend"
+	"github.com/coreos/etcd/mvcc"
+	"github.com/coreos/etcd/mvcc/backend"
 	"github.com/spf13/cobra"
 )
 
@@ -28,32 +28,32 @@ var (
 	batchInterval int
 	batchLimit    int
 
-	s storage.KV
+	s mvcc.KV
 )
 
-func initStorage() {
-	be := backend.New("storage-bench", time.Duration(batchInterval), batchLimit)
-	s = storage.NewStore(be, &lease.FakeLessor{}, nil)
-	os.Remove("storage-bench") // boltDB has an opened fd, so removing the file is ok
+func initMVCC() {
+	be := backend.New("mvcc-bench", time.Duration(batchInterval), batchLimit)
+	s = mvcc.NewStore(be, &lease.FakeLessor{}, nil)
+	os.Remove("mvcc-bench") // boltDB has an opened fd, so removing the file is ok
 }
 
-// storageCmd represents the storage benchmarking tools
-var storageCmd = &cobra.Command{
-	Use:   "storage",
-	Short: "Benchmark storage",
-	Long: `storage subcommand is a set of various benchmark tools for storage subsystem of etcd.
+// mvccCmd represents the MVCC storage benchmarking tools
+var mvccCmd = &cobra.Command{
+	Use:   "mvcc",
+	Short: "Benchmark mvcc",
+	Long: `storage subcommand is a set of various benchmark tools for MVCC storage subsystem of etcd.
 Actual benchmarks are implemented as its subcommands.`,
 
-	PersistentPreRun: storagePreRun,
+	PersistentPreRun: mvccPreRun,
 }
 
 func init() {
-	RootCmd.AddCommand(storageCmd)
+	RootCmd.AddCommand(mvccCmd)
 
-	storageCmd.PersistentFlags().IntVar(&batchInterval, "batch-interval", 100, "Interval of batching (milliseconds)")
-	storageCmd.PersistentFlags().IntVar(&batchLimit, "batch-limit", 10000, "A limit of batched transaction")
+	mvccCmd.PersistentFlags().IntVar(&batchInterval, "batch-interval", 100, "Interval of batching (milliseconds)")
+	mvccCmd.PersistentFlags().IntVar(&batchLimit, "batch-limit", 10000, "A limit of batched transaction")
 }
 
-func storagePreRun(cmd *cobra.Command, args []string) {
-	initStorage()
+func mvccPreRun(cmd *cobra.Command, args []string) {
+	initMVCC()
 }

wal/walpb/record.pb.go

@@ -501,16 +501,16 @@ var (
 )
 
 var fileDescriptorRecord = []byte{
-	// 175 bytes of a gzipped FileDescriptorProto
+	// 161 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x4a, 0x4d, 0xce,
 	0x2f, 0x4a, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2d, 0x4f, 0xcc, 0x29, 0x48, 0x92,
-	0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x8b, 0xe8, 0x83, 0x58, 0x10, 0x49, 0x25, 0x3f, 0x2e, 0xb6,
-	0x20, 0xb0, 0x62, 0x21, 0x09, 0x2e, 0x96, 0x92, 0xca, 0x82, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d,
-	0x66, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xc0, 0x22, 0x42, 0x62, 0x5c, 0xcc, 0xc9, 0x45,
-	0xc9, 0x12, 0x4c, 0x40, 0x09, 0x5e, 0xa8, 0x04, 0x48, 0x40, 0x48, 0x88, 0x8b, 0x25, 0x25, 0xb1,
-	0x24, 0x51, 0x82, 0x19, 0x28, 0xc1, 0x13, 0x04, 0x66, 0x2b, 0x39, 0x70, 0x71, 0x04, 0xe7, 0x25,
-	0x16, 0x14, 0x67, 0xe4, 0x97, 0x08, 0x49, 0x71, 0xb1, 0x66, 0xe6, 0xa5, 0xa4, 0x56, 0x80, 0x8d,
-	0x64, 0x81, 0xea, 0x84, 0x08, 0x81, 0x6d, 0x4b, 0x2d, 0xca, 0x05, 0x1b, 0xca, 0x02, 0xb7, 0x0d,
-	0x28, 0xe2, 0x24, 0x70, 0xe2, 0xa1, 0x1c, 0xc3, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x80, 0xf8, 0x01,
-	0x10, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x20, 0xf5, 0xbc, 0xcf, 0x00, 0x00, 0x00,
+	0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x8b, 0xe8, 0x83, 0x58, 0x10, 0x49, 0x25, 0x5b, 0x2e, 0xb6,
+	0x20, 0xb0, 0x62, 0x21, 0x21, 0x2e, 0x96, 0x92, 0xca, 0x82, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d,
+	0x66, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x84, 0x04, 0xb9, 0x98, 0x93, 0x8b, 0x92, 0x25, 0x98,
+	0x80, 0x42, 0xbc, 0x50, 0x21, 0x1e, 0x2e, 0x96, 0x94, 0xc4, 0x92, 0x44, 0x09, 0x66, 0xa0, 0x18,
+	0x8f, 0x92, 0x31, 0x17, 0x47, 0x70, 0x5e, 0x62, 0x41, 0x71, 0x46, 0x7e, 0x89, 0x90, 0x30, 0x17,
+	0x6b, 0x66, 0x5e, 0x4a, 0x6a, 0x05, 0xd8, 0x04, 0x16, 0xa8, 0x72, 0x90, 0xa9, 0xa9, 0x45, 0xb9,
+	0x60, 0x23, 0xa0, 0x62, 0x4e, 0x02, 0x27, 0x1e, 0xca, 0x31, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0x01,
+	0x88, 0x1f, 0x00, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x73, 0xbe, 0x84, 0x03, 0xb1, 0x00, 0x00,
+	0x00,
 }