diff --git a/storage/index.go b/storage/index.go index f67178cff..4640de7d4 100644 --- a/storage/index.go +++ b/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) diff --git a/storage/index_test.go b/storage/index_test.go index affa398f6..2998d8ae3 100644 --- a/storage/index_test.go +++ b/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 } diff --git a/storage/key_index.go b/storage/key_index.go index 35498c919..1d83e91eb 100644 --- a/storage/key_index.go +++ b/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]) diff --git a/storage/key_index_test.go b/storage/key_index_test.go index 3e7dc0c57..1ea5f7f7a 100644 --- a/storage/key_index_test.go +++ b/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) diff --git a/storage/kvstore.go b/storage/kvstore.go index ee8acf986..c6e276b84 100644 --- a/storage/kvstore.go +++ b/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) } diff --git a/storage/kvstore_compaction.go b/storage/kvstore_compaction.go index b6b1ba80f..7f1d307de 100644 --- a/storage/kvstore_compaction.go +++ b/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 { diff --git a/storage/kvstore_test.go b/storage/kvstore_test.go index 93d61a5d0..c83311c46 100644 --- a/storage/kvstore_test.go +++ b/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) diff --git a/storage/reversion.go b/storage/revision.go similarity index 71% rename from storage/reversion.go rename to storage/revision.go index 335f8048b..d579fc28b 100644 --- a/storage/reversion.go +++ b/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:])), } diff --git a/storage/reversion_test.go b/storage/revision_test.go similarity index 62% rename from storage/reversion_test.go rename to storage/revision_test.go index 021398cae..d122ab07e 100644 --- a/storage/reversion_test.go +++ b/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) } }