Skip to content

Commit 395376d

Browse files
dusk125dusk125
committed
Refactor common revision code to pkg
Signed-off-by: Allen Ray <[email protected]>
1 parent 1c5289d commit 395376d

17 files changed

+470
-554
lines changed

‎etcdutl/snapshot/util.go

-53
This file was deleted.

‎etcdutl/snapshot/v3_snapshot.go

+16-16
Original file line numberDiff line numberDiff line change
@@ -156,8 +156,8 @@ func (s *v3Manager) Status(dbPath string) (ds Status, err error) {
156156
return fmt.Errorf("cannot write to bucket %s", herr.Error())
157157
}
158158
if iskeyb {
159-
rev := bytesToRev(k)
160-
ds.Revision = rev.main
159+
rev := mvcc.BytesToRev(k)
160+
ds.Revision = rev.Main
161161
}
162162
ds.TotalKey++
163163
return nil
@@ -346,42 +346,42 @@ func (s *v3Manager) modifyLatestRevision(bumpAmount uint64) error {
346346
return err
347347
}
348348

349-
latest = s.unsafeBumpRevision(tx, latest, int64(bumpAmount))
349+
latest = s.unsafeBumpBucketsRevision(tx, latest, int64(bumpAmount))
350350
s.unsafeMarkRevisionCompacted(tx, latest)
351351

352352
return nil
353353
}
354354

