def _connect(self):
    """Creates a connection to a zookeeper instance."""
    s = []
    for host, port in self._servers:
      try:
        _, _, ips = socket.gethostbyname_ex(host)
        for ip in ips:
          s.append('%s:%s' % (ip, port))
      except socket.gaierror:
        logging.error('Hostname not known: %s', host)
      except socket.herror:
        logging.error('Unable to resolve %s', host)

    if not s:
      logging.error('No IPs found to connect to.. trying again in 1 second.')
      t = threading.Timer(1.0, self._connect)
      t.daemon = True
      t.start()
      return

    if self._clientid is not None:
      # Existing connections get registered with the same clientid that was
      # used before.
      self._zookeeper = zookeeper.init(
          ','.join(s), self._global_watch, None, clientid)
    else:
      self._zookeeper = zookeeper.init(','.join(s), self._global_watch)

    def testhandlereuse(self):
        """
        Test a) multiple concurrent connections b) reuse of closed handles
        """
        cv = threading.Condition()
        self.connected = False
        def connection_watcher(handle, type, state, path):
            cv.acquire()
            self.connected = True
            self.assertEqual(zookeeper.CONNECTED_STATE, state)
            self.handle = handle
            cv.notify()
            cv.release()

        cv.acquire()
        handles = [ zookeeper.init(self.host) for i in xrange(10) ]
        ret = zookeeper.init(self.host, connection_watcher)
        cv.wait(15.0)
        cv.release()
        self.assertEqual(self.connected, True, "Connection timed out to " + self.host)
        self.assertEqual(True, all( [ zookeeper.state(handle) == zookeeper.CONNECTED_STATE for handle in handles ] ),
                         "Not all connections succeeded")
        oldhandle = handles[3]
        zookeeper.close(oldhandle)
        newhandle = zookeeper.init(self.host)

        # This assertion tests *internal* behaviour; i.e. that the module
        # correctly reuses closed handles. This is therefore implementation
        # dependent.
        self.assertEqual(newhandle, oldhandle, "Didn't get reused handle")

    def testmanyhandles(self):
        """
        Test the ability of the module to support many handles.
        """
        # We'd like to do more, but currently the C client doesn't
        # work with > 83 handles (fails to create a pipe) on MacOS 10.5.8
        handles = [ zookeeper.init(self.host) for i in xrange(63) ]

        cv = threading.Condition()
        self.connected = False
        def connection_watcher(handle, type, state, path):
            cv.acquire()
            self.connected = True
            self.assertEqual(zookeeper.CONNECTED_STATE, state)
            self.handle = handle
            cv.notify()
            cv.release()

        cv.acquire()
        ret = zookeeper.init(self.host, connection_watcher)
        cv.wait(15.0)
        cv.release()
        self.assertEqual(self.connected, True, "Connection timed out to " + self.host)

        for i,h in enumerate(handles):
            path = "/zkpython-test-handles-%s" % str(i)
            self.assertEqual(path, zookeeper.create(h, path, "", [ZOO_OPEN_ACL_UNSAFE], zookeeper.EPHEMERAL))

        self.assertEqual(True, all( zookeeper.close(h) == zookeeper.OK for h in handles ))

    def __init__(self, connection_string="127.0.0.1:2181", session_timeout=None,
                 wait=False):
        self.watches = WatchManager()
        self.ephemeral = {}
        self.handle = None

        connected = self.connected = threading.Event()
        def watch_session(handle, event_type, state, path):
            assert event_type == zookeeper.SESSION_EVENT
            assert not path
            if state == zookeeper.CONNECTED_STATE:
                if self.handle is None:
                    self.handle = handle
                    for watch in self.watches.clear():
                        self._watch(watch)
                    for path, data in list(self.ephemeral.items()):
                        zookeeper.create(self.handle, path, data['data'],
                                         data['acl'], data['flags'])
                else:
                    assert handle == self.handle
                connected.set()
                logger.info('connected %s', handle)
            elif state == zookeeper.CONNECTING_STATE:
                connected.clear()
            elif state == zookeeper.EXPIRED_SESSION_STATE:
                connected.clear()
                if self.handle is not None:
                    zookeeper.close(self.handle)
                self.handle = None
                init()
            else:
                logger.critical('unexpected session event %s %s', handle, state)

        if session_timeout:
            init = (lambda : zookeeper.init(connection_string, watch_session,
                                            session_timeout)
                    )
        else:
            init = lambda : zookeeper.init(connection_string, watch_session)

        handle = init()
        connected.wait(self.initial_connection_wait)
        if not connected.is_set():
            if wait:
                while not connected.is_set():
                    logger.critical("Can't connect to ZooKeeper at %r",
                                    connection_string)
                    connected.wait(1)
            else:
                zookeeper.close(handle)
                raise FailedConnect(connection_string)

    def connect(self, servers=None, timeout=10, client_id=None):
        """
        Establish a connection to the given zookeeper server(s).

        @param servers: A string specifying the servers and their ports to
                        connect to. Multiple servers can be specified in
                        comma separated fashion.
        @param timeout: How many seconds to wait on a connection to the
                        zookeeper servers.

        @param session_id:
        @returns A deferred that's fired when the connection is established.
        """
        d = defer.Deferred()

        if self.connected:
            return defer.fail(
                zookeeper.ZooKeeperException("Already Connected"))

        # Use a scheduled function to ensure a timeout.
        def _check_timeout():
            # Close the handle
            try:
                if self.handle is not None:
                    zookeeper.close(self.handle)
            except zookeeper.ZooKeeperException:
                pass
            d.errback(
                ConnectionTimeoutException("could not connect before timeout"))

        scheduled_timeout = reactor.callLater(timeout, _check_timeout)

        # Assemble an on connect callback with closure variable access.
        callback = partial(self._cb_connected, scheduled_timeout, d)
        callback = self._zk_thread_callback(callback)

        if self._session_timeout is None:
            self._session_timeout = DEFAULT_SESSION_TIMEOUT

        if servers is not None:
            self._servers = servers

        # Use client id if specified.
        if client_id:
            self.handle = zookeeper.init(
                self._servers, callback, self._session_timeout, client_id)
        else:
            self.handle = zookeeper.init(
                self._servers, callback, self._session_timeout)
        return d

    def connect_async(self):
        """Asynchronously initiate connection to ZK

        @return: AsyncResult object set on connection success
        @rtype AsyncResult
        """

        cb = self._wrap_session_callback(self._session_callback)
        if self._provided_client_id:
            self._handle = zookeeper.init(self._hosts, cb, self._timeout,
                self._provided_client_id)
        else:
            self._handle = zookeeper.init(self._hosts, cb, self._timeout)

        return self._connected_async_result

    def __init__(self, server, root_node, host='localhost', port=2181):
        self.root = root_node
        self.host = host
        self.port = port
        self.counter = random.randint(0,2**30)
        self.server = server
        self.zcv = Condition() 

        def watcher(handle,type,state,path):
            print "Z connected (%s:%s)" % (self.host, self.port)
            self.zcv.acquire()
            self.connected = True
            self.zcv.notify()
            self.zcv.release()

        self.zcv.acquire()
        self.connected = False

        self.handle = z.init("%s:%s"%(self.host,self.port), watcher, 10000, 0)
        self.zcv.wait(10.0)

        if not self.connected:
            print "Connection to Z cluster timed out - is a server running on %s:%s?" % (self.host,self.port)
            self.connected = False
            self.zcv.release()
            return
        self.zcv.release()

        # make sure root node exists
        try:
            self.create(self.root,"RACS root node", [ZOO_OPEN_ACL_UNSAFE])
        except IOError, e:
            if e.args[0] != z.zerror(z.NODEEXISTS):
                raise e

    def __init__(self, barriername, number_of_workers):
	self.cv = threading.Condition()
	self.connected = False
	self.barrier = "/" + barriername
	self.workers = number_of_workers
	zookeeper.set_log_stream(open('/dev/null'))
	def watcher(handle, type, state, path):
	    self.cv.acquire()
	    self.connected = True
	    self.cv.notify()
	    self.cv.release()

	self.cv.acquire()
	self.handle = zookeeper.init("localhost:2181", watcher, 10000)
	self.cv.wait(10.0)
	if not self.connected:
            print "Connection to ZooKeeper cluster timed out - is a server running on localhost:2181?"
            sys.exit()
	self.cv.release()
	try:
	    zookeeper.create(self.handle, self.barrier, '\x00', [ZOO_OPEN_ACL_UNSAFE], 0)
	except zookeeper.NodeExistsException:
	    pass
	except Exception, ex:
	    print ex
	    raise ex

    def __init__(self, setting):
        #Connect to ZK servers
        print "Connecting to ZooKeeper ... "
        self.connected = False
        self.log = open("zookeeper.log", 'a')
        self.log.write("\n\n=============\nZOOKEEPER LOG\n=============\n")
        self.log.write(datetime.now().__str__())
        zookeeper.set_log_stream(self.log)
        self.cv = threading.Condition()
        self.cv2 = threading.Condition()
        def watcher (handle, type, state, path):
            self.cv.acquire()
            if state == zookeeper.CONNECTED_STATE:
                print "Connected!"
                self.connected = True
            else:
                print "Disconnected from ZooKeeper: ",
                print zookeeper.zerror(state)
            self.cv.notify()
            self.cv.release()
        
        self.cv.acquire()
        self.zh = zookeeper.init(setting.zookeeperloc, watcher, 10000)
        self.cv.wait(10.0)
        if not self.connected:
            print "Cannot connect to ZooKeeper. ",
            print "Check that server(s) are on " + setting.zookeeperloc
            sys.exit()
        self.cv.release()

        self.root = setting.zookeeperroot
        self.createRootNode(self.root)
        self.zpath = '/'

    def post(self):
	request_dict = self.request.arguments
	node_key = (request_dict['node_key'])[0]
        cluster_name  = (request_dict['cluster_name'])[0]
        zk=zookeeper.init(self.zk_connect(cluster_name))


        data = []
        def get_node_tree(node_key):
            if node_key == "/":
                for node in zookeeper.get_children(zk,node_key):
                     key =  "/" + node
                     if (zookeeper.get(zk,key)[1])['numChildren'] > 0:
                          get_node_tree(key)
                          print key
                     else:
                          print key
            else:
                for node in zookeeper.get_children(zk,node_key):
                     key =  node_key + "/" + node
                     if (zookeeper.get(zk,key)[1])['numChildren'] > 0:
                          get_node_tree(key)
                          data.append(key)
                     else:
                          data.append(key)
        
            return data

	get_node_tree(node_key)
	data.append(node_key)

	for items in data:
	    zookeeper.delete(zk,items)
        zookeeper.close(zk)                                                                                                                          
        self.write("删除成功")

