// GetOrCreateShard will return the shard object, or create one if it doesn't
// already exist. Note the shard creation is protected by a keyspace Lock.
func GetOrCreateShard(ctx context.Context, ts topo.Server, keyspace, shard string) (*topo.ShardInfo, error) {
si, finalErr := ts.GetShard(ctx, keyspace, shard)
if finalErr == topo.ErrNoNode {
// create the keyspace, maybe it already exists
if err := ts.CreateKeyspace(ctx, keyspace, &pb.Keyspace{}); err != nil && err != topo.ErrNodeExists {
return nil, fmt.Errorf("CreateKeyspace(%v) failed: %v", keyspace, err)
}
// now we can lock the keyspace
node := actionnode.KeyspaceCreateShard()
lockPath, err := node.LockKeyspace(ctx, ts, keyspace)
if err != nil {
return nil, fmt.Errorf("LockKeyspace failed: %v", err)
}
// now try to create within the lock, may already exist
if err := ts.CreateShard(ctx, keyspace, shard); err != nil && err != topo.ErrNodeExists {
return nil, node.UnlockKeyspace(ctx, ts, keyspace, lockPath, fmt.Errorf("CreateShard(%v/%v) failed: %v", keyspace, shard, err))
}
// try to read the shard again, maybe someone created it
// in between the original GetShard and the LockKeyspace
si, finalErr = ts.GetShard(ctx, keyspace, shard)
// and unlock
if err := node.UnlockKeyspace(ctx, ts, keyspace, lockPath, finalErr); err != nil {
return nil, fmt.Errorf("UnlockKeyspace failed: %v", err)
}
}
return si, finalErr
}
// CopyKeyspaces will create the keyspaces in the destination topo
func CopyKeyspaces(fromTS, toTS topo.Server) {
keyspaces, err := fromTS.GetKeyspaces()
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(keyspace)
if err != nil {
rec.RecordError(fmt.Errorf("GetKeyspace(%v): %v", keyspace, err))
return
}
if err := toTS.CreateKeyspace(keyspace, k.Keyspace); 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.Server) {
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)
}
func CheckShardLock(t *testing.T, ts topo.Server) {
if err := ts.CreateKeyspace("test_keyspace", &topo.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
if err := topo.CreateShard(ts, "test_keyspace", "10-20"); err != nil {
t.Fatalf("CreateShard: %v", err)
}
interrupted := make(chan struct{}, 1)
lockPath, err := ts.LockShardForAction("test_keyspace", "10-20", "fake-content", 5*time.Second, interrupted)
if err != nil {
t.Fatalf("LockShardForAction: %v", err)
}
// test we can't take the lock again
if _, err := ts.LockShardForAction("test_keyspace", "10-20", "unused-fake-content", time.Second/2, interrupted); err != topo.ErrTimeout {
t.Errorf("LockShardForAction(again): %v", err)
}
// test we can interrupt taking the lock
go func() {
time.Sleep(time.Second / 2)
close(interrupted)
}()
if _, err := ts.LockShardForAction("test_keyspace", "10-20", "unused-fake-content", 5*time.Second, interrupted); err != topo.ErrInterrupted {
t.Errorf("LockShardForAction(interrupted): %v", err)
}
if err := ts.UnlockShardForAction("test_keyspace", "10-20", lockPath, "fake-results"); err != nil {
t.Errorf("UnlockShardForAction(): %v", err)
}
// test we can't unlock again
if err := ts.UnlockShardForAction("test_keyspace", "10-20", lockPath, "fake-results"); err == nil {
t.Error("UnlockShardForAction(again) worked")
}
// test we can't lock a non-existing shard
interrupted = make(chan struct{}, 1)
if _, err := ts.LockShardForAction("test_keyspace", "20-30", "fake-content", 5*time.Second, interrupted); err == nil {
t.Fatalf("LockShardForAction(test_keyspace/20-30) worked for non-existing shard")
}
}
func CheckKeyspace(t *testing.T, ts topo.Server) {
keyspaces, err := ts.GetKeyspaces()
if err != nil {
t.Errorf("GetKeyspaces(empty): %v", err)
}
if len(keyspaces) != 0 {
t.Errorf("len(GetKeyspaces()) != 0: %v", keyspaces)
}
if err := ts.CreateKeyspace("test_keyspace"); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
if err := ts.CreateKeyspace("test_keyspace"); err != topo.ErrNodeExists {
t.Errorf("CreateKeyspace(again) is not ErrNodeExists: %v", err)
}
keyspaces, err = ts.GetKeyspaces()
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)
}
if err := ts.CreateKeyspace("test_keyspace2"); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
keyspaces, err = ts.GetKeyspaces()
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)
}
}
// initTabletMap creates the action agents and associated data structures
// for all tablets
func initTabletMap(ts topo.Server, topology string, mysqld mysqlctl.MysqlDaemon, dbcfgs dbconfigs.DBConfigs, mycnf *mysqlctl.Mycnf) {
tabletMap = make(map[uint32]*tablet)
ctx := context.Background()
// disable publishing of stats from query service
flag.Lookup("queryserver-config-enable-publish-stats").Value.Set("false")
var uid uint32 = 1
keyspaceMap := make(map[string]bool)
for _, entry := range strings.Split(topology, ",") {
slash := strings.IndexByte(entry, '/')
column := strings.IndexByte(entry, ':')
if slash == -1 || column == -1 {
log.Fatalf("invalid topology entry: %v", entry)
}
keyspace := entry[:slash]
shard := entry[slash+1 : column]
dbname := entry[column+1:]
dbcfgs.App.DbName = dbname
// create the keyspace if necessary, so we can set the
// ShardingColumnName and ShardingColumnType
if _, ok := keyspaceMap[keyspace]; !ok {
// only set for sharding key info for sharded keyspaces
scn := ""
sct := topodatapb.KeyspaceIdType_UNSET
if shard != "0" {
var err error
sct, err = key.ParseKeyspaceIDType(*shardingColumnType)
if err != nil {
log.Fatalf("parseKeyspaceIDType(%v) failed: %v", *shardingColumnType, err)
}
scn = *shardingColumnName
}
if err := ts.CreateKeyspace(ctx, keyspace, &topodatapb.Keyspace{
ShardingColumnName: scn,
ShardingColumnType: sct,
}); err != nil {
log.Fatalf("CreateKeyspace(%v) failed: %v", keyspace, err)
}
keyspaceMap[keyspace] = true
}
// create the master
alias := &topodatapb.TabletAlias{
Cell: cell,
Uid: uid,
}
log.Infof("Creating master tablet %v for %v/%v", topoproto.TabletAliasString(alias), keyspace, shard)
flag.Lookup("debug-url-prefix").Value.Set(fmt.Sprintf("/debug-%d", uid))
masterController := tabletserver.NewServer()
masterAgent := tabletmanager.NewComboActionAgent(ctx, ts, alias, int32(8000+uid), int32(9000+uid), masterController, dbcfgs, mysqld, keyspace, shard, dbname, "replica")
if err := masterAgent.TabletExternallyReparented(ctx, ""); err != nil {
log.Fatalf("TabletExternallyReparented failed on master: %v", err)
}
tabletMap[uid] = &tablet{
keyspace: keyspace,
shard: shard,
tabletType: topodatapb.TabletType_MASTER,
dbname: dbname,
qsc: masterController,
agent: masterAgent,
}
uid++
// create a replica slave
alias = &topodatapb.TabletAlias{
Cell: cell,
Uid: uid,
}
log.Infof("Creating replica tablet %v for %v/%v", topoproto.TabletAliasString(alias), keyspace, shard)
flag.Lookup("debug-url-prefix").Value.Set(fmt.Sprintf("/debug-%d", uid))
replicaController := tabletserver.NewServer()
tabletMap[uid] = &tablet{
keyspace: keyspace,
shard: shard,
tabletType: topodatapb.TabletType_REPLICA,
dbname: dbname,
qsc: replicaController,
agent: tabletmanager.NewComboActionAgent(ctx, ts, alias, int32(8000+uid), int32(9000+uid), replicaController, dbcfgs, mysqld, keyspace, shard, dbname, "replica"),
}
uid++
// create a rdonly slave
alias = &topodatapb.TabletAlias{
Cell: cell,
Uid: uid,
}
log.Infof("Creating rdonly tablet %v for %v/%v", topoproto.TabletAliasString(alias), keyspace, shard)
flag.Lookup("debug-url-prefix").Value.Set(fmt.Sprintf("/debug-%d", uid))
rdonlyController := tabletserver.NewServer()
tabletMap[uid] = &tablet{
keyspace: keyspace,
shard: shard,
tabletType: topodatapb.TabletType_RDONLY,
dbname: dbname,
qsc: rdonlyController,
agent: tabletmanager.NewComboActionAgent(ctx, ts, alias, int32(8000+uid), int32(9000+uid), rdonlyController, dbcfgs, mysqld, keyspace, shard, dbname, "rdonly"),
}
uid++
}
// Rebuild the SrvKeyspace objects, we we can support range-based
// sharding queries.
wr := wrangler.New(logutil.NewConsoleLogger(), ts, nil)
for keyspace := range keyspaceMap {
if err := wr.RebuildKeyspaceGraph(ctx, keyspace, nil, true); err != nil {
log.Fatalf("cannot rebuild %v: %v", keyspace, err)
}
}
// Register the tablet dialer for tablet server
tabletconn.RegisterDialer("internal", dialer)
*tabletconn.TabletProtocol = "internal"
// Register the tablet manager client factory for tablet manager
tmclient.RegisterTabletManagerClientFactory("internal", func() tmclient.TabletManagerClient {
return &internalTabletManagerClient{}
})
*tmclient.TabletManagerProtocol = "internal"
}
func CheckShard(t *testing.T, ts topo.Server) {
if err := ts.CreateKeyspace("test_keyspace", &topo.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
if err := topo.CreateShard(ts, "test_keyspace", "b0-c0"); err != nil {
t.Fatalf("CreateShard: %v", err)
}
if err := topo.CreateShard(ts, "test_keyspace", "b0-c0"); err != topo.ErrNodeExists {
t.Errorf("CreateShard called second time, got: %v", err)
}
if _, err := ts.GetShard("test_keyspace", "666"); err != topo.ErrNoNode {
t.Errorf("GetShard(666): %v", err)
}
shardInfo, err := ts.GetShard("test_keyspace", "b0-c0")
if err != nil {
t.Errorf("GetShard: %v", err)
}
if want := newKeyRange("b0-c0"); shardInfo.KeyRange != want {
t.Errorf("shardInfo.KeyRange: want %v, got %v", want, shardInfo.KeyRange)
}
master := topo.TabletAlias{Cell: "ny", Uid: 1}
shardInfo.MasterAlias = master
shardInfo.KeyRange = newKeyRange("b0-c0")
shardInfo.ServedTypes = []topo.TabletType{topo.TYPE_MASTER, topo.TYPE_REPLICA, topo.TYPE_RDONLY}
shardInfo.SourceShards = []topo.SourceShard{
topo.SourceShard{
Uid: 1,
Keyspace: "source_ks",
Shard: "b8-c0",
KeyRange: newKeyRange("b8-c0"),
Tables: []string{"table1", "table2"},
},
}
if err := topo.UpdateShard(ts, shardInfo); err != nil {
t.Errorf("UpdateShard: %v", err)
}
shardInfo, err = ts.GetShard("test_keyspace", "b0-c0")
if err != nil {
t.Errorf("GetShard: %v", err)
}
if shardInfo.MasterAlias != master {
t.Errorf("after UpdateShard: shardInfo.MasterAlias got %v", shardInfo.MasterAlias)
}
if shardInfo.KeyRange != newKeyRange("b0-c0") {
t.Errorf("after UpdateShard: shardInfo.KeyRange got %v", shardInfo.KeyRange)
}
if len(shardInfo.ServedTypes) != 3 || shardInfo.ServedTypes[0] != topo.TYPE_MASTER || shardInfo.ServedTypes[1] != topo.TYPE_REPLICA || shardInfo.ServedTypes[2] != topo.TYPE_RDONLY {
t.Errorf("after UpdateShard: shardInfo.ServedTypes got %v", shardInfo.ServedTypes)
}
if len(shardInfo.SourceShards) != 1 ||
shardInfo.SourceShards[0].Uid != 1 ||
shardInfo.SourceShards[0].Keyspace != "source_ks" ||
shardInfo.SourceShards[0].Shard != "b8-c0" ||
shardInfo.SourceShards[0].KeyRange != newKeyRange("b8-c0") ||
len(shardInfo.SourceShards[0].Tables) != 2 ||
shardInfo.SourceShards[0].Tables[0] != "table1" ||
shardInfo.SourceShards[0].Tables[1] != "table2" {
t.Errorf("after UpdateShard: shardInfo.SourceShards got %v", shardInfo.SourceShards)
}
shards, err := ts.GetShardNames("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("test_keyspace666"); err != topo.ErrNoNode {
t.Errorf("GetShardNames(666): %v", err)
}
}
// initTabletMap creates the action agents and associated data structures
// for all tablets, based on the vttest proto parameter.
func initTabletMap(ts topo.Server, topoProto string, mysqld mysqlctl.MysqlDaemon, dbcfgs dbconfigs.DBConfigs, schemaDir string, mycnf *mysqlctl.Mycnf) error {
// parse the input topology
tpb := &vttestpb.VTTestTopology{}
if err := proto.UnmarshalText(topoProto, tpb); err != nil {
return fmt.Errorf("cannot parse topology: %v", err)
}
tabletMap = make(map[uint32]*tablet)
ctx := context.Background()
// disable publishing of stats from query service
flag.Set("queryserver-config-enable-publish-stats", "false")
// iterate through the keyspaces
wr := wrangler.New(logutil.NewConsoleLogger(), ts, nil)
var uid uint32 = 1
for _, kpb := range tpb.Keyspaces {
keyspace := kpb.Name
// First parse the ShardingColumnType.
// Note if it's empty, we will return 'UNSET'.
sct, err := key.ParseKeyspaceIDType(kpb.ShardingColumnType)
if err != nil {
return fmt.Errorf("parseKeyspaceIDType(%v) failed: %v", kpb.ShardingColumnType, err)
}
if kpb.ServedFrom != "" {
// if we have a redirect, create a completely redirected
// keyspace and no tablet
if err := ts.CreateKeyspace(ctx, keyspace, &topodatapb.Keyspace{
ShardingColumnName: kpb.ShardingColumnName,
ShardingColumnType: sct,
ServedFroms: []*topodatapb.Keyspace_ServedFrom{
{
TabletType: topodatapb.TabletType_MASTER,
Keyspace: kpb.ServedFrom,
},
{
TabletType: topodatapb.TabletType_REPLICA,
Keyspace: kpb.ServedFrom,
},
{
TabletType: topodatapb.TabletType_RDONLY,
Keyspace: kpb.ServedFrom,
},
},
}); err != nil {
return fmt.Errorf("CreateKeyspace(%v) failed: %v", keyspace, err)
}
} else {
// create a regular keyspace
if err := ts.CreateKeyspace(ctx, keyspace, &topodatapb.Keyspace{
ShardingColumnName: kpb.ShardingColumnName,
ShardingColumnType: sct,
}); err != nil {
return fmt.Errorf("CreateKeyspace(%v) failed: %v", keyspace, err)
}
// iterate through the shards
for _, spb := range kpb.Shards {
shard := spb.Name
dbname := spb.DbNameOverride
if dbname == "" {
dbname = fmt.Sprintf("vt_%v_%v", keyspace, shard)
}
dbcfgs.App.DbName = dbname
// create the master
if err := createTablet(ctx, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_MASTER, mysqld, dbcfgs); err != nil {
return err
}
uid++
// create a replica slave
if err := createTablet(ctx, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_REPLICA, mysqld, dbcfgs); err != nil {
return err
}
uid++
// create a rdonly slave
if err := createTablet(ctx, ts, cell, uid, keyspace, shard, dbname, topodatapb.TabletType_RDONLY, mysqld, dbcfgs); err != nil {
return err
}
uid++
}
}
// vschema for the keyspace
if schemaDir != "" {
f := path.Join(schemaDir, keyspace, "vschema.json")
if _, err := os.Stat(f); err == nil {
// load the vschema
formal, err := vindexes.LoadFormalKeyspace(f)
if err != nil {
return fmt.Errorf("cannot load vschema file %v for keyspace %v: %v", f, keyspace, err)
}
if err := ts.SaveVSchema(ctx, keyspace, formal); err != nil {
return fmt.Errorf("SaveVSchema(%v) failed: %v", keyspace, err)
}
} else {
log.Infof("File %v doesn't exist, skipping vschema for keyspace %v", f, keyspace)
}
}
// Rebuild the SrvKeyspace object, so we can support
// range-based sharding queries, and export the redirects.
if err := wr.RebuildKeyspaceGraph(ctx, keyspace, nil); err != nil {
return fmt.Errorf("cannot rebuild %v: %v", keyspace, err)
}
}
// Rebuild the SrvVSchema object
if err := topotools.RebuildVSchema(ctx, wr.Logger(), ts, []string{cell}); err != nil {
return fmt.Errorf("RebuildVSchemaGraph failed: %v", err)
}
// Register the tablet dialer for tablet server
tabletconn.RegisterDialer("internal", dialer)
*tabletconn.TabletProtocol = "internal"
// Register the tablet manager client factory for tablet manager
tmclient.RegisterTabletManagerClientFactory("internal", func() tmclient.TabletManagerClient {
return &internalTabletManagerClient{}
})
*tmclient.TabletManagerProtocol = "internal"
// run healthcheck on all vttablets
tmc := tmclient.NewTabletManagerClient()
for _, tablet := range tabletMap {
tabletInfo, err := ts.GetTablet(ctx, tablet.agent.TabletAlias)
if err != nil {
return fmt.Errorf("cannot find tablet: %+v", tablet.agent.TabletAlias)
}
tmc.RunHealthCheck(ctx, tabletInfo.Tablet)
}
return nil
}
func CheckKeyspace(t *testing.T, ts topo.Server) {
keyspaces, err := ts.GetKeyspaces()
if err != nil {
t.Errorf("GetKeyspaces(empty): %v", err)
}
if len(keyspaces) != 0 {
t.Errorf("len(GetKeyspaces()) != 0: %v", keyspaces)
}
if err := ts.CreateKeyspace("test_keyspace", &topo.Keyspace{}); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
if err := ts.CreateKeyspace("test_keyspace", &topo.Keyspace{}); err != topo.ErrNodeExists {
t.Errorf("CreateKeyspace(again) is not ErrNodeExists: %v", err)
}
keyspaces, err = ts.GetKeyspaces()
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)
}
if err := ts.CreateKeyspace("test_keyspace2", &topo.Keyspace{
ShardingColumnName: "user_id",
ShardingColumnType: key.KIT_UINT64,
ServedFrom: map[topo.TabletType]string{
topo.TYPE_MASTER: "test_keyspace3",
},
}); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
keyspaces, err = ts.GetKeyspaces()
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)
}
ki, err := ts.GetKeyspace("test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if ki.ShardingColumnName != "user_id" ||
ki.ShardingColumnType != key.KIT_UINT64 ||
ki.ServedFrom[topo.TYPE_MASTER] != "test_keyspace3" {
t.Errorf("GetKeyspace: unexpected keyspace, got %v", *ki)
}
ki.ShardingColumnName = "other_id"
ki.ShardingColumnType = key.KIT_BYTES
delete(ki.ServedFrom, topo.TYPE_MASTER)
ki.ServedFrom[topo.TYPE_REPLICA] = "test_keyspace4"
err = ts.UpdateKeyspace(ki)
if err != nil {
t.Fatalf("UpdateKeyspace: %v", err)
}
ki, err = ts.GetKeyspace("test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if ki.ShardingColumnName != "other_id" ||
ki.ShardingColumnType != key.KIT_BYTES ||
ki.ServedFrom[topo.TYPE_REPLICA] != "test_keyspace4" {
t.Errorf("GetKeyspace: unexpected keyspace, got %v", *ki)
}
}
// CheckKeyspace tests the keyspace part of the API
func CheckKeyspace(ctx context.Context, t *testing.T, ts topo.Server) {
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)
}
ki, err := ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if !reflect.DeepEqual(ki.Keyspace, k) {
t.Fatalf("returned keyspace doesn't match: got %v expected %v", ki.Keyspace, k)
}
ki.ShardingColumnName = "other_id"
ki.ShardingColumnType = pb.KeyspaceIdType_BYTES
var newServedFroms []*pb.Keyspace_ServedFrom
for _, ksf := range ki.ServedFroms {
if ksf.TabletType == pb.TabletType_MASTER {
continue
}
if ksf.TabletType == pb.TabletType_REPLICA {
ksf.Keyspace = "test_keyspace4"
}
newServedFroms = append(newServedFroms, ksf)
}
ki.ServedFroms = newServedFroms
err = topo.UpdateKeyspace(ctx, ts, ki)
if err != nil {
t.Fatalf("UpdateKeyspace: %v", err)
}
ki, err = ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if ki.ShardingColumnName != "other_id" ||
ki.ShardingColumnType != pb.KeyspaceIdType_BYTES ||
ki.GetServedFrom(pb.TabletType_REPLICA).Keyspace != "test_keyspace4" {
t.Errorf("GetKeyspace: unexpected keyspace, got %v", *ki)
}
}
// CheckKeyspace tests the keyspace part of the API
func CheckKeyspace(ctx context.Context, t *testing.T, ts topo.Server) {
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", &topo.Keyspace{}); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topo.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", &topo.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 := &topo.Keyspace{
ShardingColumnName: "user_id",
ShardingColumnType: key.KIT_UINT64,
ServedFromMap: map[topo.TabletType]*topo.KeyspaceServedFrom{
topo.TYPE_REPLICA: &topo.KeyspaceServedFrom{
Cells: []string{"c1", "c2"},
Keyspace: "test_keyspace3",
},
topo.TYPE_MASTER: &topo.KeyspaceServedFrom{
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)
}
ki, err := ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if !reflect.DeepEqual(ki.Keyspace, k) {
t.Fatalf("returned keyspace doesn't match: got %v expected %v", ki.Keyspace, k)
}
ki.ShardingColumnName = "other_id"
ki.ShardingColumnType = key.KIT_BYTES
delete(ki.ServedFromMap, topo.TYPE_MASTER)
ki.ServedFromMap[topo.TYPE_REPLICA].Keyspace = "test_keyspace4"
err = topo.UpdateKeyspace(ctx, ts, ki)
if err != nil {
t.Fatalf("UpdateKeyspace: %v", err)
}
ki, err = ts.GetKeyspace(ctx, "test_keyspace2")
if err != nil {
t.Fatalf("GetKeyspace: %v", err)
}
if ki.ShardingColumnName != "other_id" ||
ki.ShardingColumnType != key.KIT_BYTES ||
ki.ServedFromMap[topo.TYPE_REPLICA].Keyspace != "test_keyspace4" {
t.Errorf("GetKeyspace: unexpected keyspace, got %v", *ki)
}
}
func CheckReplicationPaths(t *testing.T, ts topo.Server) {
if _, err := ts.GetReplicationPaths("test_keyspace", "-10", "/"); err != topo.ErrNoNode {
t.Errorf("GetReplicationPaths(bad shard): %v", err)
}
if err := ts.CreateKeyspace("test_keyspace"); err != nil {
t.Errorf("CreateKeyspace: %v", err)
}
if err := topo.CreateShard(ts, "test_keyspace", "-10"); err != nil {
t.Errorf("CreateShard: %v", err)
}
if paths, err := ts.GetReplicationPaths("test_keyspace", "-10", "/"); err != nil || len(paths) != 0 {
t.Errorf("GetReplicationPaths(empty shard): %v, %v", err, paths)
}
if _, err := ts.GetReplicationPaths("test_keyspace", "-10", "/666"); err != topo.ErrNoNode {
t.Errorf("GetReplicationPaths(non-existing path): %v", err)
}
if err := ts.CreateReplicationPath("test_keyspace", "-10", "/cell-0000000001"); err != nil {
t.Errorf("CreateReplicationPath: %v", err)
}
if err := ts.CreateReplicationPath("test_keyspace", "-10", "/cell-0000000001"); err != topo.ErrNodeExists {
t.Errorf("CreateReplicationPath(again): %v", err)
}
if paths, err := ts.GetReplicationPaths("test_keyspace", "-10", "/"); err != nil || len(paths) != 1 || paths[0].String() != "cell-0000000001" {
t.Errorf("GetReplicationPaths(root): %v, %v", err, paths)
}
if err := ts.CreateReplicationPath("test_keyspace", "-10", "/cell-0000000001/cell-0000000002"); err != nil {
t.Errorf("CreateReplicationPath(2): %v", err)
}
if err := ts.CreateReplicationPath("test_keyspace", "-10", "/cell-0000000001/cell-0000000003"); err != nil {
t.Errorf("CreateReplicationPath(3): %v", err)
}
if paths, err := ts.GetReplicationPaths("test_keyspace", "-10", "/cell-0000000001"); err != nil || len(paths) != 2 || paths[0].String() != "cell-0000000002" || paths[1].String() != "cell-0000000003" {
t.Errorf("GetReplicationPaths(master): %v, %v", err, paths)
}
if err := ts.DeleteReplicationPath("test_keyspace", "-10", "/cell-0000000001"); err != topo.ErrNotEmpty {
t.Errorf("DeleteReplicationPath(master with slaves): %v", err)
}
if err := ts.DeleteReplicationPath("test_keyspace", "-10", "/cell-0000000001/cell-0000000002"); err != nil {
t.Errorf("DeleteReplicationPath(slave1): %v", err)
}
if paths, err := ts.GetReplicationPaths("test_keyspace", "-10", "/cell-0000000001"); err != nil || len(paths) != 1 || paths[0].String() != "cell-0000000003" {
t.Errorf("GetReplicationPaths(master): %v, %v", err, paths)
}
if err := ts.DeleteReplicationPath("test_keyspace", "-10", "/cell-0000000001/cell-0000000003"); err != nil {
t.Errorf("DeleteReplicationPath(slave2): %v", err)
}
if paths, err := ts.GetReplicationPaths("test_keyspace", "-10", "/cell-0000000001"); err != nil || len(paths) != 0 {
t.Errorf("GetReplicationPaths(master): %v, %v", err, paths)
}
if err := ts.DeleteReplicationPath("test_keyspace", "-10", "/cell-0000000001"); err != nil {
t.Errorf("DeleteReplicationPath(master): %v", err)
}
if paths, err := ts.GetReplicationPaths("test_keyspace", "-10", "/"); err != nil || len(paths) != 0 {
t.Errorf("GetReplicationPaths(root): %v, %v", err, paths)
}
}
func CheckShard(t *testing.T, ts topo.Server) {
if err := ts.CreateKeyspace("test_keyspace", &topo.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
if err := topo.CreateShard(ts, "test_keyspace", "b0-c0"); err != nil {
t.Fatalf("CreateShard: %v", err)
}
if err := topo.CreateShard(ts, "test_keyspace", "b0-c0"); err != topo.ErrNodeExists {
t.Errorf("CreateShard called second time, got: %v", err)
}
if _, err := ts.GetShard("test_keyspace", "666"); err != topo.ErrNoNode {
t.Errorf("GetShard(666): %v", err)
}
shardInfo, err := ts.GetShard("test_keyspace", "b0-c0")
if err != nil {
t.Errorf("GetShard: %v", err)
}
if want := newKeyRange("b0-c0"); shardInfo.KeyRange != want {
t.Errorf("shardInfo.KeyRange: want %v, got %v", want, shardInfo.KeyRange)
}
master := topo.TabletAlias{Cell: "ny", Uid: 1}
shardInfo.MasterAlias = master
shardInfo.KeyRange = newKeyRange("b0-c0")
shardInfo.ServedTypes = []topo.TabletType{topo.TYPE_MASTER, topo.TYPE_REPLICA, topo.TYPE_RDONLY}
shardInfo.SourceShards = []topo.SourceShard{
topo.SourceShard{
Uid: 1,
Keyspace: "source_ks",
Shard: "b8-c0",
KeyRange: newKeyRange("b8-c0"),
Tables: []string{"table1", "table2"},
},
}
shardInfo.BlacklistedTablesMap = map[topo.TabletType][]string{
topo.TYPE_MASTER: []string{"black1", "black2"},
topo.TYPE_REPLICA: []string{"black3", "black4"},
}
if err := topo.UpdateShard(ts, shardInfo); err != nil {
t.Errorf("UpdateShard: %v", err)
}
updatedShardInfo, err := ts.GetShard("test_keyspace", "b0-c0")
if err != nil {
t.Fatalf("GetShard: %v", err)
}
if eq, err := shardEqual(shardInfo.Shard, updatedShardInfo.Shard); 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", shardInfo.Shard, updatedShardInfo.Shard)
}
// test GetShardNames
shards, err := ts.GetShardNames("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("test_keyspace666"); err != topo.ErrNoNode {
t.Errorf("GetShardNames(666): %v", err)
}
}
// CheckShard verifies the Shard operations work correctly
func CheckShard(ctx context.Context, t *testing.T, ts topo.Server) {
if err := ts.CreateKeyspace(ctx, "test_keyspace", &topo.Keyspace{}); err != nil {
t.Fatalf("CreateKeyspace: %v", err)
}
if err := topo.CreateShard(ctx, ts, "test_keyspace", "b0-c0"); err != nil {
t.Fatalf("CreateShard: %v", err)
}
if err := topo.CreateShard(ctx, ts, "test_keyspace", "b0-c0"); 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 := topo.CreateShard(ctx, ts, "test_keyspace", "b0-c0"); 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 := topo.CreateShard(ctx, ts, "test_keyspace", "b0-c0"); err != nil {
t.Fatalf("CreateShard: %v", err)
}
if _, err := topo.GetShard(ctx, ts, "test_keyspace", "666"); err != topo.ErrNoNode {
t.Errorf("GetShard(666): %v", err)
}
shardInfo, err := topo.GetShard(ctx, ts, "test_keyspace", "b0-c0")
if err != nil {
t.Errorf("GetShard: %v", err)
}
if want := newKeyRange("b0-c0"); shardInfo.KeyRange != want {
t.Errorf("shardInfo.KeyRange: want %v, got %v", want, shardInfo.KeyRange)
}
master := topo.TabletAlias{Cell: "ny", Uid: 1}
shardInfo.MasterAlias = master
shardInfo.KeyRange = newKeyRange("b0-c0")
shardInfo.ServedTypesMap = map[topo.TabletType]*topo.ShardServedType{
topo.TYPE_MASTER: &topo.ShardServedType{},
topo.TYPE_REPLICA: &topo.ShardServedType{Cells: []string{"c1"}},
topo.TYPE_RDONLY: &topo.ShardServedType{},
}
shardInfo.SourceShards = []topo.SourceShard{
topo.SourceShard{
Uid: 1,
Keyspace: "source_ks",
Shard: "b8-c0",
KeyRange: newKeyRange("b8-c0"),
Tables: []string{"table1", "table2"},
},
}
shardInfo.TabletControlMap = map[topo.TabletType]*topo.TabletControl{
topo.TYPE_MASTER: &topo.TabletControl{
Cells: []string{"c1", "c2"},
BlacklistedTables: []string{"black1", "black2"},
},
topo.TYPE_REPLICA: &topo.TabletControl{
DisableQueryService: true,
},
}
if err := topo.UpdateShard(ctx, ts, shardInfo); err != nil {
t.Errorf("UpdateShard: %v", err)
}
other := topo.TabletAlias{Cell: "ny", Uid: 82873}
_, err = topo.UpdateShardFields(ctx, ts, "test_keyspace", "b0-c0", func(shard *topo.Shard) error {
shard.MasterAlias = other
return nil
})
if err != nil {
t.Fatalf("UpdateShardFields error: %v", err)
}
si, err := topo.GetShard(ctx, ts, "test_keyspace", "b0-c0")
if err != nil {
t.Fatalf("GetShard: %v", err)
}
if si.MasterAlias != other {
t.Fatalf("shard.MasterAlias = %v, want %v", si.MasterAlias, other)
}
_, err = topo.UpdateShardFields(ctx, ts, "test_keyspace", "b0-c0", func(shard *topo.Shard) error {
shard.MasterAlias = master
return nil
})
if err != nil {
t.Fatalf("UpdateShardFields error: %v", err)
}
updatedShardInfo, err := topo.GetShard(ctx, ts, "test_keyspace", "b0-c0")
if err != nil {
t.Fatalf("GetShard: %v", err)
}
if eq, err := shardEqual(shardInfo.Shard, updatedShardInfo.Shard); 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", shardInfo.Shard, updatedShardInfo.Shard)
}
// 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)
}
}