355-
func (s *v3Manager) unsafeBumpRevision(tx backend.UnsafeWriter, latest revision, amount int64) revision {
355+
func (s *v3Manager) unsafeBumpBucketsRevision(tx backend.UnsafeWriter, latest mvcc.Revision, amount int64) mvcc.Revision {
356356
s.lg.Info(
357357
"bumping latest revision",
358-
zap.Int64("latest-revision", latest.main),
358+
zap.Int64("latest-revision", latest.Main),
359359
zap.Int64("bump-amount", amount),
360-
zap.Int64("new-latest-revision", latest.main+amount),
360+
zap.Int64("new-latest-revision", latest.Main+amount),
361361
)
362362

363-
latest.main += amount
364-
latest.sub = 0
365-
k := make([]byte, 17)
366-
revToBytes(k, latest)
363+
latest.Main += amount
364+
latest.Sub = 0
365+
k := mvcc.NewRevBytes()
366+
k = mvcc.RevToBytes(latest, k)
367367
tx.UnsafePut(schema.Key, k, []byte{})
368368

369369
return latest
370370
}
371371

372-
func (s *v3Manager) unsafeMarkRevisionCompacted(tx backend.UnsafeWriter, latest revision) {
372+
func (s *v3Manager) unsafeMarkRevisionCompacted(tx backend.UnsafeWriter, latest mvcc.Revision) {
373373
s.lg.Info(
374374
"marking revision compacted",
375-
zap.Int64("revision", latest.main),
375+
zap.Int64("revision", latest.Main),
376376
)
377377

378-
mvcc.UnsafeSetScheduledCompact(tx, latest.main)
378+
mvcc.UnsafeSetScheduledCompact(tx, latest.Main)
379379
}
380380

381-
func (s *v3Manager) unsafeGetLatestRevision(tx backend.UnsafeReader) (revision, error) {
382-
var latest revision
381+
func (s *v3Manager) unsafeGetLatestRevision(tx backend.UnsafeReader) (mvcc.Revision, error) {
382+
var latest mvcc.Revision
383383
err := tx.UnsafeForEach(schema.Key, func(k, _ []byte) (err error) {
384-
rev := bytesToRev(k)
384+
rev := mvcc.BytesToRev(k)
385385

386386
if rev.GreaterThan(latest) {
387387
latest = rev

‎server/storage/mvcc/hash.go

+6-6
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ const (
3030
hashStorageMaxSize = 10
3131
)
3232

33-
func unsafeHashByRev(tx backend.UnsafeReader, compactRevision, revision int64, keep map[revision]struct{}) (KeyValueHash, error) {
33+
func unsafeHashByRev(tx backend.UnsafeReader, compactRevision, revision int64, keep map[Revision]struct{}) (KeyValueHash, error) {
3434
h := newKVHasher(compactRevision, revision, keep)
3535
err := tx.UnsafeForEach(schema.Key, func(k, v []byte) error {
3636
h.WriteKeyValue(k, v)
@@ -43,10 +43,10 @@ type kvHasher struct {
4343
hash hash.Hash32
4444
compactRevision int64
4545
revision int64
46-
keep map[revision]struct{}
46+
keep map[Revision]struct{}
4747
}
4848

49-
func newKVHasher(compactRev, rev int64, keep map[revision]struct{}) kvHasher {
49+
func newKVHasher(compactRev, rev int64, keep map[Revision]struct{}) kvHasher {
5050
h := crc32.New(crc32.MakeTable(crc32.Castagnoli))
5151
h.Write(schema.Key.Name())
5252
return kvHasher{
@@ -58,12 +58,12 @@ func newKVHasher(compactRev, rev int64, keep map[revision]struct{}) kvHasher {
5858
}
5959

6060
func (h *kvHasher) WriteKeyValue(k, v []byte) {
61-
kr := bytesToRev(k)
62-
upper := revision{main: h.revision + 1}
61+
kr := BytesToRev(k)
62+
upper := Revision{Main: h.revision + 1}
6363
if !upper.GreaterThan(kr) {
6464
return
6565
}
66-
lower := revision{main: h.compactRevision + 1}
66+
lower := Revision{Main: h.compactRevision + 1}
6767
// skip revisions that are scheduled for deletion
6868
// due to compacting; don't skip if there isn't one.
6969
if lower.GreaterThan(kr) && len(h.keep) > 0 {

‎server/storage/mvcc/index.go

+23-23
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,14 @@ import (
2222
)
2323

2424
type index interface {
25-
Get(key []byte, atRev int64) (rev, created revision, ver int64, err error)
26-
Range(key, end []byte, atRev int64) ([][]byte, []revision)
27-
Revisions(key, end []byte, atRev int64, limit int) ([]revision, int)
25+
Get(key []byte, atRev int64) (rev, created Revision, ver int64, err error)
26+
Range(key, end []byte, atRev int64) ([][]byte, []Revision)
27+
Revisions(key, end []byte, atRev int64, limit int) ([]Revision, int)
2828
CountRevisions(key, end []byte, atRev int64) int
29-
Put(key []byte, rev revision)
30-
Tombstone(key []byte, rev revision) error
31-
Compact(rev int64) map[revision]struct{}
32-
Keep(rev int64) map[revision]struct{}
29+
Put(key []byte, rev Revision)
30+
Tombstone(key []byte, rev Revision) error
31+
Compact(rev int64) map[Revision]struct{}
32+
Keep(rev int64) map[Revision]struct{}
3333
Equal(b index) bool
3434

3535
Insert(ki *keyIndex)
@@ -51,30 +51,30 @@ func newTreeIndex(lg *zap.Logger) index {
5151
}
5252
}
5353

54-
func (ti *treeIndex) Put(key []byte, rev revision) {
54+
func (ti *treeIndex) Put(key []byte, rev Revision) {
5555
keyi := &keyIndex{key: key}
5656

5757
ti.Lock()
5858
defer ti.Unlock()
5959
okeyi, ok := ti.tree.Get(keyi)
6060
if !ok {
61-
keyi.put(ti.lg, rev.main, rev.sub)
61+
keyi.put(ti.lg, rev.Main, rev.Sub)
6262
ti.tree.ReplaceOrInsert(keyi)
6363
return
6464
}
65-
okeyi.put(ti.lg, rev.main, rev.sub)
65+
okeyi.put(ti.lg, rev.Main, rev.Sub)
6666
}
6767

68-
func (ti *treeIndex) Get(key []byte, atRev int64) (modified, created revision, ver int64, err error) {
68+
func (ti *treeIndex) Get(key []byte, atRev int64) (modified, created Revision, ver int64, err error) {
6969
ti.RLock()
7070
defer ti.RUnlock()
7171
return ti.unsafeGet(key, atRev)
7272
}
7373

74-
func (ti *treeIndex) unsafeGet(key []byte, atRev int64) (modified, created revision, ver int64, err error) {
74+
func (ti *treeIndex) unsafeGet(key []byte, atRev int64) (modified, created Revision, ver int64, err error) {
7575
keyi := &keyIndex{key: key}
7676
if keyi = ti.keyIndex(keyi); keyi == nil {
77-
return revision{}, revision{}, 0, ErrRevisionNotFound
77+
return Revision{}, Revision{}, 0, ErrRevisionNotFound
7878
}
7979
return keyi.get(ti.lg, atRev)
8080
}
@@ -109,7 +109,7 @@ func (ti *treeIndex) unsafeVisit(key, end []byte, f func(ki *keyIndex) bool) {
109109
// Revisions returns limited number of revisions from key(included) to end(excluded)
110110
// at the given rev. The returned slice is sorted in the order of key. There is no limit if limit <= 0.
111111
// The second return parameter isn't capped by the limit and reflects the total number of revisions.
112-
func (ti *treeIndex) Revisions(key, end []byte, atRev int64, limit int) (revs []revision, total int) {
112+
func (ti *treeIndex) Revisions(key, end []byte, atRev int64, limit int) (revs []Revision, total int) {
113113
ti.RLock()
114114
defer ti.RUnlock()
115115

@@ -118,7 +118,7 @@ func (ti *treeIndex) Revisions(key, end []byte, atRev int64, limit int) (revs []
118118
if err != nil {
119119
return nil, 0
120120
}
121-
return []revision{rev}, 1
121+
return []Revision{rev}, 1
122122
}
123123
ti.unsafeVisit(key, end, func(ki *keyIndex) bool {
124124
if rev, _, _, err := ki.get(ti.lg, atRev); err == nil {
@@ -155,7 +155,7 @@ func (ti *treeIndex) CountRevisions(key, end []byte, atRev int64) int {
155155
return total
156156
}
157157

158-
func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []revision) {
158+
func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []Revision) {
159159
ti.RLock()
160160
defer ti.RUnlock()
161161

@@ -164,7 +164,7 @@ func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []
164164
if err != nil {
165165
return nil, nil
166166
}
167-
return [][]byte{key}, []revision{rev}
167+
return [][]byte{key}, []Revision{rev}
168168
}
169169
ti.unsafeVisit(key, end, func(ki *keyIndex) bool {
170170
if rev, _, _, err := ki.get(ti.lg, atRev); err == nil {
@@ -176,7 +176,7 @@ func (ti *treeIndex) Range(key, end []byte, atRev int64) (keys [][]byte, revs []
176176
return keys, revs
177177
}
178178

179-
func (ti *treeIndex) Tombstone(key []byte, rev revision) error {
179+
func (ti *treeIndex) Tombstone(key []byte, rev Revision) error {
180180
keyi := &keyIndex{key: key}
181181

182182
ti.Lock()
@@ -186,11 +186,11 @@ func (ti *treeIndex) Tombstone(key []byte, rev revision) error {
186186
return ErrRevisionNotFound
187187
}
188188

189-
return ki.tombstone(ti.lg, rev.main, rev.sub)
189+
return ki.tombstone(ti.lg, rev.Main, rev.Sub)
190190
}
191191

192-
func (ti *treeIndex) Compact(rev int64) map[revision]struct{} {
193-
available := make(map[revision]struct{})
192+
func (ti *treeIndex) Compact(rev int64) map[Revision]struct{} {
193+
available := make(map[Revision]struct{})
194194
ti.lg.Info("compact tree index", zap.Int64("revision", rev))
195195
ti.Lock()
196196
clone := ti.tree.Clone()
@@ -214,8 +214,8 @@ func (ti *treeIndex) Compact(rev int64) map[revision]struct{} {
214214
}
215215

216216
// Keep finds all revisions to be kept for a Compaction at the given rev.
217-
func (ti *treeIndex) Keep(rev int64) map[revision]struct{} {
218-
available := make(map[revision]struct{})
217+
func (ti *treeIndex) Keep(rev int64) map[Revision]struct{} {
218+
available := make(map[Revision]struct{})
219219
ti.RLock()
220220
defer ti.RUnlock()
221221
ti.tree.Ascend(func(keyi *keyIndex) bool {

‎server/storage/mvcc/index_bench_test.go

+3-3
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ func benchmarkIndexCompact(b *testing.B, size int) {
3333
bytesN := 64
3434
keys := createBytesSlice(bytesN, size)
3535
for i := 1; i < size; i++ {
36-
kvindex.Put(keys[i], revision{main: int64(i), sub: int64(i)})
36+
kvindex.Put(keys[i], Revision{Main: int64(i), Sub: int64(i)})
3737
}
3838
b.ResetTimer()
3939
for i := 1; i < b.N; i++ {
@@ -49,7 +49,7 @@ func BenchmarkIndexPut(b *testing.B) {
4949
keys := createBytesSlice(bytesN, b.N)
5050
b.ResetTimer()
5151
for i := 1; i < b.N; i++ {
52-
kvindex.Put(keys[i], revision{main: int64(i), sub: int64(i)})
52+
kvindex.Put(keys[i], Revision{Main: int64(i), Sub: int64(i)})
5353
}
5454
}
5555

@@ -60,7 +60,7 @@ func BenchmarkIndexGet(b *testing.B) {
6060
bytesN := 64
6161
keys := createBytesSlice(bytesN, b.N)
6262
for i := 1; i < b.N; i++ {
63-
kvindex.Put(keys[i], revision{main: int64(i), sub: int64(i)})
63+
kvindex.Put(keys[i], Revision{Main: int64(i), Sub: int64(i)})
6464
}
6565
b.ResetTimer()
6666
for i := 1; i < b.N; i++ {

0 commit comments

Comments
 (0)