storage: reversion -> revision

storage/index.go

@@ -8,12 +8,12 @@ import (
 )
 
 type index interface {
-	Get(key []byte, atRev int64) (rev, created reversion, ver int64, err error)
-	Range(key, end []byte, atRev int64) ([][]byte, []reversion)
-	Put(key []byte, rev reversion)
-	Restore(key []byte, created, modified reversion, ver int64)
-	Tombstone(key []byte, rev reversion) error
-	Compact(rev int64) map[reversion]struct{}
+	Get(key []byte, atRev int64) (rev, created revision, ver int64, err error)
+	Range(key, end []byte, atRev int64) ([][]byte, []revision)
+	Put(key []byte, rev revision)
+	Restore(key []byte, created, modified revision, ver int64)
+	Tombstone(key []byte, rev revision) error
+	Compact(rev int64) map[revision]struct{}
 	Equal(b index) bool
 }
 
@@ -28,7 +28,7 @@ func newTreeIndex() index {
 	}
 }
 
-func (ti *treeIndex) Put(key []byte, rev reversion) {
+func (ti *treeIndex) Put(key []byte, rev revision) {
 	keyi := &keyIndex{key: key}
 
 	ti.Lock()
@@ -43,7 +43,7 @@ func (ti *treeIndex) Put(key []byte, rev reversion) {
 	okeyi.put(rev.main, rev.sub)
 }
 
-func (ti *treeIndex) Restore(key []byte, created, modified reversion, ver int64) {
+func (ti *treeIndex) Restore(key []byte, created, modified revision, ver int64) {
 	keyi := &keyIndex{key: key}
 
 	ti.Lock()
@@ -58,27 +58,27 @@ func (ti *treeIndex) Restore(key []byte, created, modified reversion, ver int64)
 	okeyi.put(modified.main, modified.sub)
 }
 
-func (ti *treeIndex) Get(key []byte, atRev int64) (modified, created reversion, ver int64, err error) {
+func (ti *treeIndex) Get(key []byte, atRev int64) (modified, created revision, ver int64, err error) {
 	keyi := &keyIndex{key: key}
 
 	ti.RLock()
 	defer ti.RUnlock()
 	item := ti.tree.Get(keyi)
 	if item == nil {
-		return reversion{}, reversion{}, 0, ErrReversionNotFound
+		return revision{}, revision{}, 0, ErrRevisionNotFound
 	}
 
 	keyi = item.(*keyIndex)
 	return keyi.get(atRev)
 }
 
-func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []reversion) {
+func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []revision) {
 	if end == nil {
 		rev, _, _, err := ti.Get(key, atRev)
 		if err != nil {
 			return nil, nil
 		}
-		return [][]byte{key}, []reversion{rev}
+		return [][]byte{key}, []revision{rev}
 	}
 
 	keyi := &keyIndex{key: key}
@@ -104,14 +104,14 @@ func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []
 	return keys, revs
 }
 
-func (ti *treeIndex) Tombstone(key []byte, rev reversion) error {
+func (ti *treeIndex) Tombstone(key []byte, rev revision) error {
 	keyi := &keyIndex{key: key}
 
 	ti.Lock()
 	defer ti.Unlock()
 	item := ti.tree.Get(keyi)
 	if item == nil {
-		return ErrReversionNotFound
+		return ErrRevisionNotFound
 	}
 
 	ki := item.(*keyIndex)
@@ -119,8 +119,8 @@ func (ti *treeIndex) Tombstone(key []byte, rev reversion) error {
 	return nil
 }
 
-func (ti *treeIndex) Compact(rev int64) map[reversion]struct{} {
-	available := make(map[reversion]struct{})
+func (ti *treeIndex) Compact(rev int64) map[revision]struct{} {
+	available := make(map[revision]struct{})
 	emptyki := make([]*keyIndex, 0)
 	log.Printf("store.index: compact %d", rev)
 	// TODO: do not hold the lock for long time?
@@ -137,7 +137,7 @@ func (ti *treeIndex) Compact(rev int64) map[reversion]struct{} {
 	return available
 }
 
-func compactIndex(rev int64, available map[reversion]struct{}, emptyki *[]*keyIndex) func(i btree.Item) bool {
+func compactIndex(rev int64, available map[revision]struct{}, emptyki *[]*keyIndex) func(i btree.Item) bool {
 	return func(i btree.Item) bool {
 		keyi := i.(*keyIndex)
 		keyi.compact(rev, available)

storage/index_test.go

@@ -9,20 +9,20 @@ func TestIndexPutAndGet(t *testing.T) {
 	index := newTestTreeIndex()
 
 	tests := []T{
-		{[]byte("foo"), 0, ErrReversionNotFound, 0},
+		{[]byte("foo"), 0, ErrRevisionNotFound, 0},
 		{[]byte("foo"), 1, nil, 1},
 		{[]byte("foo"), 3, nil, 1},
 		{[]byte("foo"), 5, nil, 5},
 		{[]byte("foo"), 6, nil, 5},
 
-		{[]byte("foo1"), 0, ErrReversionNotFound, 0},
-		{[]byte("foo1"), 1, ErrReversionNotFound, 0},
+		{[]byte("foo1"), 0, ErrRevisionNotFound, 0},
+		{[]byte("foo1"), 1, ErrRevisionNotFound, 0},
 		{[]byte("foo1"), 2, nil, 2},
 		{[]byte("foo1"), 5, nil, 2},
 		{[]byte("foo1"), 6, nil, 6},
 
-		{[]byte("foo2"), 0, ErrReversionNotFound, 0},
-		{[]byte("foo2"), 1, ErrReversionNotFound, 0},
+		{[]byte("foo2"), 0, ErrRevisionNotFound, 0},
+		{[]byte("foo2"), 1, ErrRevisionNotFound, 0},
 		{[]byte("foo2"), 3, nil, 3},
 		{[]byte("foo2"), 4, nil, 4},
 		{[]byte("foo2"), 6, nil, 4},
@@ -33,11 +33,11 @@ func TestIndexPutAndGet(t *testing.T) {
 func TestIndexRange(t *testing.T) {
 	atRev := int64(3)
 	allKeys := [][]byte{[]byte("foo"), []byte("foo1"), []byte("foo2")}
-	allRevs := []reversion{{main: 1}, {main: 2}, {main: 3}}
+	allRevs := []revision{{main: 1}, {main: 2}, {main: 3}}
 	tests := []struct {
 		key, end []byte
 		wkeys    [][]byte
-		wrevs    []reversion
+		wrevs    []revision
 	}{
 		// single key that not found
 		{
@@ -87,7 +87,7 @@ func TestIndexRange(t *testing.T) {
 func TestIndexTombstone(t *testing.T) {
 	index := newTestTreeIndex()
 
-	err := index.Tombstone([]byte("foo"), reversion{main: 7})
+	err := index.Tombstone([]byte("foo"), revision{main: 7})
 	if err != nil {
 		t.Errorf("tombstone error = %v, want nil", err)
 	}
@@ -95,9 +95,9 @@ func TestIndexTombstone(t *testing.T) {
 	if err != nil {
 		t.Errorf("get error = %v, want nil", err)
 	}
-	w := reversion{main: 7}
+	w := revision{main: 7}
 	if !reflect.DeepEqual(rev, w) {
-		t.Errorf("get reversion = %+v, want %+v", rev, w)
+		t.Errorf("get revision = %+v, want %+v", rev, w)
 	}
 }
 
@@ -105,26 +105,26 @@ func TestContinuousCompact(t *testing.T) {
 	index := newTestTreeIndex()
 
 	tests := []T{
-		{[]byte("foo"), 0, ErrReversionNotFound, 0},
+		{[]byte("foo"), 0, ErrRevisionNotFound, 0},
 		{[]byte("foo"), 1, nil, 1},
 		{[]byte("foo"), 3, nil, 1},
 		{[]byte("foo"), 5, nil, 5},
 		{[]byte("foo"), 6, nil, 5},
 
-		{[]byte("foo1"), 0, ErrReversionNotFound, 0},
-		{[]byte("foo1"), 1, ErrReversionNotFound, 0},
+		{[]byte("foo1"), 0, ErrRevisionNotFound, 0},
+		{[]byte("foo1"), 1, ErrRevisionNotFound, 0},
 		{[]byte("foo1"), 2, nil, 2},
 		{[]byte("foo1"), 5, nil, 2},
 		{[]byte("foo1"), 6, nil, 6},
 
-		{[]byte("foo2"), 0, ErrReversionNotFound, 0},
-		{[]byte("foo2"), 1, ErrReversionNotFound, 0},
+		{[]byte("foo2"), 0, ErrRevisionNotFound, 0},
+		{[]byte("foo2"), 1, ErrRevisionNotFound, 0},
 		{[]byte("foo2"), 3, nil, 3},
 		{[]byte("foo2"), 4, nil, 4},
 		{[]byte("foo2"), 6, nil, 4},
 	}
-	wa := map[reversion]struct{}{
-		reversion{main: 1}: struct{}{},
+	wa := map[revision]struct{}{
+		revision{main: 1}: struct{}{},
 	}
 	ga := index.Compact(1)
 	if !reflect.DeepEqual(ga, wa) {
@@ -132,9 +132,9 @@ func TestContinuousCompact(t *testing.T) {
 	}
 	verify(t, index, tests)
 
-	wa = map[reversion]struct{}{
-		reversion{main: 1}: struct{}{},
-		reversion{main: 2}: struct{}{},
+	wa = map[revision]struct{}{
+		revision{main: 1}: struct{}{},
+		revision{main: 2}: struct{}{},
 	}
 	ga = index.Compact(2)
 	if !reflect.DeepEqual(ga, wa) {
@@ -142,10 +142,10 @@ func TestContinuousCompact(t *testing.T) {
 	}
 	verify(t, index, tests)
 
-	wa = map[reversion]struct{}{
-		reversion{main: 1}: struct{}{},
-		reversion{main: 2}: struct{}{},
-		reversion{main: 3}: struct{}{},
+	wa = map[revision]struct{}{
+		revision{main: 1}: struct{}{},
+		revision{main: 2}: struct{}{},
+		revision{main: 3}: struct{}{},
 	}
 	ga = index.Compact(3)
 	if !reflect.DeepEqual(ga, wa) {
@@ -153,45 +153,45 @@ func TestContinuousCompact(t *testing.T) {
 	}
 	verify(t, index, tests)
 
-	wa = map[reversion]struct{}{
-		reversion{main: 1}: struct{}{},
-		reversion{main: 2}: struct{}{},
-		reversion{main: 4}: struct{}{},
+	wa = map[revision]struct{}{
+		revision{main: 1}: struct{}{},
+		revision{main: 2}: struct{}{},
+		revision{main: 4}: struct{}{},
 	}
 	ga = index.Compact(4)
-	delete(wa, reversion{main: 3})
-	tests[12] = T{[]byte("foo2"), 3, ErrReversionNotFound, 0}
+	delete(wa, revision{main: 3})
+	tests[12] = T{[]byte("foo2"), 3, ErrRevisionNotFound, 0}
 	if !reflect.DeepEqual(wa, ga) {
 		t.Errorf("a = %v, want %v", ga, wa)
 	}
 	verify(t, index, tests)
 
-	wa = map[reversion]struct{}{
-		reversion{main: 2}: struct{}{},
-		reversion{main: 4}: struct{}{},
-		reversion{main: 5}: struct{}{},
+	wa = map[revision]struct{}{
+		revision{main: 2}: struct{}{},
+		revision{main: 4}: struct{}{},
+		revision{main: 5}: struct{}{},
 	}
 	ga = index.Compact(5)
-	delete(wa, reversion{main: 1})
+	delete(wa, revision{main: 1})
 	if !reflect.DeepEqual(ga, wa) {
 		t.Errorf("a = %v, want %v", ga, wa)
 	}
-	tests[1] = T{[]byte("foo"), 1, ErrReversionNotFound, 0}
-	tests[2] = T{[]byte("foo"), 3, ErrReversionNotFound, 0}
+	tests[1] = T{[]byte("foo"), 1, ErrRevisionNotFound, 0}
+	tests[2] = T{[]byte("foo"), 3, ErrRevisionNotFound, 0}
 	verify(t, index, tests)
 
-	wa = map[reversion]struct{}{
-		reversion{main: 4}: struct{}{},
-		reversion{main: 5}: struct{}{},
-		reversion{main: 6}: struct{}{},
+	wa = map[revision]struct{}{
+		revision{main: 4}: struct{}{},
+		revision{main: 5}: struct{}{},
+		revision{main: 6}: struct{}{},
 	}
 	ga = index.Compact(6)
-	delete(wa, reversion{main: 2})
+	delete(wa, revision{main: 2})
 	if !reflect.DeepEqual(ga, wa) {
 		t.Errorf("a = %v, want %v", ga, wa)
 	}
-	tests[7] = T{[]byte("foo1"), 2, ErrReversionNotFound, 0}
-	tests[8] = T{[]byte("foo1"), 5, ErrReversionNotFound, 0}
+	tests[7] = T{[]byte("foo1"), 2, ErrRevisionNotFound, 0}
+	tests[8] = T{[]byte("foo1"), 5, ErrRevisionNotFound, 0}
 	verify(t, index, tests)
 }
 
@@ -217,11 +217,11 @@ type T struct {
 
 func newTestTreeIndex() index {
 	index := newTreeIndex()
-	index.Put([]byte("foo"), reversion{main: 1})
-	index.Put([]byte("foo1"), reversion{main: 2})
-	index.Put([]byte("foo2"), reversion{main: 3})
-	index.Put([]byte("foo2"), reversion{main: 4})
-	index.Put([]byte("foo"), reversion{main: 5})
-	index.Put([]byte("foo1"), reversion{main: 6})
+	index.Put([]byte("foo"), revision{main: 1})
+	index.Put([]byte("foo1"), revision{main: 2})
+	index.Put([]byte("foo2"), revision{main: 3})
+	index.Put([]byte("foo2"), revision{main: 4})
+	index.Put([]byte("foo"), revision{main: 5})
+	index.Put([]byte("foo1"), revision{main: 6})
 	return index
 }

storage/key_index.go

@@ -10,10 +10,10 @@ import (
 )
 
 var (
-	ErrReversionNotFound = errors.New("stroage: reversion not found")
+	ErrRevisionNotFound = errors.New("stroage: revision not found")
 )
 
-// keyIndex stores the reversion of an key in the backend.
+// keyIndex stores the revision of an key in the backend.
 // Each keyIndex has at least one key generation.
 // Each generation might have several key versions.
 // Tombstone on a key appends an tombstone version at the end
@@ -55,16 +55,16 @@ var (
 //    {empty} -> key SHOULD be removed.
 type keyIndex struct {
 	key         []byte
-	modified    reversion // the main rev of the last modification
+	modified    revision // the main rev of the last modification
 	generations []generation
 }
 
-// put puts a reversion to the keyIndex.
+// put puts a revision to the keyIndex.
 func (ki *keyIndex) put(main int64, sub int64) {
-	rev := reversion{main: main, sub: sub}
+	rev := revision{main: main, sub: sub}
 
 	if !rev.GreaterThan(ki.modified) {
-		log.Panicf("store.keyindex: put with unexpected smaller reversion [%v / %v]", rev, ki.modified)
+		log.Panicf("store.keyindex: put with unexpected smaller revision [%v / %v]", rev, ki.modified)
 	}
 	if len(ki.generations) == 0 {
 		ki.generations = append(ki.generations, generation{})
@@ -78,17 +78,17 @@ func (ki *keyIndex) put(main int64, sub int64) {
 	ki.modified = rev
 }
 
-func (ki *keyIndex) restore(created, modified reversion, ver int64) {
+func (ki *keyIndex) restore(created, modified revision, ver int64) {
 	if len(ki.generations) != 0 {
 		log.Panicf("store.keyindex: cannot restore non-empty keyIndex")
 	}
 
 	ki.modified = modified
-	g := generation{created: created, ver: ver, revs: []reversion{modified}}
+	g := generation{created: created, ver: ver, revs: []revision{modified}}
 	ki.generations = append(ki.generations, g)
 }
 
-// tombstone puts a reversion, pointing to a tombstone, to the keyIndex.
+// tombstone puts a revision, pointing to a tombstone, to the keyIndex.
 // It also creates a new empty generation in the keyIndex.
 func (ki *keyIndex) tombstone(main int64, sub int64) {
 	if ki.isEmpty() {
@@ -98,18 +98,18 @@ func (ki *keyIndex) tombstone(main int64, sub int64) {
 	ki.generations = append(ki.generations, generation{})
 }
 
-// get gets the modified, created reversion and version of the key that satisfies the given atRev.
+// get gets the modified, created revision and version of the key that satisfies the given atRev.
 // Rev must be higher than or equal to the given atRev.
-func (ki *keyIndex) get(atRev int64) (modified, created reversion, ver int64, err error) {
+func (ki *keyIndex) get(atRev int64) (modified, created revision, ver int64, err error) {
 	if ki.isEmpty() {
 		log.Panicf("store.keyindex: unexpected get on empty keyIndex %s", string(ki.key))
 	}
 	g := ki.findGeneration(atRev)
 	if g.isEmpty() {
-		return reversion{}, reversion{}, 0, ErrReversionNotFound
+		return revision{}, revision{}, 0, ErrRevisionNotFound
 	}
 
-	f := func(rev reversion) bool {
+	f := func(rev revision) bool {
 		if rev.main <= atRev {
 			return false
 		}
@@ -121,22 +121,22 @@ func (ki *keyIndex) get(atRev int64) (modified, created reversion, ver int64, er
 		return g.revs[n], g.created, g.ver - int64(len(g.revs)-n-1), nil
 	}
 
-	return reversion{}, reversion{}, 0, ErrReversionNotFound
+	return revision{}, revision{}, 0, ErrRevisionNotFound
 }
 
 // compact compacts a keyIndex by removing the versions with smaller or equal
-// reversion than the given atRev except the largest one (If the largest one is
+// revision than the given atRev except the largest one (If the largest one is
 // a tombstone, it will not be kept).
 // If a generation becomes empty during compaction, it will be removed.
-func (ki *keyIndex) compact(atRev int64, available map[reversion]struct{}) {
+func (ki *keyIndex) compact(atRev int64, available map[revision]struct{}) {
 	if ki.isEmpty() {
 		log.Panic("store.keyindex: unexpected compact on empty keyIndex %s", string(ki.key))
 	}
 
-	// walk until reaching the first reversion that has an reversion smaller or equal to
-	// the atReversion.
+	// walk until reaching the first revision that has an revision smaller or equal to
+	// the atRevision.
 	// add it to the available map
-	f := func(rev reversion) bool {
+	f := func(rev revision) bool {
 		if rev.main <= atRev {
 			available[rev] = struct{}{}
 			return false
@@ -231,18 +231,18 @@ func (ki *keyIndex) String() string {
 
 type generation struct {
 	ver     int64
-	created reversion // when the generation is created (put in first reversion).
-	revs    []reversion
+	created revision // when the generation is created (put in first revision).
+	revs    []revision
 }
 
 func (g *generation) isEmpty() bool { return g == nil || len(g.revs) == 0 }
 
-// walk walks through the reversions in the generation in ascending order.
+// walk walks through the revisions in the generation in ascending order.
 // It passes the revision to the given function.
 // walk returns until: 1. it finishs walking all pairs 2. the function returns false.
 // walk returns the position at where it stopped. If it stopped after
 // finishing walking, -1 will be returned.
-func (g *generation) walk(f func(rev reversion) bool) int {
+func (g *generation) walk(f func(rev revision) bool) int {
 	l := len(g.revs)
 	for i := range g.revs {
 		ok := f(g.revs[l-i-1])

storage/key_index_test.go

@@ -13,7 +13,7 @@ func TestKeyIndexGet(t *testing.T) {
 	//    {8[1], 10[2], 12(t)[3]}
 	//    {4[2], 6(t)[3]}
 	ki := newTestKeyIndex()
-	ki.compact(4, make(map[reversion]struct{}))
+	ki.compact(4, make(map[revision]struct{}))
 
 	tests := []struct {
 		rev int64
@@ -55,8 +55,8 @@ func TestKeyIndexPut(t *testing.T) {
 
 	wki := &keyIndex{
 		key:         []byte("foo"),
-		modified:    reversion{5, 0},
-		generations: []generation{{created: reversion{5, 0}, ver: 1, revs: []reversion{{main: 5}}}},
+		modified:    revision{5, 0},
+		generations: []generation{{created: revision{5, 0}, ver: 1, revs: []revision{{main: 5}}}},
 	}
 	if !reflect.DeepEqual(ki, wki) {
 		t.Errorf("ki = %+v, want %+v", ki, wki)
@@ -66,8 +66,8 @@ func TestKeyIndexPut(t *testing.T) {
 
 	wki = &keyIndex{
 		key:         []byte("foo"),
-		modified:    reversion{7, 0},
-		generations: []generation{{created: reversion{5, 0}, ver: 2, revs: []reversion{{main: 5}, {main: 7}}}},
+		modified:    revision{7, 0},
+		generations: []generation{{created: revision{5, 0}, ver: 2, revs: []revision{{main: 5}, {main: 7}}}},
 	}
 	if !reflect.DeepEqual(ki, wki) {
 		t.Errorf("ki = %+v, want %+v", ki, wki)
@@ -82,8 +82,8 @@ func TestKeyIndexTombstone(t *testing.T) {
 
 	wki := &keyIndex{
 		key:         []byte("foo"),
-		modified:    reversion{7, 0},
-		generations: []generation{{created: reversion{5, 0}, ver: 2, revs: []reversion{{main: 5}, {main: 7}}}, {}},
+		modified:    revision{7, 0},
+		generations: []generation{{created: revision{5, 0}, ver: 2, revs: []revision{{main: 5}, {main: 7}}}, {}},
 	}
 	if !reflect.DeepEqual(ki, wki) {
 		t.Errorf("ki = %+v, want %+v", ki, wki)
@@ -95,10 +95,10 @@ func TestKeyIndexTombstone(t *testing.T) {
 
 	wki = &keyIndex{
 		key:      []byte("foo"),
-		modified: reversion{15, 0},
+		modified: revision{15, 0},
 		generations: []generation{
-			{created: reversion{5, 0}, ver: 2, revs: []reversion{{main: 5}, {main: 7}}},
-			{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 9}, {main: 15}}},
+			{created: revision{5, 0}, ver: 2, revs: []revision{{main: 5}, {main: 7}}},
+			{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 9}, {main: 15}}},
 			{},
 		},
 	}
@@ -112,176 +112,176 @@ func TestKeyIndexCompact(t *testing.T) {
 		compact int64
 
 		wki *keyIndex
-		wam map[reversion]struct{}
+		wam map[revision]struct{}
 	}{
 		{
 			1,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{2, 0}, ver: 3, revs: []reversion{{main: 2}, {main: 4}, {main: 6}}},
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{2, 0}, ver: 3, revs: []revision{{main: 2}, {main: 4}, {main: 6}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{},
+			map[revision]struct{}{},
 		},
 		{
 			2,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{2, 0}, ver: 3, revs: []reversion{{main: 2}, {main: 4}, {main: 6}}},
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{2, 0}, ver: 3, revs: []revision{{main: 2}, {main: 4}, {main: 6}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 2}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 2}: struct{}{},
 			},
 		},
 		{
 			3,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{2, 0}, ver: 3, revs: []reversion{{main: 2}, {main: 4}, {main: 6}}},
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{2, 0}, ver: 3, revs: []revision{{main: 2}, {main: 4}, {main: 6}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 2}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 2}: struct{}{},
 			},
 		},
 		{
 			4,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{2, 0}, ver: 3, revs: []reversion{{main: 4}, {main: 6}}},
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{2, 0}, ver: 3, revs: []revision{{main: 4}, {main: 6}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 4}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 4}: struct{}{},
 			},
 		},
 		{
 			5,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{2, 0}, ver: 3, revs: []reversion{{main: 4}, {main: 6}}},
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{2, 0}, ver: 3, revs: []revision{{main: 4}, {main: 6}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 4}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 4}: struct{}{},
 			},
 		},
 		{
 			6,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{},
+			map[revision]struct{}{},
 		},
 		{
 			7,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{},
+			map[revision]struct{}{},
 		},
 		{
 			8,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 8}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 8}: struct{}{},
 			},
 		},
 		{
 			9,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 8}, {main: 10}, {main: 12}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 8}, {main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 8}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 8}: struct{}{},
 			},
 		},
 		{
 			10,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 10}, {main: 12}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 10}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 10}: struct{}{},
 			},
 		},
 		{
 			11,
 			&keyIndex{
 				key:      []byte("foo"),
-				modified: reversion{12, 0},
+				modified: revision{12, 0},
 				generations: []generation{
-					{created: reversion{8, 0}, ver: 3, revs: []reversion{{main: 10}, {main: 12}}},
+					{created: revision{8, 0}, ver: 3, revs: []revision{{main: 10}, {main: 12}}},
 					{},
 				},
 			},
-			map[reversion]struct{}{
-				reversion{main: 10}: struct{}{},
+			map[revision]struct{}{
+				revision{main: 10}: struct{}{},
 			},
 		},
 		{
 			12,
 			&keyIndex{
 				key:         []byte("foo"),
-				modified:    reversion{12, 0},
+				modified:    revision{12, 0},
 				generations: []generation{{}},
 			},
-			map[reversion]struct{}{},
+			map[revision]struct{}{},
 		},
 	}
 
 	// Continous Compaction
 	ki := newTestKeyIndex()
 	for i, tt := range tests {
-		am := make(map[reversion]struct{})
+		am := make(map[revision]struct{})
 		ki.compact(tt.compact, am)
 		if !reflect.DeepEqual(ki, tt.wki) {
 			t.Errorf("#%d: ki = %+v, want %+v", i, ki, tt.wki)
@@ -294,7 +294,7 @@ func TestKeyIndexCompact(t *testing.T) {
 	// Jump Compaction
 	for i, tt := range tests {
 		if (i%2 == 0 && i < 6) && (i%2 == 1 && i > 6) {
-			am := make(map[reversion]struct{})
+			am := make(map[revision]struct{})
 			ki.compact(tt.compact, am)
 			if !reflect.DeepEqual(ki, tt.wki) {
 				t.Errorf("#%d: ki = %+v, want %+v", i, ki, tt.wki)
@@ -308,7 +308,7 @@ func TestKeyIndexCompact(t *testing.T) {
 	// OnceCompaction
 	for i, tt := range tests {
 		ki := newTestKeyIndex()
-		am := make(map[reversion]struct{})
+		am := make(map[revision]struct{})
 		ki.compact(tt.compact, am)
 		if !reflect.DeepEqual(ki, tt.wki) {
 			t.Errorf("#%d: ki = %+v, want %+v", i, ki, tt.wki)

storage/kvstore.go

@@ -23,8 +23,8 @@ var (
 	finishedCompactKeyName  = []byte("finishedCompactRev")
 
 	ErrTxnIDMismatch = errors.New("storage: txn id mismatch")
-	ErrCompacted     = errors.New("storage: required reversion has been compacted")
-	ErrFutureRev     = errors.New("storage: required reversion is a future reversion")
+	ErrCompacted     = errors.New("storage: required revision has been compacted")
+	ErrFutureRev     = errors.New("storage: required revision is a future revision")
 )
 
 type store struct {
@@ -33,8 +33,8 @@ type store struct {
 	b       backend.Backend
 	kvindex index
 
-	currentRev reversion
-	// the main reversion of the last compaction
+	currentRev revision
+	// the main revision of the last compaction
 	compactMainRev int64
 
 	tmu   sync.Mutex // protect the txnID field
@@ -52,7 +52,7 @@ func newStore(path string) *store {
 	s := &store{
 		b:              backend.New(path, batchInterval, batchLimit),
 		kvindex:        newTreeIndex(),
-		currentRev:     reversion{},
+		currentRev:     revision{},
 		compactMainRev: -1,
 		stopc:          make(chan struct{}),
 	}
@@ -160,7 +160,7 @@ func (s *store) Compact(rev int64) error {
 	s.compactMainRev = rev
 
 	rbytes := newRevBytes()
-	revToBytes(reversion{main: rev}, rbytes)
+	revToBytes(revision{main: rev}, rbytes)
 
 	tx := s.b.BatchTx()
 	tx.Lock()
@@ -184,8 +184,8 @@ func (s *store) Restore() error {
 	defer s.mu.Unlock()
 
 	min, max := newRevBytes(), newRevBytes()
-	revToBytes(reversion{}, min)
-	revToBytes(reversion{main: math.MaxInt64, sub: math.MaxInt64}, max)
+	revToBytes(revision{}, min)
+	revToBytes(revision{main: math.MaxInt64, sub: math.MaxInt64}, max)
 
 	// restore index
 	tx := s.b.BatchTx()
@@ -209,14 +209,14 @@ func (s *store) Restore() error {
 		// restore index
 		switch e.Type {
 		case storagepb.PUT:
-			s.kvindex.Restore(e.Kv.Key, reversion{e.Kv.CreateIndex, 0}, rev, e.Kv.Version)
+			s.kvindex.Restore(e.Kv.Key, revision{e.Kv.CreateIndex, 0}, rev, e.Kv.Version)
 		case storagepb.DELETE:
 			s.kvindex.Tombstone(e.Kv.Key, rev)
 		default:
 			log.Panicf("storage: unexpected event type %s", e.Type)
 		}
 
-		// update reversion
+		// update revision
 		s.currentRev = rev
 	}
 
@@ -308,7 +308,7 @@ func (s *store) put(key, value []byte, rev int64) {
 	}
 
 	ibytes := newRevBytes()
-	revToBytes(reversion{main: rev, sub: s.currentRev.sub}, ibytes)
+	revToBytes(revision{main: rev, sub: s.currentRev.sub}, ibytes)
 
 	ver = ver + 1
 	event := storagepb.Event{
@@ -331,7 +331,7 @@ func (s *store) put(key, value []byte, rev int64) {
 	tx.Lock()
 	defer tx.Unlock()
 	tx.UnsafePut(keyBucketName, ibytes, d)
-	s.kvindex.Put(key, reversion{main: rev, sub: s.currentRev.sub})
+	s.kvindex.Put(key, revision{main: rev, sub: s.currentRev.sub})
 	s.currentRev.sub += 1
 }
 
@@ -388,7 +388,7 @@ func (s *store) delete(key []byte, mainrev int64) bool {
 	}
 
 	ibytes := newRevBytes()
-	revToBytes(reversion{main: mainrev, sub: s.currentRev.sub}, ibytes)
+	revToBytes(revision{main: mainrev, sub: s.currentRev.sub}, ibytes)
 
 	event := storagepb.Event{
 		Type: storagepb.DELETE,
@@ -403,7 +403,7 @@ func (s *store) delete(key []byte, mainrev int64) bool {
 	}
 
 	tx.UnsafePut(keyBucketName, ibytes, d)
-	err = s.kvindex.Tombstone(key, reversion{main: mainrev, sub: s.currentRev.sub})
+	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)
 	}

storage/kvstore_compaction.go

@@ -5,7 +5,7 @@ import (
 	"time"
 )
 
-func (s *store) scheduleCompaction(compactMainRev int64, keep map[reversion]struct{}) {
+func (s *store) scheduleCompaction(compactMainRev int64, keep map[revision]struct{}) {
 	defer s.wg.Done()
 	end := make([]byte, 8)
 	binary.BigEndian.PutUint64(end, uint64(compactMainRev+1))
@@ -13,7 +13,7 @@ func (s *store) scheduleCompaction(compactMainRev int64, keep map[reversion]stru
 	batchsize := int64(10000)
 	last := make([]byte, 8+1+8)
 	for {
-		var rev reversion
+		var rev revision
 
 		tx := s.b.BatchTx()
 		tx.Lock()
@@ -28,14 +28,14 @@ func (s *store) scheduleCompaction(compactMainRev int64, keep map[reversion]stru
 
 		if len(keys) == 0 {
 			rbytes := make([]byte, 8+1+8)
-			revToBytes(reversion{main: compactMainRev}, rbytes)
+			revToBytes(revision{main: compactMainRev}, rbytes)
 			tx.UnsafePut(metaBucketName, finishedCompactKeyName, rbytes)
 			tx.Unlock()
 			return
 		}
 
 		// update last
-		revToBytes(reversion{main: rev.main, sub: rev.sub + 1}, last)
+		revToBytes(revision{main: rev.main, sub: rev.sub + 1}, last)
 		tx.Unlock()
 
 		select {

storage/kvstore_test.go

@@ -407,9 +407,9 @@ func TestRestore(t *testing.T) {
 	s0.DeleteRange([]byte("foo3"), nil)
 
 	mink := newRevBytes()
-	revToBytes(reversion{main: 0, sub: 0}, mink)
+	revToBytes(revision{main: 0, sub: 0}, mink)
 	maxk := newRevBytes()
-	revToBytes(reversion{main: math.MaxInt64, sub: math.MaxInt64}, maxk)
+	revToBytes(revision{main: math.MaxInt64, sub: math.MaxInt64}, maxk)
 	s0kvs, _, err := s0.rangeKeys(mink, maxk, 0, 0)
 	if err != nil {
 		t.Fatalf("rangeKeys on s0 error (%v)", err)
@@ -442,7 +442,7 @@ func TestRestoreContinueUnfinishedCompaction(t *testing.T) {
 
 	// write scheduled compaction, but not do compaction
 	rbytes := newRevBytes()
-	revToBytes(reversion{main: 2}, rbytes)
+	revToBytes(revision{main: 2}, rbytes)
 	tx := s0.b.BatchTx()
 	tx.Lock()
 	tx.UnsafePut(metaBucketName, scheduledCompactKeyName, rbytes)
@@ -462,7 +462,7 @@ func TestRestoreContinueUnfinishedCompaction(t *testing.T) {
 	// check the key in backend is deleted
 	revbytes := newRevBytes()
 	// TODO: compact should delete main=2 key too
-	revToBytes(reversion{main: 1}, revbytes)
+	revToBytes(revision{main: 1}, revbytes)
 	tx = s1.b.BatchTx()
 	tx.Lock()
 	ks, _ := tx.UnsafeRange(keyBucketName, revbytes, nil, 0)

storage/reversion.go → storage/revision.go

@@ -2,12 +2,12 @@ package storage
 
 import "encoding/binary"
 
-type reversion struct {
+type revision struct {
 	main int64
 	sub  int64
 }
 
-func (a reversion) GreaterThan(b reversion) bool {
+func (a revision) GreaterThan(b revision) bool {
 	if a.main > b.main {
 		return true
 	}
@@ -21,14 +21,14 @@ func newRevBytes() []byte {
 	return make([]byte, 8+1+8)
 }
 
-func revToBytes(rev reversion, bytes []byte) {
+func revToBytes(rev revision, bytes []byte) {
 	binary.BigEndian.PutUint64(bytes, uint64(rev.main))
 	bytes[8] = '_'
 	binary.BigEndian.PutUint64(bytes[9:], uint64(rev.sub))
 }
 
-func bytesToRev(bytes []byte) reversion {
-	return reversion{
+func bytesToRev(bytes []byte) revision {
+	return revision{
 		main: int64(binary.BigEndian.Uint64(bytes[0:8])),
 		sub:  int64(binary.BigEndian.Uint64(bytes[9:])),
 	}

storage/reversion_test.go → storage/revision_test.go

@@ -7,17 +7,17 @@ import (
 	"testing"
 )
 
-// TestReversion tests that reversion could be encoded to and decoded from
+// TestRevision tests that revision could be encoded to and decoded from
 // bytes slice. Moreover, the lexicograph order of its byte slice representation
 // follows the order of (main, sub).
-func TestReversion(t *testing.T) {
-	tests := []reversion{
+func TestRevision(t *testing.T) {
+	tests := []revision{
 		// order in (main, sub)
-		reversion{},
-		reversion{main: 1, sub: 0},
-		reversion{main: 1, sub: 1},
-		reversion{main: 2, sub: 0},
-		reversion{main: math.MaxInt64, sub: math.MaxInt64},
+		revision{},
+		revision{main: 1, sub: 0},
+		revision{main: 1, sub: 1},
+		revision{main: 2, sub: 0},
+		revision{main: math.MaxInt64, sub: math.MaxInt64},
 	}
 
 	bs := make([][]byte, len(tests))
@@ -27,7 +27,7 @@ func TestReversion(t *testing.T) {
 		bs[i] = b
 
 		if grev := bytesToRev(b); !reflect.DeepEqual(grev, tt) {
-			t.Errorf("#%d: reversion = %+v, want %+v", i, grev, tt)
+			t.Errorf("#%d: revision = %+v, want %+v", i, grev, tt)
 		}
 	}