func TestLocalSenderLookupReplica(t *testing.T) {
defer leaktest.AfterTest(t)
stopper := stop.NewStopper()
defer stopper.Stop()
ctx := storage.TestStoreContext
manualClock := hlc.NewManualClock(0)
ctx.Clock = hlc.NewClock(manualClock.UnixNano)
ls := NewLocalSender()
// Create two new stores with ranges we care about.
var e [2]engine.Engine
var s [2]*storage.Store
ranges := []struct {
storeID proto.StoreID
start, end proto.Key
}{
{2, proto.Key("a"), proto.Key("c")},
{3, proto.Key("x"), proto.Key("z")},
}
for i, rng := range ranges {
e[i] = engine.NewInMem(proto.Attributes{}, 1<<20)
ctx.Transport = multiraft.NewLocalRPCTransport(stopper)
defer ctx.Transport.Close()
s[i] = storage.NewStore(ctx, e[i], &proto.NodeDescriptor{NodeID: 1})
s[i].Ident.StoreID = rng.storeID
desc := &proto.RangeDescriptor{
RaftID: proto.RaftID(i),
StartKey: rng.start,
EndKey: rng.end,
Replicas: []proto.Replica{{StoreID: rng.storeID}},
}
newRng, err := storage.NewRange(desc, s[i])
if err != nil {
t.Fatal(err)
}
if err := s[i].AddRangeTest(newRng); err != nil {
t.Error(err)
}
ls.AddStore(s[i])
}
if _, r, err := ls.lookupReplica(proto.Key("a"), proto.Key("c")); r.StoreID != s[0].Ident.StoreID || err != nil {
t.Errorf("expected store %d; got %d: %v", s[0].Ident.StoreID, r.StoreID, err)
}
if _, r, err := ls.lookupReplica(proto.Key("b"), nil); r.StoreID != s[0].Ident.StoreID || err != nil {
t.Errorf("expected store %d; got %d: %v", s[0].Ident.StoreID, r.StoreID, err)
}
if _, r, err := ls.lookupReplica(proto.Key("b"), proto.Key("d")); r != nil || err == nil {
t.Errorf("expected store 0 and error got %d", r.StoreID)
}
if _, r, err := ls.lookupReplica(proto.Key("x"), proto.Key("z")); r.StoreID != s[1].Ident.StoreID {
t.Errorf("expected store %d; got %d: %v", s[1].Ident.StoreID, r.StoreID, err)
}
if _, r, err := ls.lookupReplica(proto.Key("y"), nil); r.StoreID != s[1].Ident.StoreID || err != nil {
t.Errorf("expected store %d; got %d: %v", s[1].Ident.StoreID, r.StoreID, err)
}
}
func startServer() *kvTestServer {
once.Do(func() {
meta := storage.RangeMetadata{
RangeID: 1,
StartKey: storage.KeyMin,
EndKey: storage.KeyMax,
}
server = &kvTestServer{}
server.db = NewLocalDB(storage.NewRange(meta, storage.NewInMem(1<<30), nil, nil))
server.rest = NewRESTServer(server.db)
server.httpServer = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
server.rest.HandleAction(w, r)
}))
})
return server
}
func splitTestRange(store *storage.Store, key, splitKey proto.Key, t *testing.T) *storage.Range {
rng := store.LookupRange(key, key)
if rng == nil {
t.Fatalf("couldn't lookup range for key %q", key)
}
desc, err := store.NewRangeDescriptor(splitKey, rng.Desc().EndKey, rng.Desc().Replicas)
if err != nil {
t.Fatal(err)
}
newRng, err := storage.NewRange(desc, store)
if err != nil {
t.Fatal(err)
}
if err := store.SplitRange(rng, newRng); err != nil {
t.Fatal(err)
}
return newRng
}
func TestLocalSenderLookupReplica(t *testing.T) {
manualClock := hlc.NewManualClock(0)
clock := hlc.NewClock(manualClock.UnixNano)
eng := engine.NewInMem(proto.Attributes{}, 1<<20)
ls := NewLocalSender()
db := client.NewKV(NewTxnCoordSender(ls, clock, false), nil)
transport := multiraft.NewLocalRPCTransport()
defer transport.Close()
store := storage.NewStore(clock, eng, db, nil, transport)
if err := store.Bootstrap(proto.StoreIdent{NodeID: 1, StoreID: 1}); err != nil {
t.Fatal(err)
}
ls.AddStore(store)
if err := store.BootstrapRange(); err != nil {
t.Fatal(err)
}
if err := store.Start(); err != nil {
t.Fatal(err)
}
defer store.Stop()
rng := splitTestRange(store, engine.KeyMin, proto.Key("a"), t)
if err := store.RemoveRange(rng); err != nil {
t.Fatal(err)
}
// Create two new stores with ranges we care about.
var e [2]engine.Engine
var s [2]*storage.Store
ranges := []struct {
storeID proto.StoreID
start, end proto.Key
}{
{2, proto.Key("a"), proto.Key("c")},
{3, proto.Key("x"), proto.Key("z")},
}
for i, rng := range ranges {
e[i] = engine.NewInMem(proto.Attributes{}, 1<<20)
transport := multiraft.NewLocalRPCTransport()
defer transport.Close()
s[i] = storage.NewStore(clock, e[i], db, nil, transport)
s[i].Ident.StoreID = rng.storeID
if err := s[i].Bootstrap(proto.StoreIdent{NodeID: 1, StoreID: rng.storeID}); err != nil {
t.Fatal(err)
}
if err := s[i].Start(); err != nil {
t.Fatal(err)
}
defer s[i].Stop()
desc, err := store.NewRangeDescriptor(rng.start, rng.end, []proto.Replica{{StoreID: rng.storeID}})
if err != nil {
t.Fatal(err)
}
newRng, err := storage.NewRange(desc, s[i])
if err != nil {
t.Fatal(err)
}
if err := s[i].AddRange(newRng); err != nil {
t.Error(err)
}
ls.AddStore(s[i])
}
if _, r, err := ls.lookupReplica(proto.Key("a"), proto.Key("c")); r.StoreID != s[0].Ident.StoreID || err != nil {
t.Errorf("expected store %d; got %d: %v", s[0].Ident.StoreID, r.StoreID, err)
}
if _, r, err := ls.lookupReplica(proto.Key("b"), nil); r.StoreID != s[0].Ident.StoreID || err != nil {
t.Errorf("expected store %d; got %d: %v", s[0].Ident.StoreID, r.StoreID, err)
}
if _, r, err := ls.lookupReplica(proto.Key("b"), proto.Key("d")); r != nil || err == nil {
t.Errorf("expected store 0 and error got %d", r.StoreID)
}
if _, r, err := ls.lookupReplica(proto.Key("x"), proto.Key("z")); r.StoreID != s[1].Ident.StoreID {
t.Errorf("expected store %d; got %d: %v", s[1].Ident.StoreID, r.StoreID, err)
}
if _, r, err := ls.lookupReplica(proto.Key("y"), nil); r.StoreID != s[1].Ident.StoreID || err != nil {
t.Errorf("expected store %d; got %d: %v", s[1].Ident.StoreID, r.StoreID, err)
}
}
