func getActions(wr *wrangler.Wrangler, zconn zk.Conn, actionPath string) ([]*actionnode.ActionNode, error) {
actions, _, err := zconn.Children(actionPath)
if err != nil {
return nil, fmt.Errorf("getActions failed: %v %v", actionPath, err)
}
sort.Strings(actions)
wg := sync.WaitGroup{}
mu := sync.Mutex{}
nodes := make([]*actionnode.ActionNode, 0, len(actions))
for _, action := range actions {
wg.Add(1)
go func(action string) {
defer wg.Done()
actionNodePath := path.Join(actionPath, action)
data, _, err := zconn.Get(actionNodePath)
if err != nil && !zookeeper.IsError(err, zookeeper.ZNONODE) {
wr.Logger().Warningf("getActions: %v %v", actionNodePath, err)
return
}
actionNode, err := actionnode.ActionNodeFromJson(data, actionNodePath)
if err != nil {
wr.Logger().Warningf("getActions: %v %v", actionNodePath, err)
return
}
mu.Lock()
nodes = append(nodes, actionNode)
mu.Unlock()
}(action)
}
wg.Wait()
return nodes, nil
}
// return a few values that need to be refreshed
func (zkc *ZkCache) refreshSomeValues(zconn zk.Conn, maxToRefresh int) {
// build a list of a few values we want to refresh
refreshThreshold := time.Now().Add(-10 * time.Minute)
// range will randomize the traversal order, so we will not always try
// the same entries in the same order
dataEntries := make([]*zkCacheEntry, 0, maxToRefresh)
childrenEntries := make([]*zkCacheEntry, 0, maxToRefresh)
zkc.mutex.Lock()
for _, entry := range zkc.Cache {
shouldBeDataRefreshed, shouldBeChildrenRefreshed := entry.checkForRefresh(refreshThreshold)
if shouldBeDataRefreshed {
dataEntries = append(dataEntries, entry)
}
if shouldBeChildrenRefreshed {
childrenEntries = append(childrenEntries, entry)
}
// check if we have enough work to do
if len(dataEntries) == maxToRefresh || len(childrenEntries) == maxToRefresh {
break
}
}
zkc.mutex.Unlock()
// now refresh the values
for _, entry := range dataEntries {
data, stat, watch, err := zconn.GetW(entry.node.Path)
if err == nil {
zkStat := &zk.ZkStat{}
zkStat.FromZookeeperStat(stat)
entry.updateData(data, zkStat, watch)
} else if zookeeper.IsError(err, zookeeper.ZCLOSING) {
// connection is closing, no point in asking for more
relog.Warning("failed to refresh cache: %v (and stopping refresh)", err.Error())
return
} else {
// individual failure
relog.Warning("failed to refresh cache: %v", err.Error())
}
}
for _, entry := range childrenEntries {
children, stat, watch, err := zconn.ChildrenW(entry.node.Path)
if err == nil {
zkStat := &zk.ZkStat{}
zkStat.FromZookeeperStat(stat)
entry.updateChildren(children, zkStat, watch)
} else if zookeeper.IsError(err, zookeeper.ZCLOSING) {
// connection is closing, no point in asking for more
relog.Warning("failed to refresh cache: %v (and stopping refresh)", err.Error())
return
} else {
// individual failure
relog.Warning("failed to refresh cache: %v", err.Error())
}
}
}
func ReadAddrs(zconn zk.Conn, zkPath string) (*ZknsAddrs, error) {
data, stat, err := zconn.Get(zkPath)
if err != nil {
return nil, err
}
addrs := new(ZknsAddrs)
err = json.Unmarshal([]byte(data), addrs)
if err != nil {
return nil, err
}
addrs.version = stat.Version()
return addrs, nil
}
// ReadAddrs returns a ZknsAddrs record from the given path in Zookeeper.
func ReadAddrs(zconn zk.Conn, zkPath string) (*ZknsAddrs, error) {
data, stat, err := zconn.Get(zkPath)
if err != nil {
return nil, err
}
// There are nodes that will have no data - for instance a subdomain node.
if len(data) == 0 {
return nil, nil
}
addrs := new(ZknsAddrs)
err = json.Unmarshal([]byte(data), addrs)
if err != nil {
return nil, err
}
addrs.version = stat.Version()
return addrs, nil
}
func (wr *Wrangler) exportVtnsToZkns(ctx context.Context, zconn zk.Conn, vtnsAddrPath, zknsAddrPath string) ([]string, error) {
zknsPaths := make([]string, 0, 32)
parts := strings.Split(vtnsAddrPath, "/")
if len(parts) != 8 && len(parts) != 9 {
return nil, fmt.Errorf("Invalid leaf zk path: %v", vtnsAddrPath)
}
cell := parts[2]
keyspace := parts[5]
shard := parts[6]
tabletType := topo.TabletType(parts[7])
if tabletType == "action" || tabletType == "actionlog" {
return nil, nil
}
addrs, _, err := wr.ts.GetEndPoints(ctx, cell, keyspace, shard, tabletType)
if err != nil {
return nil, err
}
// Write the individual endpoints and compute the SRV entries.
vtoccAddrs := LegacyZknsAddrs{make([]string, 0, 8)}
defaultAddrs := LegacyZknsAddrs{make([]string, 0, 8)}
for i, entry := range addrs.Entries {
zknsAddrPath := fmt.Sprintf("%v/%v", zknsAddrPath, i)
zknsPaths = append(zknsPaths, zknsAddrPath)
zknsAddr := zkns.ZknsAddr{
Host: entry.Host,
PortMap: entry.PortMap,
}
err := writeAddr(zconn, zknsAddrPath, &zknsAddr)
if err != nil {
return nil, err
}
defaultAddrs.Endpoints = append(defaultAddrs.Endpoints, zknsAddrPath)
vtoccAddrs.Endpoints = append(vtoccAddrs.Endpoints, zknsAddrPath+":vt")
}
// Prune any zkns entries that are no longer referenced by the
// shard graph.
deleteIdx := len(addrs.Entries)
for {
zknsStaleAddrPath := fmt.Sprintf("%v/%v", zknsAddrPath, deleteIdx)
// A "delete" is a write of sorts - just communicate up that nothing
// needs to be done to this node.
zknsPaths = append(zknsPaths, zknsStaleAddrPath)
err := zconn.Delete(zknsStaleAddrPath, -1)
if zookeeper.IsError(err, zookeeper.ZNONODE) {
break
}
if err != nil {
return nil, err
}
deleteIdx++
}
// Write the VDNS entries for both vtocc and mysql
vtoccVdnsPath := fmt.Sprintf("%v/vt.vdns", zknsAddrPath)
zknsPaths = append(zknsPaths, vtoccVdnsPath)
if err = writeAddrs(zconn, vtoccVdnsPath, &vtoccAddrs); err != nil {
return nil, err
}
defaultVdnsPath := fmt.Sprintf("%v.vdns", zknsAddrPath)
zknsPaths = append(zknsPaths, defaultVdnsPath)
if err = writeAddrs(zconn, defaultVdnsPath, &defaultAddrs); err != nil {
return nil, err
}
return zknsPaths, nil
}