func TestWatchSrvKeyspaceCancel(t *testing.T) {
cell := "cell1"
keyspace := "ks1"
ctx := context.Background()
mt := memorytopo.NewMemoryTopo([]string{"global", cell})
ts := topo.Server{Impl: mt}
// No SrvKeyspace -> ErrNoNode
current, changes, cancel := ts.WatchSrvKeyspace(ctx, cell, keyspace)
if current.Err != topo.ErrNoNode {
t.Errorf("Got invalid result from WatchSrvKeyspace(not there): %v", current.Err)
}
// Create initial value
wanted := &topodatapb.SrvKeyspace{
ShardingColumnName: "scn2",
}
contents, err := proto.Marshal(wanted)
if err != nil {
t.Fatalf("proto.Marshal(wanted) failed: %v", err)
}
if _, err := mt.Create(ctx, cell, "/keyspaces/"+keyspace+"/SrvKeyspace", contents); err != nil {
t.Fatalf("Update(/keyspaces/ks1/SrvKeyspace) failed: %v", err)
}
// Starting the watch should now work.
current, changes, cancel = waitForInitialSrvKeyspace(t, ts, cell, keyspace)
if !proto.Equal(current.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", current.Value, wanted)
}
// Cancel watch, wait for error.
cancel()
for {
wd, ok := <-changes
if !ok {
t.Fatalf("watch channel unexpectedly closed")
}
if wd.Err == topo.ErrInterrupted {
break
}
if wd.Err != nil {
t.Fatalf("watch channel unexpectedly got unknown error: %v", wd.Err)
}
if !proto.Equal(wd.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", wd.Value, wanted)
}
t.Log("got duplicate right value, skipping.")
}
// Cancel should still work here, although it does nothing.
cancel()
}
func TestWatchSrvKeyspaceNoNode(t *testing.T) {
cell := "cell1"
keyspace := "ks1"
ctx := context.Background()
mt := memorytopo.NewMemoryTopo([]string{"global", cell})
ts := topo.Server{Impl: mt}
// No SrvKeyspace -> ErrNoNode
current, _, _ := ts.WatchSrvKeyspace(ctx, cell, keyspace)
if current.Err != topo.ErrNoNode {
t.Errorf("Got invalid result from WatchSrvKeyspace(not there): %v", current.Err)
}
}
// waitForInitialSrvKeyspace waits for the initial SrvKeyspace to
// appear, and match the provided srvKeyspace.
func waitForInitialSrvKeyspace(t *testing.T, ts topo.Server, cell, keyspace string) (current *topo.WatchSrvKeyspaceData, changes <-chan *topo.WatchSrvKeyspaceData, cancel topo.CancelFunc) {
ctx := context.Background()
start := time.Now()
for {
current, changes, cancel = ts.WatchSrvKeyspace(ctx, cell, keyspace)
switch current.Err {
case topo.ErrNoNode:
// hasn't appeared yet
if time.Now().Sub(start) > 10*time.Second {
t.Fatalf("time out waiting for file to appear")
}
time.Sleep(10 * time.Millisecond)
continue
case nil:
return
default:
t.Fatalf("watch failed: %v", current.Err)
}
}
}
func TestWatchSrvKeyspace(t *testing.T) {
cell := "cell1"
keyspace := "ks1"
ctx := context.Background()
mt := memorytopo.NewMemoryTopo([]string{"global", cell})
ts := topo.Server{Impl: mt}
// Create initial value
if _, err := mt.Create(ctx, cell, "/keyspaces/"+keyspace+"/SrvKeyspace", []byte{}); err != nil {
t.Fatalf("Update(/keyspaces/ks1/SrvKeyspace) failed: %v", err)
}
// Starting the watch should now work, and return an empty
// SrvKeyspace.
wanted := &topodatapb.SrvKeyspace{}
current, changes, cancel := waitForInitialSrvKeyspace(t, ts, cell, keyspace)
if !proto.Equal(current.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", current.Value, wanted)
}
// Update the value with good data, wait until we see it
wanted.ShardingColumnName = "scn1"
contents, err := proto.Marshal(wanted)
if err != nil {
t.Fatalf("proto.Marshal(wanted) failed: %v", err)
}
if _, err := mt.Update(ctx, cell, "/keyspaces/"+keyspace+"/SrvKeyspace", contents, nil); err != nil {
t.Fatalf("Update(/keyspaces/ks1/SrvKeyspace) failed: %v", err)
}
for {
wd, ok := <-changes
if !ok {
t.Fatalf("watch channel unexpectedly closed")
}
if wd.Err != nil {
t.Fatalf("watch channel unexpectedly got error: %v", wd.Err)
}
if proto.Equal(wd.Value, wanted) {
break
}
if proto.Equal(wd.Value, &topodatapb.SrvKeyspace{}) {
t.Log("got duplicate empty value, skipping.")
}
t.Fatalf("got bad data: %v expected: %v", wd.Value, wanted)
}
// Update the value with bad data, wait until error.
if _, err := mt.Update(ctx, cell, "/keyspaces/"+keyspace+"/SrvKeyspace", []byte("BAD PROTO DATA"), nil); err != nil {
t.Fatalf("Update(/keyspaces/ks1/SrvKeyspace) failed: %v", err)
}
for {
wd, ok := <-changes
if !ok {
t.Fatalf("watch channel unexpectedly closed")
}
if wd.Err != nil {
if strings.Contains(wd.Err.Error(), "error unpacking SrvKeyspace object") {
break
}
t.Fatalf("watch channel unexpectedly got unknown error: %v", wd.Err)
}
if !proto.Equal(wd.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", wd.Value, wanted)
}
t.Log("got duplicate right value, skipping.")
}
// Cancel should still work here, although it does nothing.
cancel()
// Bad data in topo, setting the watch should now fail.
current, changes, cancel = ts.WatchSrvKeyspace(ctx, cell, keyspace)
if current.Err == nil || !strings.Contains(current.Err.Error(), "error unpacking initial SrvKeyspace object") {
t.Fatalf("expected an initial error setting watch on bad content, but got: %v", current.Err)
}
// Update content, wait until Watch works again
if _, err := mt.Update(ctx, cell, "/keyspaces/"+keyspace+"/SrvKeyspace", contents, nil); err != nil {
t.Fatalf("Update(/keyspaces/ks1/SrvKeyspace) failed: %v", err)
}
start := time.Now()
for {
current, changes, cancel = ts.WatchSrvKeyspace(ctx, cell, keyspace)
if current.Err != nil {
if strings.Contains(current.Err.Error(), "error unpacking initial SrvKeyspace object") {
// hasn't changed yet
if time.Now().Sub(start) > 10*time.Second {
t.Fatalf("time out waiting for file to appear")
}
time.Sleep(10 * time.Millisecond)
continue
}
t.Fatalf("got unexpected error while setting watch: %v", err)
}
if !proto.Equal(current.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", current.Value, wanted)
}
break
}
// Delete node, wait for error (skip any duplicate).
if err := mt.Delete(ctx, cell, "/keyspaces/"+keyspace+"/SrvKeyspace", nil); err != nil {
t.Fatalf("Delete(/keyspaces/ks1/SrvKeyspace) failed: %v", err)
}
for {
wd, ok := <-changes
if !ok {
t.Fatalf("watch channel unexpectedly closed")
}
if wd.Err == topo.ErrNoNode {
break
}
if wd.Err != nil {
t.Fatalf("watch channel unexpectedly got unknown error: %v", wd.Err)
}
if !proto.Equal(wd.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", wd.Value, wanted)
}
t.Log("got duplicate right value, skipping.")
}
}
// CheckWatchSrvKeyspace makes sure WatchSrvKeyspace works as expected
func CheckWatchSrvKeyspace(ctx context.Context, t *testing.T, ts topo.Server) {
cell := getLocalCell(ctx, t, ts)
keyspace := "test_keyspace"
// start watching, should get nil first
notifications, stopWatching, err := ts.WatchSrvKeyspace(ctx, cell, keyspace)
if err != nil {
t.Fatalf("WatchSrvKeyspace failed: %v", err)
}
sk, ok := <-notifications
if !ok || sk != nil {
t.Fatalf("first value is wrong: %v %v", sk, ok)
}
// update the SrvKeyspace, should get a notification
srvKeyspace := &topo.SrvKeyspace{
ShardingColumnName: "test_column",
Partitions: map[topo.TabletType]*topo.KeyspacePartition{
topo.TYPE_RDONLY: &topo.KeyspacePartition{
ShardReferences: []topo.ShardReference{
topo.ShardReference{
Name: "0",
},
},
},
},
ServedFrom: map[topo.TabletType]string{
topo.TYPE_MASTER: "other_keyspace",
},
}
if err := ts.UpdateSrvKeyspace(ctx, cell, keyspace, srvKeyspace); err != nil {
t.Fatalf("UpdateSrvKeyspace failed: %v", err)
}
for {
sk, ok := <-notifications
if !ok {
t.Fatalf("watch channel is closed???")
}
if sk == nil {
// duplicate notification of the first value, that's OK
continue
}
// non-empty value, that one should be ours
if !reflect.DeepEqual(sk, srvKeyspace) {
t.Fatalf("first value is wrong: got %v expected %v", sk, srvKeyspace)
}
break
}
// delete the SrvKeyspace, should get a notification
if err := ts.DeleteSrvKeyspace(ctx, cell, keyspace); err != nil {
t.Fatalf("DeleteSrvKeyspace failed: %v", err)
}
for {
sk, ok := <-notifications
if !ok {
t.Fatalf("watch channel is closed???")
}
if sk == nil {
break
}
// duplicate notification of the first value, that's OK,
// but value better be good.
if !reflect.DeepEqual(srvKeyspace, sk) {
t.Fatalf("duplicate notification value is bad: %v", sk)
}
}
// re-create the value, a bit different, should get a notification
srvKeyspace.SplitShardCount = 2
if err := ts.UpdateSrvKeyspace(ctx, cell, keyspace, srvKeyspace); err != nil {
t.Fatalf("UpdateSrvKeyspace failed: %v", err)
}
for {
sk, ok := <-notifications
if !ok {
t.Fatalf("watch channel is closed???")
}
if sk == nil {
// duplicate notification of the closed value, that's OK
continue
}
// non-empty value, that one should be ours
if !reflect.DeepEqual(srvKeyspace, sk) {
t.Fatalf("value after delete / re-create is wrong: %v %v", sk, ok)
}
break
}
// close the stopWatching channel, should eventually get a closed
// notifications channel too
close(stopWatching)
for {
sk, ok := <-notifications
if !ok {
break
}
if !reflect.DeepEqual(srvKeyspace, sk) {
t.Fatalf("duplicate notification value is bad: %v", sk)
}
}
}
