func (zkts *Server) DeleteTablet(alias topo.TabletAlias) error {
// We need to find out the keyspace and shard names because those are required
// in the TabletChange event.
ti, tiErr := zkts.GetTablet(alias)
zkTabletPath := TabletPathForAlias(alias)
err := zk.DeleteRecursive(zkts.zconn, zkTabletPath, -1)
if err != nil {
if zookeeper.IsError(err, zookeeper.ZNONODE) {
err = topo.ErrNoNode
}
return err
}
// Only try to log if we have the required information.
if tiErr == nil {
// We only want to copy the identity info for the tablet (alias, etc.).
// The rest has just been deleted, so it should be blank.
event.Dispatch(&events.TabletChange{
Tablet: topo.Tablet{
Alias: ti.Tablet.Alias,
Keyspace: ti.Tablet.Keyspace,
Shard: ti.Tablet.Shard,
},
Status: "deleted",
})
}
return nil
}
func (zkts *Server) CreateKeyspace(keyspace string, value *topo.Keyspace) error {
keyspacePath := path.Join(globalKeyspacesPath, keyspace)
pathList := []string{
keyspacePath,
path.Join(keyspacePath, "action"),
path.Join(keyspacePath, "actionlog"),
path.Join(keyspacePath, "shards"),
}
alreadyExists := false
for i, zkPath := range pathList {
c := ""
if i == 0 {
c = jscfg.ToJson(value)
}
_, err := zk.CreateRecursive(zkts.zconn, zkPath, c, 0, zookeeper.WorldACL(zookeeper.PERM_ALL))
if err != nil {
if zookeeper.IsError(err, zookeeper.ZNODEEXISTS) {
alreadyExists = true
} else {
return fmt.Errorf("error creating keyspace: %v %v", zkPath, err)
}
}
}
if alreadyExists {
return topo.ErrNodeExists
}
event.Dispatch(&events.KeyspaceChange{
KeyspaceInfo: *topo.NewKeyspaceInfo(keyspace, value, -1),
Status: "created",
})
return nil
}
func TestInvalidSeverity(t *testing.T) {
fw := &fakeWriter{}
writer = fw
event.Dispatch(&TestEvent{priority: syslog.Priority(123), message: "log me"})
if fw.message == "log me" {
t.Errorf("message was logged despite invalid severity")
}
}
// TestBadWriter checks that we don't panic when the connection fails.
func TestBadWriter(t *testing.T) {
writer = nil
ev := new(TestEvent)
event.Dispatch(ev)
if ev.triggered {
t.Errorf("passed nil writer to client")
}
}
// TestSyslog checks that our callback works.
func TestSyslog(t *testing.T) {
writer = &fakeWriter{}
ev := new(TestEvent)
event.Dispatch(ev)
if !ev.triggered {
t.Errorf("Syslog() was not called on event that implements Syslogger")
}
}
func (zkts *Server) DeleteKeyspaceShards(keyspace string) error {
shardsPath := path.Join(globalKeyspacesPath, keyspace, "shards")
if err := zk.DeleteRecursive(zkts.zconn, shardsPath, -1); err != nil && !zookeeper.IsError(err, zookeeper.ZNONODE) {
return err
}
event.Dispatch(&events.KeyspaceChange{
KeyspaceInfo: *topo.NewKeyspaceInfo(keyspace, nil, -1),
Status: "deleted all shards",
})
return nil
}
func testSeverity(sev syslog.Priority, t *testing.T) {
fw := &fakeWriter{}
writer = fw
event.Dispatch(&TestEvent{priority: sev, message: "log me"})
if fw.priority != sev {
t.Errorf("wrong priority: got %v, want %v", fw.priority, sev)
}
if fw.message != "log me" {
t.Errorf(`wrong message: got "%v", want "%v"`, fw.message, "log me")
}
}
func (zkts *Server) UpdateShard(si *topo.ShardInfo, existingVersion int64) (int64, error) {
shardPath := path.Join(globalKeyspacesPath, si.Keyspace(), "shards", si.ShardName())
stat, err := zkts.zconn.Set(shardPath, jscfg.ToJson(si.Shard), int(existingVersion))
if err != nil {
if zookeeper.IsError(err, zookeeper.ZNONODE) {
err = topo.ErrNoNode
}
return -1, err
}
event.Dispatch(&events.ShardChange{
ShardInfo: *si,
Status: "updated",
})
return int64(stat.Version()), nil
}
func (zkts *Server) DeleteShard(keyspace, shard string) error {
shardPath := path.Join(globalKeyspacesPath, keyspace, "shards", shard)
err := zk.DeleteRecursive(zkts.zconn, shardPath, -1)
if err != nil {
if zookeeper.IsError(err, zookeeper.ZNONODE) {
err = topo.ErrNoNode
}
return err
}
event.Dispatch(&events.ShardChange{
ShardInfo: *topo.NewShardInfo(keyspace, shard, nil, -1),
Status: "deleted",
})
return nil
}
func (zkts *Server) UpdateKeyspace(ki *topo.KeyspaceInfo, existingVersion int64) (int64, error) {
keyspacePath := path.Join(globalKeyspacesPath, ki.KeyspaceName())
data := jscfg.ToJson(ki.Keyspace)
stat, err := zkts.zconn.Set(keyspacePath, data, int(existingVersion))
if err != nil {
if zookeeper.IsError(err, zookeeper.ZNONODE) {
err = topo.ErrNoNode
}
return -1, err
}
event.Dispatch(&events.KeyspaceChange{
KeyspaceInfo: *ki,
Status: "updated",
})
return int64(stat.Version()), nil
}
func (zkts *Server) CreateTablet(tablet *topo.Tablet) error {
zkTabletPath := TabletPathForAlias(tablet.Alias)
// Create /zk/<cell>/vt/tablets/<uid>
_, err := zk.CreateRecursive(zkts.zconn, zkTabletPath, tablet.Json(), 0, zookeeper.WorldACL(zookeeper.PERM_ALL))
if err != nil {
if zookeeper.IsError(err, zookeeper.ZNODEEXISTS) {
err = topo.ErrNodeExists
}
return err
}
event.Dispatch(&events.TabletChange{
Tablet: *tablet,
Status: "created",
})
return nil
}
func (zkts *Server) UpdateTablet(tablet *topo.TabletInfo, existingVersion int64) (int64, error) {
zkTabletPath := TabletPathForAlias(tablet.Alias)
stat, err := zkts.zconn.Set(zkTabletPath, tablet.Json(), int(existingVersion))
if err != nil {
if zookeeper.IsError(err, zookeeper.ZBADVERSION) {
err = topo.ErrBadVersion
} else if zookeeper.IsError(err, zookeeper.ZNONODE) {
err = topo.ErrNoNode
}
return 0, err
}
event.Dispatch(&events.TabletChange{
Tablet: *tablet.Tablet,
Status: "updated",
})
return int64(stat.Version()), nil
}
func (zkts *Server) UpdateTabletFields(tabletAlias topo.TabletAlias, update func(*topo.Tablet) error) error {
// Store the last tablet value so we can log it if the change succeeds.
var lastTablet *topo.Tablet
zkTabletPath := TabletPathForAlias(tabletAlias)
f := func(oldValue string, oldStat zk.Stat) (string, error) {
if oldValue == "" {
return "", fmt.Errorf("no data for tablet addr update: %v", tabletAlias)
}
tablet, err := tabletFromJson(oldValue)
if err != nil {
return "", err
}
if err := update(tablet); err != nil {
return "", err
}
lastTablet = tablet
return jscfg.ToJson(tablet), nil
}
err := zkts.zconn.RetryChange(zkTabletPath, 0, zookeeper.WorldACL(zookeeper.PERM_ALL), f)
if err != nil {
if zookeeper.IsError(err, zookeeper.ZNONODE) {
err = topo.ErrNoNode
}
return err
}
if lastTablet != nil {
event.Dispatch(&events.TabletChange{
Tablet: *lastTablet,
Status: "updated",
})
}
return nil
}
// TestWriteError checks that we don't panic on a write error.
func TestWriteError(t *testing.T) {
writer = &fakeWriter{err: fmt.Errorf("forced error")}
event.Dispatch(&TestEvent{priority: syslog.LOG_EMERG})
}