func (s *store) put(key, value []byte) { rev := s.currentRev.main + 1 c := rev // if the key exists before, use its previous created _, created, ver, err := s.kvindex.Get(key, rev) if err == nil { c = created.main } ibytes := newRevBytes() revToBytes(revision{main: rev, sub: s.currentRev.sub}, ibytes) ver = ver + 1 kv := storagepb.KeyValue{ Key: key, Value: value, CreateRevision: c, ModRevision: rev, Version: ver, } d, err := kv.Marshal() if err != nil { log.Fatalf("storage: cannot marshal event: %v", err) } s.tx.UnsafePut(keyBucketName, ibytes, d) s.kvindex.Put(key, revision{main: rev, sub: s.currentRev.sub}) s.currentRev.sub += 1 }
func (s *store) delete(key []byte) { mainrev := s.currentRev.main + 1 ibytes := newRevBytes() revToBytes(revision{main: mainrev, sub: s.currentRev.sub}, ibytes) ibytes = appendMarkTombstone(ibytes) kv := storagepb.KeyValue{ Key: key, } d, err := kv.Marshal() if err != nil { log.Fatalf("storage: cannot marshal event: %v", err) } s.tx.UnsafePut(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) } s.currentRev.sub += 1 // TODO: De-attach keys from lease if necessary }
func TestStoreRestore(t *testing.T) { s := newFakeStore() b := s.b.(*fakeBackend) fi := s.kvindex.(*fakeIndex) putkey := newTestKeyBytes(revision{3, 0}, false) putkv := storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 3, ModRevision: 3, Version: 1, } putkvb, err := putkv.Marshal() if err != nil { t.Fatal(err) } delkey := newTestKeyBytes(revision{4, 0}, true) delkv := storagepb.KeyValue{ Key: []byte("foo"), } delkvb, err := delkv.Marshal() if err != nil { t.Fatal(err) } b.tx.rangeRespc <- rangeResp{[][]byte{finishedCompactKeyName}, [][]byte{newTestRevBytes(revision{2, 0})}} b.tx.rangeRespc <- rangeResp{[][]byte{putkey, delkey}, [][]byte{putkvb, delkvb}} b.tx.rangeRespc <- rangeResp{[][]byte{scheduledCompactKeyName}, [][]byte{newTestRevBytes(revision{2, 0})}} s.Restore() if s.compactMainRev != 2 { t.Errorf("compact rev = %d, want 4", s.compactMainRev) } wrev := revision{4, 0} if !reflect.DeepEqual(s.currentRev, wrev) { t.Errorf("current rev = %v, want %v", s.currentRev, wrev) } wact := []testutil.Action{ {"range", []interface{}{metaBucketName, finishedCompactKeyName, []byte(nil), int64(0)}}, {"range", []interface{}{keyBucketName, newTestRevBytes(revision{}), newTestRevBytes(revision{math.MaxInt64, math.MaxInt64}), int64(0)}}, {"range", []interface{}{metaBucketName, scheduledCompactKeyName, []byte(nil), int64(0)}}, } if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("tx actions = %+v, want %+v", g, wact) } wact = []testutil.Action{ {"restore", []interface{}{[]byte("foo"), revision{3, 0}, revision{3, 0}, int64(1)}}, {"tombstone", []interface{}{[]byte("foo"), revision{4, 0}}}, } if g := fi.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("index action = %+v, want %+v", g, wact) } }
func (s *store) put(key, value []byte, leaseID lease.LeaseID) { rev := s.currentRev.main + 1 c := rev // if the key exists before, use its previous created _, created, ver, err := s.kvindex.Get(key, rev) if err == nil { c = created.main } ibytes := newRevBytes() revToBytes(revision{main: rev, sub: s.currentRev.sub}, ibytes) ver = ver + 1 kv := storagepb.KeyValue{ Key: key, Value: value, CreateRevision: c, ModRevision: rev, Version: ver, Lease: int64(leaseID), } d, err := kv.Marshal() if err != nil { log.Fatalf("storage: cannot marshal event: %v", err) } s.tx.UnsafePut(keyBucketName, ibytes, d) s.kvindex.Put(key, revision{main: rev, sub: s.currentRev.sub}) s.changes = append(s.changes, kv) s.currentRev.sub += 1 if leaseID != lease.NoLease { if s.le == nil { panic("no lessor to attach lease") } // TODO: validate the existence of lease before call Attach. // We need to ensure put always successful since we do not want // to handle abortion for txn request. We need to ensure all requests // inside the txn can execute without error before executing them. err = s.le.Attach(leaseID, []lease.LeaseItem{{Key: string(key)}}) if err != nil { panic("unexpected error from lease Attach") } } }
func (s *store) delete(key []byte, rev revision) { mainrev := s.currentRev.main + 1 ibytes := newRevBytes() revToBytes(revision{main: mainrev, sub: s.currentRev.sub}, ibytes) ibytes = appendMarkTombstone(ibytes) kv := storagepb.KeyValue{ Key: key, } d, err := kv.Marshal() if err != nil { log.Fatalf("storage: cannot marshal event: %v", err) } s.tx.UnsafePut(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) } s.changes = append(s.changes, kv) s.currentRev.sub += 1 ibytes = newRevBytes() revToBytes(rev, ibytes) _, vs := s.tx.UnsafeRange(keyBucketName, ibytes, nil, 0) kv.Reset() if err = kv.Unmarshal(vs[0]); err != nil { log.Fatalf("storage: 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) } } }
func TestStoreRange(t *testing.T) { key := newTestKeyBytes(revision{2, 0}, false) kv := storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 1, ModRevision: 2, Version: 1, } kvb, err := kv.Marshal() if err != nil { t.Fatal(err) } currev := revision{1, 1} wrev := int64(2) tests := []struct { idxr indexRangeResp r rangeResp }{ { indexRangeResp{[][]byte{[]byte("foo")}, []revision{{2, 0}}}, rangeResp{[][]byte{key}, [][]byte{kvb}}, }, { indexRangeResp{[][]byte{[]byte("foo"), []byte("foo1")}, []revision{{2, 0}, {3, 0}}}, rangeResp{[][]byte{key}, [][]byte{kvb}}, }, } for i, tt := range tests { s := newFakeStore() b := s.b.(*fakeBackend) fi := s.kvindex.(*fakeIndex) s.currentRev = currev s.tx = b.BatchTx() b.tx.rangeRespc <- tt.r fi.indexRangeRespc <- tt.idxr kvs, rev, err := s.rangeKeys([]byte("foo"), []byte("goo"), 1, 0) if err != nil { t.Errorf("#%d: err = %v, want nil", i, err) } if w := []storagepb.KeyValue{kv}; !reflect.DeepEqual(kvs, w) { t.Errorf("#%d: kvs = %+v, want %+v", i, kvs, w) } if rev != wrev { t.Errorf("#%d: rev = %d, want %d", i, rev, wrev) } wstart, wend := revBytesRange(tt.idxr.revs[0]) wact := []testutil.Action{ {"range", []interface{}{keyBucketName, wstart, wend, int64(0)}}, } if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact) } wact = []testutil.Action{ {"range", []interface{}{[]byte("foo"), []byte("goo"), wrev}}, } if g := fi.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) } if s.currentRev != currev { t.Errorf("#%d: current rev = %+v, want %+v", i, s.currentRev, currev) } } }
func (s *store) put(key, value []byte, leaseID lease.LeaseID) { rev := s.currentRev.main + 1 c := rev oldLease := lease.NoLease // if the key exists before, use its previous created and // get its previous leaseID grev, created, ver, err := s.kvindex.Get(key, rev) if err == nil { c = created.main ibytes := newRevBytes() revToBytes(grev, ibytes) _, vs := s.tx.UnsafeRange(keyBucketName, ibytes, nil, 0) var kv storagepb.KeyValue if err = kv.Unmarshal(vs[0]); err != nil { log.Fatalf("storage: cannot unmarshal value: %v", err) } oldLease = lease.LeaseID(kv.Lease) } ibytes := newRevBytes() revToBytes(revision{main: rev, sub: s.currentRev.sub}, ibytes) ver = ver + 1 kv := storagepb.KeyValue{ Key: key, Value: value, CreateRevision: c, ModRevision: rev, Version: ver, Lease: int64(leaseID), } d, err := kv.Marshal() if err != nil { log.Fatalf("storage: cannot marshal event: %v", err) } s.tx.UnsafePut(keyBucketName, ibytes, d) s.kvindex.Put(key, revision{main: rev, sub: s.currentRev.sub}) s.changes = append(s.changes, kv) s.currentRev.sub += 1 if oldLease != lease.NoLease { if s.le == nil { panic("no lessor to detach lease") } err = s.le.Detach(oldLease, []lease.LeaseItem{{Key: string(key)}}) if err != nil { panic("unexpected error from lease detach") } } if leaseID != lease.NoLease { if s.le == nil { panic("no lessor to attach lease") } err = s.le.Attach(leaseID, []lease.LeaseItem{{Key: string(key)}}) if err != nil { panic("unexpected error from lease Attach") } } }
func TestStorePut(t *testing.T) { kv := storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 1, ModRevision: 2, Version: 1, } kvb, err := kv.Marshal() if err != nil { t.Fatal(err) } tests := []struct { rev revision r indexGetResp rr *rangeResp wrev revision wkey []byte wkv storagepb.KeyValue wputrev revision }{ { revision{1, 0}, indexGetResp{revision{}, revision{}, 0, ErrRevisionNotFound}, nil, revision{1, 1}, newTestKeyBytes(revision{2, 0}, false), storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 1, Lease: 1, }, revision{2, 0}, }, { revision{1, 1}, indexGetResp{revision{2, 0}, revision{2, 0}, 1, nil}, &rangeResp{[][]byte{newTestKeyBytes(revision{2, 1}, false)}, [][]byte{kvb}}, revision{1, 2}, newTestKeyBytes(revision{2, 1}, false), storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 2, Version: 2, Lease: 2, }, revision{2, 1}, }, { revision{2, 0}, indexGetResp{revision{2, 1}, revision{2, 0}, 2, nil}, &rangeResp{[][]byte{newTestKeyBytes(revision{2, 1}, false)}, [][]byte{kvb}}, revision{2, 1}, newTestKeyBytes(revision{3, 0}, false), storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 2, ModRevision: 3, Version: 3, Lease: 3, }, revision{3, 0}, }, } for i, tt := range tests { s := newFakeStore() b := s.b.(*fakeBackend) fi := s.kvindex.(*fakeIndex) s.currentRev = tt.rev s.tx = b.BatchTx() fi.indexGetRespc <- tt.r if tt.rr != nil { b.tx.rangeRespc <- *tt.rr } s.put([]byte("foo"), []byte("bar"), lease.LeaseID(i+1)) data, err := tt.wkv.Marshal() if err != nil { t.Errorf("#%d: marshal err = %v, want nil", i, err) } wact := []testutil.Action{ {"seqput", []interface{}{keyBucketName, tt.wkey, data}}, } if tt.rr != nil { wact = []testutil.Action{ {"range", []interface{}{keyBucketName, newTestKeyBytes(tt.r.rev, false), []byte(nil), int64(0)}}, {"seqput", []interface{}{keyBucketName, tt.wkey, data}}, } } if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact) } wact = []testutil.Action{ {"get", []interface{}{[]byte("foo"), tt.wputrev.main}}, {"put", []interface{}{[]byte("foo"), tt.wputrev}}, } if g := fi.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) } if s.currentRev != tt.wrev { t.Errorf("#%d: rev = %+v, want %+v", i, s.currentRev, tt.wrev) } s.Close() } }
func TestStoreDeleteRange(t *testing.T) { key := newTestKeyBytes(revision{2, 0}, false) kv := storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 1, ModRevision: 2, Version: 1, } kvb, err := kv.Marshal() if err != nil { t.Fatal(err) } tests := []struct { rev revision r indexRangeResp rr rangeResp wkey []byte wrev revision wrrev int64 wdelrev revision }{ { revision{2, 0}, indexRangeResp{[][]byte{[]byte("foo")}, []revision{{2, 0}}}, rangeResp{[][]byte{key}, [][]byte{kvb}}, newTestKeyBytes(revision{3, 0}, true), revision{2, 1}, 2, revision{3, 0}, }, { revision{2, 1}, indexRangeResp{[][]byte{[]byte("foo")}, []revision{{2, 0}}}, rangeResp{[][]byte{key}, [][]byte{kvb}}, newTestKeyBytes(revision{3, 1}, true), revision{2, 2}, 3, revision{3, 1}, }, } for i, tt := range tests { s := newFakeStore() b := s.b.(*fakeBackend) fi := s.kvindex.(*fakeIndex) s.currentRev = tt.rev s.tx = b.BatchTx() fi.indexRangeRespc <- tt.r b.tx.rangeRespc <- tt.rr n := s.deleteRange([]byte("foo"), []byte("goo")) if n != 1 { t.Errorf("#%d: n = %d, want 1", i, n) } data, err := (&storagepb.KeyValue{ Key: []byte("foo"), }).Marshal() if err != nil { t.Errorf("#%d: marshal err = %v, want nil", i, err) } wact := []testutil.Action{ {"seqput", []interface{}{keyBucketName, tt.wkey, data}}, {"range", []interface{}{keyBucketName, newTestKeyBytes(revision{2, 0}, false), []byte(nil), int64(0)}}, } if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact) } wact = []testutil.Action{ {"range", []interface{}{[]byte("foo"), []byte("goo"), tt.wrrev}}, {"tombstone", []interface{}{[]byte("foo"), tt.wdelrev}}, } if g := fi.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) } if s.currentRev != tt.wrev { t.Errorf("#%d: rev = %+v, want %+v", i, s.currentRev, tt.wrev) } } }
func TestStoreRangeHistory(t *testing.T) { key := newTestKeyBytes(revision{2, 0}, false) kv := storagepb.KeyValue{ Key: []byte("foo"), Value: []byte("bar"), CreateRevision: 1, ModRevision: 2, Version: 1, } kvb, err := kv.Marshal() if err != nil { t.Fatal(err) } currev := revision{2, 0} tests := []struct { idxr indexRangeEventsResp r rangeResp }{ { indexRangeEventsResp{[]revision{{2, 0}}}, rangeResp{[][]byte{key}, [][]byte{kvb}}, }, { indexRangeEventsResp{[]revision{{2, 0}, {3, 0}}}, rangeResp{[][]byte{key}, [][]byte{kvb}}, }, } for i, tt := range tests { s, b, index := newFakeStore() s.currentRev = currev index.indexRangeEventsRespc <- tt.idxr b.tx.rangeRespc <- tt.r keys, kvs, _, err := s.RangeHistory([]byte("foo"), []byte("goo"), 1, 1) if err != nil { t.Errorf("#%d: err = %v, want nil", i, err) } if w := [][]byte{key}; !reflect.DeepEqual(keys, w) { t.Errorf("#%d: keys = %+v, want %+v", i, keys, w) } if w := []storagepb.KeyValue{kv}; !reflect.DeepEqual(kvs, w) { t.Errorf("#%d: kvs = %+v, want %+v", i, kvs, w) } wact := []testutil.Action{ {"rangeEvents", []interface{}{[]byte("foo"), []byte("goo"), int64(1)}}, } if g := index.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) } wstart, wend := revBytesRange(tt.idxr.revs[0]) wact = []testutil.Action{ {"range", []interface{}{keyBucketName, wstart, wend, int64(0)}}, } if g := b.tx.Action(); !reflect.DeepEqual(g, wact) { t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact) } if s.currentRev != currev { t.Errorf("#%d: current rev = %+v, want %+v", i, s.currentRev, currev) } } }