// CopyKeyspaces will create the keyspaces in the destination topo
func CopyKeyspaces(ctx context.Context, fromTS, toTS topo.Impl) {
keyspaces, err := fromTS.GetKeyspaces(ctx)
if err != nil {
log.Fatalf("GetKeyspaces: %v", err)
}
wg := sync.WaitGroup{}
rec := concurrency.AllErrorRecorder{}
for _, keyspace := range keyspaces {
wg.Add(1)
go func(keyspace string) {
defer wg.Done()
k, _, err := fromTS.GetKeyspace(ctx, keyspace)
if err != nil {
rec.RecordError(fmt.Errorf("GetKeyspace(%v): %v", keyspace, err))
return
}
if err := toTS.CreateKeyspace(ctx, keyspace, k); err != nil {
if err == topo.ErrNodeExists {
log.Warningf("keyspace %v already exists", keyspace)
} else {
rec.RecordError(fmt.Errorf("CreateKeyspace(%v): %v", keyspace, err))
}
}
}(keyspace)
}
wg.Wait()
if rec.HasErrors() {
log.Fatalf("copyKeyspaces failed: %v", rec.Error())
}
}
// CheckKeyspaceLock checks we can take a keyspace lock as expected.
func CheckKeyspaceLock(ctx context.Context, t *testing.T, ts topo.Impl) {
if err := ts.CreateKeyspace(ctx, "test_keyspace", &pb.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
checkKeyspaceLockTimeout(ctx, t, ts)
checkKeyspaceLockMissing(ctx, t, ts)
checkKeyspaceLockUnblocks(ctx, t, ts)
}
// CheckShardLock checks we can take a shard lock
func CheckShardLock(ctx context.Context, t *testing.T, ts topo.Impl) {
if err := ts.CreateKeyspace(ctx, "test_keyspace", &pb.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
if err := ts.CreateShard(ctx, "test_keyspace", "10-20", &pb.Shard{
KeyRange: newKeyRange3("10-20"),
}); err != nil {
t.Fatalf("CreateShard: %v", err)
}
checkShardLockTimeout(ctx, t, ts)
checkShardLockMissing(ctx, t, ts)
checkShardLockUnblocks(ctx, t, ts)
}
// checkKeyspaceLock checks we can take a keyspace lock as expected.
func checkKeyspaceLock(t *testing.T, ts topo.Impl) {
ctx := context.Background()
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
t.Log("=== checkKeyspaceLockTimeout")
checkKeyspaceLockTimeout(ctx, t, ts)
t.Log("=== checkKeyspaceLockMissing")
checkKeyspaceLockMissing(ctx, t, ts)
t.Log("=== checkKeyspaceLockUnblocks")
checkKeyspaceLockUnblocks(ctx, t, ts)
}
// checkShardLock checks we can take a shard lock
func checkShardLock(t *testing.T, ts topo.Impl) {
ctx := context.Background()
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
if err := ts.CreateShard(ctx, "test_keyspace", "10-20", &topodatapb.Shard{
KeyRange: newKeyRange("10-20"),
}); err != nil {
t.Fatalf("CreateShard: %v", err)
}
t.Log("=== checkShardLockTimeout")
checkShardLockTimeout(ctx, t, ts)
t.Log("=== checkShardLockMissing")
checkShardLockMissing(ctx, t, ts)
t.Log("=== checkShardLockUnblocks")
checkShardLockUnblocks(ctx, t, ts)
}
// checkShard verifies the Shard operations work correctly
func checkShard(t *testing.T, ts topo.Impl) {
ctx := context.Background()
tts := topo.Server{Impl: ts}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
shard := &topodatapb.Shard{
KeyRange: newKeyRange("b0-c0"),
}
if err := ts.CreateShard(ctx, "test_keyspace", "b0-c0", shard); err != nil {
t.Fatalf("CreateShard: %v", err)
}
if err := ts.CreateShard(ctx, "test_keyspace", "b0-c0", shard); err != topo.ErrNodeExists {
t.Errorf("CreateShard called second time, got: %v", err)
}
// Delete shard and see if we can re-create it.
if err := ts.DeleteShard(ctx, "test_keyspace", "b0-c0"); err != nil {
t.Fatalf("DeleteShard: %v", err)
}
if err := ts.CreateShard(ctx, "test_keyspace", "b0-c0", shard); err != nil {
t.Fatalf("CreateShard: %v", err)
}
// Delete ALL shards.
if err := ts.DeleteKeyspaceShards(ctx, "test_keyspace"); err != nil {
t.Fatalf("DeleteKeyspaceShards: %v", err)
}
if err := ts.CreateShard(ctx, "test_keyspace", "b0-c0", shard); err != nil {
t.Fatalf("CreateShard: %v", err)
}
if _, _, err := ts.GetShard(ctx, "test_keyspace", "666"); err != topo.ErrNoNode {
t.Errorf("GetShard(666): %v", err)
}
shard, version, err := ts.GetShard(ctx, "test_keyspace", "b0-c0")
if err != nil {
t.Errorf("GetShard: %v", err)
}
if want := newKeyRange("b0-c0"); !key.KeyRangeEqual(shard.KeyRange, want) {
t.Errorf("shard.KeyRange: want %v, got %v", want, shard.KeyRange)
}
master := &topodatapb.TabletAlias{Cell: "ny", Uid: 1}
shard.MasterAlias = master
shard.KeyRange = newKeyRange("b0-c0")
shard.ServedTypes = []*topodatapb.Shard_ServedType{
{
TabletType: topodatapb.TabletType_MASTER,
},
{
TabletType: topodatapb.TabletType_REPLICA,
Cells: []string{"c1"},
},
{
TabletType: topodatapb.TabletType_RDONLY,
},
}
shard.SourceShards = []*topodatapb.Shard_SourceShard{
{
Uid: 1,
Keyspace: "source_ks",
Shard: "b8-c0",
KeyRange: newKeyRange("b8-c0"),
Tables: []string{"table1", "table2"},
},
}
shard.TabletControls = []*topodatapb.Shard_TabletControl{
{
TabletType: topodatapb.TabletType_MASTER,
Cells: []string{"c1", "c2"},
BlacklistedTables: []string{"black1", "black2"},
},
{
TabletType: topodatapb.TabletType_REPLICA,
DisableQueryService: true,
},
}
if _, err := ts.UpdateShard(ctx, "test_keyspace", "b0-c0", shard, version); err != nil {
t.Errorf("UpdateShard: %v", err)
}
other := &topodatapb.TabletAlias{Cell: "ny", Uid: 82873}
_, err = tts.UpdateShardFields(ctx, "test_keyspace", "b0-c0", func(si *topo.ShardInfo) error {
si.MasterAlias = other
return nil
})
if err != nil {
t.Fatalf("UpdateShardFields error: %v", err)
}
s, _, err := ts.GetShard(ctx, "test_keyspace", "b0-c0")
if err != nil {
t.Fatalf("GetShard: %v", err)
}
if *s.MasterAlias != *other {
t.Fatalf("shard.MasterAlias = %v, want %v", s.MasterAlias, other)
}
// unconditional shard update
_, err = ts.UpdateShard(ctx, "test_keyspace", "b0-c0", shard, -1)
if err != nil {
t.Fatalf("UpdateShard(-1) error: %v", err)
}
updatedShard, _, err := ts.GetShard(ctx, "test_keyspace", "b0-c0")
if err != nil {
t.Fatalf("GetShard: %v", err)
}
if eq, err := shardEqual(shard, updatedShard); err != nil {
t.Errorf("cannot compare shards: %v", err)
} else if !eq {
t.Errorf("put and got shards are not identical:\n%#v\n%#v", shard, updatedShard)
}
// test GetShardNames
shards, err := ts.GetShardNames(ctx, "test_keyspace")
if err != nil {
t.Errorf("GetShardNames: %v", err)
}
if len(shards) != 1 || shards[0] != "b0-c0" {
t.Errorf(`GetShardNames: want [ "b0-c0" ], got %v`, shards)
}
if _, err := ts.GetShardNames(ctx, "test_keyspace666"); err != topo.ErrNoNode {
t.Errorf("GetShardNames(666): %v", err)
}
// test ValidateShard
if err := ts.ValidateShard(ctx, "test_keyspace", "b0-c0"); err != nil {
t.Errorf("ValidateShard(test_keyspace, b0-c0) failed: %v", err)
}
}
// checkKeyspace tests the keyspace part of the API
func checkKeyspace(t *testing.T, ts topo.Impl) {
ctx := context.Background()
keyspaces, err := ts.GetKeyspaces(ctx)
if err != nil {
t.Errorf("GetKeyspaces(empty): %v", err)
}
if len(keyspaces) != 0 {
t.Errorf("len(GetKeyspaces()) != 0: %v", keyspaces)
}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != topo.ErrNodeExists {
t.Errorf("CreateKeyspace(again) is not ErrNodeExists: %v", err)
}
// Delete and re-create.
if err := ts.DeleteKeyspace(ctx, "test_keyspace"); err != nil {
t.Errorf("DeleteKeyspace: %v", err)
}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
keyspaces, err = ts.GetKeyspaces(ctx)
if err != nil {
t.Errorf("GetKeyspaces: %v", err)
}
if len(keyspaces) != 1 || keyspaces[0] != "test_keyspace" {
t.Errorf("GetKeyspaces: want %v, got %v", []string{"test_keyspace"}, keyspaces)
}
k := &topodatapb.Keyspace{
ShardingColumnName: "user_id",
ShardingColumnType: topodatapb.KeyspaceIdType_UINT64,
ServedFroms: []*topodatapb.Keyspace_ServedFrom{
{
TabletType: topodatapb.TabletType_REPLICA,
Cells: []string{"c1", "c2"},
Keyspace: "test_keyspace3",
},
{
TabletType: topodatapb.TabletType_MASTER,
Cells: nil,
Keyspace: "test_keyspace3",
},
},
}
if err := ts.CreateKeyspace(ctx, "test_keyspace2", k); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
keyspaces, err = ts.GetKeyspaces(ctx)
if err != nil {
t.Errorf("GetKeyspaces: %v", err)
}
if len(keyspaces) != 2 ||
keyspaces[0] != "test_keyspace" ||
keyspaces[1] != "test_keyspace2" {
t.Errorf("GetKeyspaces: want %v, got %v", []string{"test_keyspace", "test_keyspace2"}, keyspaces)
}
// re-read and update.
storedK, storedVersion, err := ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
storedK.ShardingColumnName = "other_id"
var newServedFroms []*topodatapb.Keyspace_ServedFrom
for _, ksf := range storedK.ServedFroms {
if ksf.TabletType == topodatapb.TabletType_MASTER {
continue
}
if ksf.TabletType == topodatapb.TabletType_REPLICA {
ksf.Keyspace = "test_keyspace4"
}
newServedFroms = append(newServedFroms, ksf)
}
storedK.ServedFroms = newServedFroms
_, err = ts.UpdateKeyspace(ctx, "test_keyspace2", storedK, storedVersion)
if err != nil {
t.Fatalf("UpdateKeyspace: %v", err)
}
// unconditional update
storedK.ShardingColumnType = topodatapb.KeyspaceIdType_BYTES
_, err = ts.UpdateKeyspace(ctx, "test_keyspace2", storedK, -1)
if err != nil {
t.Fatalf("UpdateKeyspace(-1): %v", err)
}
storedK, storedVersion, err = ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if storedK.ShardingColumnName != "other_id" ||
storedK.ShardingColumnType != topodatapb.KeyspaceIdType_BYTES ||
len(storedK.ServedFroms) != 1 ||
storedK.ServedFroms[0].TabletType != topodatapb.TabletType_REPLICA ||
storedK.ServedFroms[0].Keyspace != "test_keyspace4" {
t.Errorf("GetKeyspace: unexpected keyspace, got %v", *storedK)
}
}
// checkVSchema runs the tests on the VSchema part of the API
func checkVSchema(t *testing.T, ts topo.Impl) {
ctx := context.Background()
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
shard := &topodatapb.Shard{
KeyRange: newKeyRange("b0-c0"),
}
if err := ts.CreateShard(ctx, "test_keyspace", "b0-c0", shard); err != nil {
t.Fatalf("CreateShard: %v", err)
}
got, err := ts.GetVSchema(ctx, "test_keyspace")
want := &vschemapb.Keyspace{}
if err != topo.ErrNoNode {
t.Error(err)
}
err = ts.SaveVSchema(ctx, "test_keyspace", &vschemapb.Keyspace{
Sharded: true,
Vindexes: map[string]*vschemapb.Vindex{
"stfu1": {
Type: "stfu",
Params: map[string]string{
"stfu1": "1",
},
Owner: "t1",
},
"stln1": {
Type: "stln",
Owner: "t1",
},
},
Tables: map[string]*vschemapb.Table{
"t1": {
ColumnVindexes: []*vschemapb.ColumnVindex{
{
Column: "c1",
Name: "stfu1",
}, {
Column: "c2",
Name: "stln1",
},
},
},
},
})
if err != nil {
t.Error(err)
}
got, err = ts.GetVSchema(ctx, "test_keyspace")
if err != nil {
t.Error(err)
}
want = &vschemapb.Keyspace{
Sharded: true,
Vindexes: map[string]*vschemapb.Vindex{
"stfu1": {
Type: "stfu",
Params: map[string]string{
"stfu1": "1",
},
Owner: "t1",
},
"stln1": {
Type: "stln",
Owner: "t1",
},
},
Tables: map[string]*vschemapb.Table{
"t1": {
ColumnVindexes: []*vschemapb.ColumnVindex{
{
Column: "c1",
Name: "stfu1",
}, {
Column: "c2",
Name: "stln1",
},
},
},
},
}
if !proto.Equal(got, want) {
t.Errorf("GetVSchema: %s, want %s", got, want)
}
err = ts.SaveVSchema(ctx, "test_keyspace", &vschemapb.Keyspace{})
if err != nil {
t.Error(err)
}
got, err = ts.GetVSchema(ctx, "test_keyspace")
if err != nil {
t.Error(err)
}
want = &vschemapb.Keyspace{}
if !proto.Equal(got, want) {
t.Errorf("GetVSchema: %s, want %s", got, want)
}
// Make sure the vschema is not returned as a shard name,
// because they share the same directory location.
shards, err := ts.GetShardNames(ctx, "test_keyspace")
if err != nil {
t.Errorf("GetShardNames: %v", err)
}
if len(shards) != 1 || shards[0] != "b0-c0" {
t.Errorf(`GetShardNames: want [ "b0-c0" ], got %v`, shards)
}
}
// CheckKeyspace tests the keyspace part of the API
func CheckKeyspace(ctx context.Context, t *testing.T, ts topo.Impl) {
keyspaces, err := ts.GetKeyspaces(ctx)
if err != nil {
t.Errorf("GetKeyspaces(empty): %v", err)
}
if len(keyspaces) != 0 {
t.Errorf("len(GetKeyspaces()) != 0: %v", keyspaces)
}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &pb.Keyspace{}); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &pb.Keyspace{}); err != topo.ErrNodeExists {
t.Errorf("CreateKeyspace(again) is not ErrNodeExists: %v", err)
}
// Delete and re-create.
if err := ts.DeleteKeyspace(ctx, "test_keyspace"); err != nil {
t.Errorf("DeleteKeyspace: %v", err)
}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &pb.Keyspace{}); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
keyspaces, err = ts.GetKeyspaces(ctx)
if err != nil {
t.Errorf("GetKeyspaces: %v", err)
}
if len(keyspaces) != 1 || keyspaces[0] != "test_keyspace" {
t.Errorf("GetKeyspaces: want %v, got %v", []string{"test_keyspace"}, keyspaces)
}
k := &pb.Keyspace{
ShardingColumnName: "user_id",
ShardingColumnType: pb.KeyspaceIdType_UINT64,
ServedFroms: []*pb.Keyspace_ServedFrom{
&pb.Keyspace_ServedFrom{
TabletType: pb.TabletType_REPLICA,
Cells: []string{"c1", "c2"},
Keyspace: "test_keyspace3",
},
&pb.Keyspace_ServedFrom{
TabletType: pb.TabletType_MASTER,
Cells: nil,
Keyspace: "test_keyspace3",
},
},
SplitShardCount: 64,
}
if err := ts.CreateKeyspace(ctx, "test_keyspace2", k); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
keyspaces, err = ts.GetKeyspaces(ctx)
if err != nil {
t.Errorf("GetKeyspaces: %v", err)
}
if len(keyspaces) != 2 ||
keyspaces[0] != "test_keyspace" ||
keyspaces[1] != "test_keyspace2" {
t.Errorf("GetKeyspaces: want %v, got %v", []string{"test_keyspace", "test_keyspace2"}, keyspaces)
}
// Call delete shards and make sure the keyspace still exists.
if err := ts.DeleteKeyspaceShards(ctx, "test_keyspace2"); err != nil {
t.Errorf("DeleteKeyspaceShards: %v", err)
}
storedK, storedVersion, err := ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if !reflect.DeepEqual(storedK, k) {
t.Fatalf("returned keyspace doesn't match: got %v expected %v", storedK, k)
}
storedK.ShardingColumnName = "other_id"
storedK.ShardingColumnType = pb.KeyspaceIdType_BYTES
var newServedFroms []*pb.Keyspace_ServedFrom
for _, ksf := range storedK.ServedFroms {
if ksf.TabletType == pb.TabletType_MASTER {
continue
}
if ksf.TabletType == pb.TabletType_REPLICA {
ksf.Keyspace = "test_keyspace4"
}
newServedFroms = append(newServedFroms, ksf)
}
storedK.ServedFroms = newServedFroms
_, err = ts.UpdateKeyspace(ctx, "test_keyspace2", storedK, storedVersion)
if err != nil {
t.Fatalf("UpdateKeyspace: %v", err)
}
storedK, storedVersion, err = ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if storedK.ShardingColumnName != "other_id" ||
storedK.ShardingColumnType != pb.KeyspaceIdType_BYTES ||
len(storedK.ServedFroms) != 1 ||
storedK.ServedFroms[0].TabletType != pb.TabletType_REPLICA ||
storedK.ServedFroms[0].Keyspace != "test_keyspace4" {
t.Errorf("GetKeyspace: unexpected keyspace, got %v", *storedK)
}
}
// CheckVSchema runs the tests on the VSchema part of the API
func CheckVSchema(ctx context.Context, t *testing.T, ts topo.Impl) {
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topodatapb.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
shard := &topodatapb.Shard{
KeyRange: newKeyRange("b0-c0"),
}
if err := ts.CreateShard(ctx, "test_keyspace", "b0-c0", shard); err != nil {
t.Fatalf("CreateShard: %v", err)
}
got, err := ts.GetVSchema(ctx, "test_keyspace")
if err != nil {
t.Error(err)
}
want := "{}"
if got != want {
t.Errorf("GetVSchema: %s, want %s", got, want)
}
err = ts.SaveVSchema(ctx, "test_keyspace", `{ "Sharded": true }`)
if err != nil {
t.Error(err)
}
got, err = ts.GetVSchema(ctx, "test_keyspace")
if err != nil {
t.Error(err)
}
want = `{ "Sharded": true }`
if got != want {
t.Errorf("GetVSchema: %s, want %s", got, want)
}
err = ts.SaveVSchema(ctx, "test_keyspace", `{ "Sharded": false }`)
if err != nil {
t.Error(err)
}
got, err = ts.GetVSchema(ctx, "test_keyspace")
if err != nil {
t.Error(err)
}
want = `{ "Sharded": false }`
if got != want {
t.Errorf("GetVSchema: %s, want %s", got, want)
}
err = ts.SaveVSchema(ctx, "test_keyspace", "invalid")
want = "Unmarshal failed:"
if err == nil || !strings.HasPrefix(err.Error(), want) {
t.Errorf("SaveVSchema: %v, must start with %s", err, want)
}
// Make sure the vschema is not returned as a shard name,
// because they share the same directory location.
shards, err := ts.GetShardNames(ctx, "test_keyspace")
if err != nil {
t.Errorf("GetShardNames: %v", err)
}
if len(shards) != 1 || shards[0] != "b0-c0" {
t.Errorf(`GetShardNames: want [ "b0-c0" ], got %v`, shards)
}
}