def connect(servers):
    cond = threading.Condition()
    connected = [False]

    # We attempt a connection for 10 seconds here. This is a long timeout
    # for servicing a web request, so hopefully it is successful.
    def connect_watcher(zh, event, state, path):
        logging.debug("CONNECT WATCHER: event=%s, state=%s, path=%s" % (event, state, path))
        try:
            cond.acquire()
            if state == zookeeper.CONNECTED_STATE:
                # We only want to notify the main thread once the state has been
                # connected. We store the connected variable in an odd way because
                # of the way variables are bound in the local scope for functions.
                connected[0] = True
                cond.notify()
        finally:
            cond.release()

    cond.acquire()
    try:
        # We default to port 2181 if no port is provided as part of the host specification.
        server_list = ",".join(map(lambda x: (x.find(":") > 0 and x) or "%s:2181" % x, servers))
        handle = zookeeper.init(server_list, connect_watcher, 10000)
        cond.wait(60.0)
    finally:
        # Save whether we were successful or not.
        is_connected = connected[0]
        cond.release()

    if not(is_connected):
        raise ZookeeperException("Unable to connect.")

    return handle

 def start(self):
     self.handle = zookeeper.init(self.servers, self.connection_watcher, self.timeout * 1000)
     self.conn_cv.acquire()
     self.conn_cv.wait(self.timeout)
     self.conn_cv.release()
     if not self.connected:
         raise TimeoutException

    def __init__(self, servers,port=2181, timeout=TIMEOUT):
        """
        create connection to zookeeper
        @param server e.g. "localhost"
        @param port (std 2181)
        """
        self.connected = False
        self.conn_cv = threading.Condition( )
        self.handle = -1
        #@todo make cross platform
        zookeeper.set_log_stream(open("/dev/null"))   

        self.conn_cv.acquire()

        q.logger.log("Connecting to %s" % (servers))
        start = time.time()
        
        self.handle = zookeeper.init(servers, self._connection_watcher, 30000)
        self.conn_cv.wait(timeout)
        self.conn_cv.release()

        if not self.connected:
            raise RuntimeError("Unable to connect to %s" % (servers))

        q.logger.log("Connected in %d ms, handle is %d" % (int((time.time() - start) * 1000), self.handle))

 def __init__(self,queuename):
     self.connected = False
     self.queuename = "/" + queuename
     self.cv = threading.Condition()
     zookeeper.set_log_stream(open("/dev/null"))        
     def watcher(handle,type,state,path):
         print "Connected"
         self.cv.acquire()
         self.connected = True
         self.cv.notify()
         self.cv.release()
         
     self.cv.acquire()            
     self.handle = zookeeper.init("localhost:2181", watcher, 10000, 0)
     self.cv.wait(10.0)
     if not self.connected:
         print "Connection to ZooKeeper cluster timed out - is a server running on localhost:2181?"
         sys.exit()
     self.cv.release()
     try:
         zookeeper.create(self.handle,self.queuename,"queue top level", [ZOO_OPEN_ACL_UNSAFE],0)
     except IOError, e:
         if e.message == zookeeper.zerror(zookeeper.NODEEXISTS):
             print "Queue already exists"    
         else:
             raise e

    def testconnection(self):
        cv = threading.Condition()
        self.connected = False
        def connection_watcher(handle, type, state, path):
            cv.acquire()
            self.connected = True
            self.assertEqual(zookeeper.CONNECTED_STATE, state)
            self.handle = handle
            cv.notify()
            cv.release()

        cv.acquire()
        ret = zookeeper.init(self.host, connection_watcher)
        cv.wait(15.0)
        cv.release()
        self.assertEqual(self.connected, True, "Connection timed out to " + self.host)
        self.assertEqual(zookeeper.CONNECTED_STATE, zookeeper.state(self.handle))

        self.assertEqual(zookeeper.close(self.handle), zookeeper.OK)
        # Trying to close the same handle twice is an error, and the C library will segfault on it
        # so make sure this is caught at the Python module layer
        self.assertRaises(zookeeper.ZooKeeperException,
                          zookeeper.close,
                          self.handle)

        self.assertRaises(zookeeper.ZooKeeperException,
                          zookeeper.get,
                          self.handle,
                          "/")

