func recursiveDelete(c *zk.Conn, path string) error { children, _, err := c.Children(path) if err != nil && err != zk.ErrNoNode { logError("err finding children of %s", path) return err } for _, child := range children { err := recursiveDelete(c, path+"/"+child) if err != nil && err != zk.ErrNoNode { logError("err deleting %s", child) return err } } // get version _, stat, err := c.Get(path) if err != nil && err != zk.ErrNoNode { logError("err getting version of %s", path) return err } if err := c.Delete(path, stat.Version); err != nil && err != zk.ErrNoNode { return err } return nil }
func All(conn *zk.Conn, zkConf conf.Zookeeper) (map[string]Service, error) { err := ensurePathExists(conn, zkConf.Path) if err != nil { return nil, err } services := map[string]Service{} keys, _, err2 := conn.Children(zkConf.Path) if err2 != nil { return nil, err2 } for _, childPath := range keys { bite, _, e := conn.Get(zkConf.Path + "/" + childPath) if e != nil { return nil, e break } appId, _ := unescapeSlashes(childPath) services[appId] = Service{Id: appId, Acl: string(bite)} } return services, nil }
func DeleteNodebyData(path string, conn *zk.Conn, data []byte) error { children, _, err := conn.Children(path) if err != nil { glog.Warning("Could not list children") return err } for _, child := range children { child_path := path + "/" + child child_data, _, err := conn.Get(child_path) if err != nil { glog.Warning("Could not get data for %s", child_path) continue } if bytes.Compare(data, child_data) == 0 { for i := 0; i < 5; i++ { _, stats, _ := conn.Get(child_path) err = conn.Delete(child_path, stats.Version) if err == nil || err == zk.ErrNoNode { return nil } } glog.Error("Could not delete matched node %s", child_path) } } return nil }
func DeleteRecursive(zconn zookeeper.Conn, zkPath string, version int) error { // version: -1 delete any version of the node at path - only applies to the top node err := zconn.Delete(zkPath, int32(version)) if err == nil { return nil } if !ZkErrorEqual(err, zookeeper.ErrNotEmpty) { return err } // Remove the ability for other nodes to get created while we are trying to delete. // Otherwise, you can enter a race condition, or get starved out from deleting. _, err = zconn.SetACL(zkPath, zookeeper.WorldACL(zookeeper.PermAdmin|zookeeper.PermDelete|zookeeper.PermRead), int32(version)) if err != nil { return err } children, _, err := zconn.Children(zkPath) if err != nil { return err } for _, child := range children { err := DeleteRecursive(zconn, path.Join(zkPath, child), -1) if err != nil && !ZkErrorEqual(err, zookeeper.ErrNoNode) { return fmt.Errorf("zkutil: recursive delete failed: %v", err) } } err = zconn.Delete(zkPath, int32(version)) if err != nil && !ZkErrorEqual(err, zookeeper.ErrNotEmpty) { err = fmt.Errorf("zkutil: nodes getting recreated underneath delete (app race condition): %v", zkPath) } return err }
func mirrorNode(conn *zk.Conn, node *NodeTree) error { var err error var children []string nodePath := appendPath(node.PathPrefix, node.Name) if children, _, err = conn.Children(nodePath); err != nil { return err } for _, child := range children { var data []byte childPath := appendPath(nodePath, child) if data, _, err = conn.Get(childPath); err != nil { return err } childNode := NewNodeTree(child, nodePath, data) node.AddChild(childNode) if err := mirrorNode(conn, childNode); err != nil { return err } } return nil }
// The lexically lowest node is the lock holder - verify that this // path holds the lock. Call this queue-lock because the semantics are // a hybrid. Normal zookeeper locks make assumptions about sequential // numbering that don't hold when the data in a lock is modified. // if the provided 'interrupted' chan is closed, we'll just stop waiting // and return an interruption error func ObtainQueueLock(zconn zookeeper.Conn, zkPath string, wait time.Duration, interrupted chan struct{}) error { queueNode := path.Dir(zkPath) lockNode := path.Base(zkPath) timer := time.NewTimer(wait) trylock: children, _, err := zconn.Children(queueNode) if err != nil { return fmt.Errorf("zkutil: trylock failed %v", err) } sort.Strings(children) if len(children) > 0 { if children[0] == lockNode { return nil } if wait > 0 { prevLock := "" for i := 1; i < len(children); i++ { if children[i] == lockNode { prevLock = children[i-1] break } } if prevLock == "" { return fmt.Errorf("zkutil: no previous queue node found: %v", zkPath) } zkPrevLock := path.Join(queueNode, prevLock) _, stat, watch, err := zconn.ExistsW(zkPrevLock) if err != nil { return fmt.Errorf("zkutil: unable to watch queued node %v %v", zkPrevLock, err) } if stat == nil { goto trylock } select { case <-timer.C: break case <-interrupted: return ErrInterrupted case <-watch: // The precise event doesn't matter - try to read again regardless. goto trylock } } return ErrTimeout } return fmt.Errorf("zkutil: empty queue node: %v", queueNode) }
func walkChildrenRecursively(conn *zk.Conn, path string, walkfunc func(string)) error { children, _, err := conn.Children(path) if err != nil { return err } sort.Strings(children) for _, child := range children { if path == "/" { walkfunc(path + child) err = walkChildrenRecursively(conn, path+child, walkfunc) } walkfunc(path + "/" + child) err = walkChildrenRecursively(conn, path+"/"+child, walkfunc) } return err }
// GetNodes get all child from zk path. func GetNodes(conn *zk.Conn, path string) ([]string, error) { nodes, stat, err := conn.Children(path) if err != nil { if err == zk.ErrNoNode { return nil, ErrNodeNotExist } glog.Errorf("zk.Children(\"%s\") error(%v)", path, err) return nil, err } if stat == nil { return nil, ErrNodeNotExist } if len(nodes) == 0 { return nil, ErrNoChild } return nodes, nil }
func childrenRecursive(zconn *zookeeper.Conn, path string, incrementalPath string) ([]string, error) { children, _, err := zconn.Children(path) if err != nil { return children, err } sort.Sort(sort.StringSlice(children)) recursiveChildren := []string{} for _, child := range children { incrementalChild := gopath.Join(incrementalPath, child) recursiveChildren = append(recursiveChildren, incrementalChild) incrementalChildren, err := childrenRecursive(zconn, gopath.Join(path, child), incrementalChild) if err != nil { return children, err } recursiveChildren = append(recursiveChildren, incrementalChildren...) } return recursiveChildren, err }
func (z *Zookeeper) znodeTree(conn *zk.Conn, keyPath string, nextKeyPath string) ([]string, error) { children, _, err := conn.Children(keyPath) if err != nil { return children, err } sort.Sort(sort.StringSlice(children)) nested := []string{} for _, child := range children { nextChild := path.Join(nextKeyPath, child) nested = append(nested, nextChild) nestedChildren, err := z.znodeTree(conn, path.Join(keyPath, child), nextChild) if err != nil { return children, err } nested = append(nested, nestedChildren...) } return nested, err }
func ZkGetChildren(zkConn *zk.Conn, root string) []string { children, stat, err := zkConn.Children(root) if err != nil { if err == zk.ErrNoNode { return nil } fmt.Printf("zk.ChildrenW(\"%s\") error(%v)", root, err) return nil } if stat == nil { return nil } if len(children) == 0 { return nil } return children }
func ChildrenRecursive(zconn zookeeper.Conn, zkPath string) ([]string, error) { var err error mutex := sync.Mutex{} wg := sync.WaitGroup{} pathList := make([]string, 0, 32) children, _, err := zconn.Children(zkPath) if err != nil { return nil, err } for _, child := range children { wg.Add(1) go func(child string) { childPath := path.Join(zkPath, child) rChildren, zkErr := ChildrenRecursive(zconn, childPath) if zkErr != nil { // If other processes are deleting nodes, we need to ignore // the missing nodes. if !ZkErrorEqual(zkErr, zookeeper.ErrNoNode) { mutex.Lock() err = zkErr mutex.Unlock() } } else { mutex.Lock() pathList = append(pathList, child) for _, rChild := range rChildren { pathList = append(pathList, path.Join(child, rChild)) } mutex.Unlock() } wg.Done() }(child) } wg.Wait() mutex.Lock() defer mutex.Unlock() if err != nil { return nil, err } return pathList, nil }
// childrenRecursiveInternal: internal implementation of recursive-children query. func childrenRecursiveInternal(connection *zk.Conn, path string, incrementalPath string) ([]string, error) { children, _, err := connection.Children(path) if err != nil { return children, err } sort.Sort(sort.StringSlice(children)) recursiveChildren := []string{} for _, child := range children { incrementalChild := gopath.Join(incrementalPath, child) recursiveChildren = append(recursiveChildren, incrementalChild) log.Debugf("incremental child: %+v", incrementalChild) incrementalChildren, err := childrenRecursiveInternal(connection, gopath.Join(path, child), incrementalChild) if err != nil { return children, err } recursiveChildren = append(recursiveChildren, incrementalChildren...) } return recursiveChildren, err }
func zkDeleteChildren(conn *zk.Conn, path string) { children, _, _ := conn.Children(path) // Leaf if len(children) == 0 { fmt.Println("Deleting ", path) err := conn.Delete(path, -1) if err != nil { log.Panic(err) } return } // Branches for _, name := range children { zkDeleteChildren(conn, path+"/"+name) } return }
func (this *Get) showChildrenRecursively(conn *zk.Conn, path string) { children, _, err := conn.Children(path) if err != nil { return } sort.Strings(children) for _, child := range children { if path == "/" { path = "" } znode := fmt.Sprintf("%s/%s", path, child) // display znode content data, stat, err := conn.Get(znode) must(err) if stat.EphemeralOwner > 0 { if patternMatched(znode, this.likePattern) { this.Ui.Output(color.Yellow(znode)) } } else { if patternMatched(znode, this.likePattern) { this.Ui.Output(color.Green(znode)) } } if len(data) > 0 && patternMatched(znode, this.likePattern) { if this.verbose { this.Ui.Output(fmt.Sprintf("%s %#v", strings.Repeat(" ", 3), stat)) this.Ui.Output(fmt.Sprintf("%s %v", strings.Repeat(" ", 3), data)) } this.Ui.Output(fmt.Sprintf("%s %s", strings.Repeat(" ", 3), string(data))) } this.showChildrenRecursively(conn, znode) } }
func (this *Ls) showChildrenRecursively(conn *zk.Conn, path string) { children, _, err := conn.Children(path) if err != nil { return } sort.Strings(children) for _, child := range children { if path == "/" { path = "" } znode := path + "/" + child if patternMatched(znode, this.likePattern) { this.Ui.Output(znode) } this.showChildrenRecursively(conn, znode) } }
func (this *Dump) dump(conn *zk.Conn, path string) { children, _, err := conn.Children(path) if err != nil { must(err) return } sort.Strings(children) var buf [4]byte for _, child := range children { if path == "/" { path = "" } znode := fmt.Sprintf("%s/%s", path, child) // display znode content data, stat, err := conn.Get(znode) must(err) if stat.EphemeralOwner > 0 { // ignore ephemeral znodes continue } _, err = this.f.Write([]byte(znode)) must(err) _, err = this.f.Write([]byte{'\n'}) must(err) v := buf[0:4] binary.BigEndian.PutUint32(v, uint32(len(data))) _, err = this.f.Write(v) if len(data) > 0 { _, err = this.f.Write(data) must(err) } this.dump(conn, znode) } }
func (zk *ZookeeperClusterRunner) deleteRecursively(client *zkClient.Conn, key string) { if key != "/zookeeper" { children, _, err := client.Children(key) Ω(err).ShouldNot(HaveOccured(), "Failed to fetch children for '%s'", key) for _, child := range children { childPath := key + "/" + child if key == "/" { childPath = key + child } zk.deleteRecursively(client, childPath) } if key != "/" { err = client.Delete(key, -1) } Ω(err).ShouldNot(HaveOccured(), "Failed to delete key '%s'", key) } return }
func pollZooKeeper(conn *zk.Conn, path string, evts chan zk.Event, quit chan bool) { children, _, err := conn.Children(path) if err != nil { fmt.Printf("%+v", err) panic(err) } watcherControl := make([]chan<- bool, len(children)+2) watcherControl[0] = sinkSelfEvents(conn, path, evts) watcherControl[1] = sinkChildEvents(conn, path, evts) for i, child := range children { p := path + "/" + child watcherControl[i+2] = sinkSelfEvents(conn, p, evts) } <-quit for _, ch := range watcherControl { ch <- true } }
func resolveRecursive(zconn zookeeper.Conn, parts []string, toplevel bool) ([]string, error) { for i, part := range parts { if HasWildcard(part) { var children []string zkParentPath := strings.Join(parts[:i], "/") var err error children, _, err = zconn.Children(zkParentPath) if err != nil { // we asked for something like // /zk/cell/aaa/* and // /zk/cell/aaa doesn't exist // -> return empty list, no error // (note we check both a regular zk // error and the error the test // produces) if ZkErrorEqual(err, zookeeper.ErrNoNode) { return nil, nil } // otherwise we return the error return nil, err } sort.Strings(children) results := make([][]string, len(children)) wg := &sync.WaitGroup{} mu := &sync.Mutex{} var firstError error for j, child := range children { matched, err := path.Match(part, child) if err != nil { return nil, err } if matched { // we have a match! wg.Add(1) newParts := make([]string, len(parts)) copy(newParts, parts) newParts[i] = child go func(j int) { defer wg.Done() subResult, err := resolveRecursive(zconn, newParts, false) if err != nil { mu.Lock() if firstError != nil { log.Infof("Multiple error: %v", err) } else { firstError = err } mu.Unlock() } else { results[j] = subResult } }(j) } } wg.Wait() if firstError != nil { return nil, firstError } result := make([]string, 0, 32) for j := 0; j < len(children); j++ { subResult := results[j] if subResult != nil { result = append(result, subResult...) } } // we found a part that is a wildcard, we // added the children already, we're done return result, nil } } // no part contains a wildcard, add the path if it exists, and done path := strings.Join(parts, "/") if toplevel { // for whatever the user typed at the toplevel, we don't // check it exists or not, we just return it return []string{path}, nil } // this is an expanded path, we need to check if it exists _, stat, err := zconn.Exists(path) if err != nil { return nil, err } if stat != nil { return []string{path}, nil } return nil, nil }
func GetServerList(conn *zk.Conn) (list []string, err error) { list, _, err = conn.Children("/go_servers") return }
}) }) Context("setting a sibling key", func() { BeforeEach(func() { nodeArr[0] = StoreNode{ Key: "/restaurant/menu/lunch", Value: []byte("fried chicken"), TTL: 0, } err := adapter.Set(nodeArr) Ω(err).ShouldNot(HaveOccured()) }) It("should be able to overwrite the key", func() { kiddos, _, err := client.Children("/restaurant/menu") Ω(kiddos).Should(HaveLen(2)) Ω(kiddos).Should(ContainElement("breakfast")) Ω(kiddos).Should(ContainElement("lunch")) Ω(err).ShouldNot(HaveOccured()) }) }) }) Context("when the store is down", func() { BeforeEach(func() { log.SetOutput(ioutil.Discard) zookeeperRunner.Stop() }) AfterEach(func() {
// GetConsumsers 获取consumer的列表 func GetConsumsers(zknode string, zkc *zk.Conn) ([]string, error) { consumers, _, err := zkc.Children(zknode + "/consumers") return consumers, err }
// GetTopicsWithConsumser 获取topic对应的consumer func GetTopicsWithConsumser(zknode string, zkc *zk.Conn, consumer string) ([]string, error) { getzknode := zknode + "/consumers/" + consumer + "/offsets" topics, _, err := zkc.Children(getzknode) return topics, err }