// 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) } }