def connect(host=None):
    global conn_cv, connected, handle
    global reconnect_host

    if host is None:
        host = "localhost:2181"

    reconnect_host = host

    conn_cv.acquire()
    handle = zookeeper.init(host, my_connection_watcher, 10000)
    while not connected:
        conn_cv.wait()
    conn_cv.release()

    connected = False
    while not connected:
        try:
            zookeeper.create(handle, ROOT, "1", [ZOO_OPEN_ACL_UNSAFE], 0)
            connected = True
        except zookeeper.NodeExistsException as e:
            # No worries
            connected = True
        except zookeeper.ConnectionLossException:
            continue
        except:
            raise

    def __init__(self, servers, acl, timeout=DEFAULT_TIMEOUT):
        """
        zookeeper 操作类的封装
        """
        self.epoch = 0
        self.acl = acl
        self.timeout = timeout
        self.connected = False
        #线程同步对象
        self.conn_cv = threading.Condition()
        self.handle = -1
        #线程尝试获取锁，如果拿到就执行下面的代码，否则等待其他线程通知
        self.conn_cv.acquire()

        self.handle = zookeeper.init(servers, self.conn_watcher, timeout)
        #wait方法会释放锁，然后阻塞，等待其他线程执行notify或者notifyAll方法，如果指定的时间没有得到通知，线程重新获取锁，如果获取到锁，继续执行下面的代码
        self.conn_cv.wait(timeout / 10000)
        #释放锁
        self.conn_cv.release()
        #检查连接状态
        if not self.connected:
            raise ZKClientError("Unable to connect to %s" % (servers))

        if not self.add_auth(scheme=acl["scheme"], id=acl["id"]):
            raise ZKClientError("add_auth to zookeeper fail")

 def __init__(self, config_server_="http://xxx.xxx.com/"):
     self.config_server = config_server_
     self.cache_config = []  
     self.zk_path = "/config"
     self.zklist = self.getZkServer()
     zookeeper.set_debug_level(zookeeper.LOG_LEVEL_ERROR)
     self.zookeeper = zookeeper.init(self.zklist)

    def __init__(self, zkservers, lockname):
        self.connected = False
        self.lockname = "/" + lockname
        self.uuid = str(uuid.uuid4())
        self.cv = threading.Condition()
        self.log = logging.getLogger('zookeeper')

        def connection_watcher(_handle, _type, _state, _path):
            self.cv.acquire()
            self.connected = True
            self.cv.notify()
            self.cv.release()

        self.cv.acquire()
        try:
            self.handle = zookeeper.init(",".join(zkservers), connection_watcher, 4000)
        except:
            self.log.exception('Failed to connect Zookeeper cluster (%r)' % zkservers)
            self.cv.release()
            raise SyncError(SYNC_LOCK_CONNECTION_FAILURE, "Failed to connect to Zookeeper cluster")

        self.cv.wait(4.0)
        if not self.connected:
            self.log.error('Failed to connect to Zookeeper cluster (%r)' % zkservers)
            self.cv.release()
            raise SyncError(SYNC_LOCK_CONNECTION_FAILURE, "Failed to connect to Zookeeper cluster")
        self.cv.release()

  def __init__(self, service_name, connect_string, timeout=DEFAULT_TIMEOUT, default_port=6664):
    self.SERVICE_NODE = "/" + service_name
    self.AVAILABILITY_NODE = self.SERVICE_NODE + "/available"
    self.MEMBERSHIP_NODE = self.SERVICE_NODE + "/members"
    self.connected = False
    self.timeout = timeout
    self.default_port = default_port
    self.conn_cv = threading.Condition()
    self.conn_cv.acquire()
    self.handle = zookeeper.init(connect_string, self.connection_watcher, timeout)
    self.conn_cv.wait(timeout / 1000)
    self.conn_cv.release()
    self.watcher_lock = threading.Lock()
    self.logger = logging.getLogger("sincc")

    if not self.connected:
      raise SinClusterClientError("Unable to connect to %s" % connect_string)

    for path in [self.SERVICE_NODE, self.AVAILABILITY_NODE, self.MEMBERSHIP_NODE]:
      if not zookeeper.exists(self.handle, path):
        zookeeper.create(self.handle, path, "", [ZOO_OPEN_ACL_UNSAFE], 0)
    self.listeners = []
    # Start to watch both /members and /available
    zookeeper.get_children(self.handle, self.MEMBERSHIP_NODE, self.watcher)
    available = zookeeper.get_children(self.handle, self.AVAILABILITY_NODE, self.watcher)
    self.available_nodes = {}
    for node_id in available:
      self.available_nodes[int(node_id)] = Node(int(node_id),
                                                zookeeper.get(self.handle, self.AVAILABILITY_NODE + "/" + node_id)[0])