Python zookeeper.close函数代码示例

 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)

    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 connection_handler(handle, type, state, path):
   if self._zh != handle:
     try:
       # latent handle callback from previous connection
       zookeeper.close(handle)
     except:
       pass
     return
   if self._stopped.is_set():
     return
   if self._watch:
     self._watch(self, type, state, path)
   if state == zookeeper.CONNECTED_STATE:
     self._logger('Connection started, setting live.')
     self._live.set()
     self._clear_completions()
   elif state == zookeeper.EXPIRED_SESSION_STATE:
     self._logger('Session lost, clearing live state.')
     self._live.clear()
     self._zh = None
     self._init_count = 0
     self.reconnect()
   else:
     self._logger('Connection lost, clearing live state.')
     self._live.clear()

    def post(self):
	request_dict = self.request.arguments
	node_key = (request_dict['node_tree'])[0]

        cluster_name  = (request_dict['cluster_name'])[0]
        zk=zookeeper.init(self.zk_connect(cluster_name))

        def get_node(node_key):
    	    """获取子节点生成快照存到MySQL"""
            if node_key == "/":
                for node in zookeeper.get_children(zk,node_key):
                     key =  "/" + node
                     if (zookeeper.get(zk,key)[1])['numChildren'] > 0:
                          get_node(key)
                     else:
            	          value = (zookeeper.get(zk,key))[0]
    		          create_time = time.time()
    		          table = ZdSnapshot(cluster_name= cluster_name ,path=key , data=value ,create_time=self.GetNowTime())
    		          table.save()
            else:
                for node in zookeeper.get_children(zk,node_key):
                     key =  node_key + "/" + node
                     if (zookeeper.get(zk,key)[1])['numChildren'] > 0:
                          get_node(key)
                     else:
            	          value = (zookeeper.get(zk,key))[0]
    		          create_time = time.time()
    		          table = ZdSnapshot(cluster_name= cluster_name,path=key , data=value ,create_time=self.GetNowTime())
    		          table.save()
	get_node(node_key)
	self.write("生成快照成功!!!!!")
        zookeeper.close(zk)

    def connect(self, timeout = None):
        '''Connects to the zookeeper server'''
        # if no timeout provided, thake the configured one
        if timeout is None:
            timeout = self._timeout

        # check, if we're already connected
        if self._handle is not None and not self.is_connected():
            raise RuntimeError('Already connected')
            return

        condition = threading.Condition()
        def connection_watch(handle, type, state, path):
            condition.acquire()
            condition.notify()
            condition.release()

        # try to connect
        condition.acquire()
        self._handle = zookeeper.init(
			','.join(self._servers),
            connection_watch,
            self._timeout * 1000)
        condition.wait(self._timeout)
        condition.release()

        if zookeeper.state(self._handle) != zookeeper.CONNECTED_STATE:
            zookeeper.close(self._handle)
            raise RuntimeError(
                'unable to connect to %s ' % (' or '.join(self._servers)))
        zookeeper.set_watcher(self._handle, self.__global_watch)

def main():
	from optparse import OptionParser as OptionParser

	parser = OptionParser()
	parser.add_option('-v', '--verbose', action="store_true", dest="flag_verbose",
		help='Triggers debugging traces')

	(options, args) = parser.parse_args(sys.argv)

	# Logging configuration
	if options.flag_verbose:
		logging.basicConfig(
			format='%(asctime)s %(message)s',
			datefmt='%m/%d/%Y %I:%M:%S',
			level=logging.DEBUG)
	else:
		logging.basicConfig(
			format='%(asctime)s %(message)s',
			datefmt='%m/%d/%Y %I:%M:%S',
			level=logging.INFO)

	if len(args) < 2:
		raise ValueError("not enough CLI arguments")

	ns = args[1]
	cnxstr = load_config().get(ns, 'zookeeper')

	zookeeper.set_debug_level(zookeeper.LOG_LEVEL_INFO)
	zh = zookeeper.init(cnxstr)
	zookeeper.create(zh, PREFIX, '', acl_openbar, 0)
	create_tree(zh, boot_tree())
	init_namespace(zh, ns)
	zookeeper.close(zh)

 def reestablish_connection(self):
   """ Checks the connection and resets it as needed. """
   try:
     zookeeper.close(self.handle)
   except zookeeper.ZooKeeperException, close_exception:
     logging.error("Exception when closing ZK connection {0}".\
       format(close_exception))

 def close(self):
   """ Stops the thread that cleans up failed transactions and closes its
   connection to Zookeeper.
   """
   logging.info("Closing ZK connection")
   self.stop_gc()
   zookeeper.close(self.handle)

    def test_logging(self):
        handler = zope.testing.loggingsupport.InstalledHandler(
            'ZooKeeper')
        try:
            handle = zookeeper.init('zookeeper.example.com:2181')
            zookeeper.close(handle)
        except:
            pass

        wait(lambda : [r for r in handler.records
                       if 'environment' in r.getMessage()]
             )
        handler.clear()

        # Test that the filter for the "Exceeded deadline by" noise works.
        # cheat and bypass zk by writing to the pipe directly.
        os.write(zc.zk._logging_pipe[1],
                 '2012-01-06 16:45:44,572:43673(0x1004f6000):[email protected]'
                 '[email protected]: Exceeded deadline by 27747ms\n')
        wait(lambda : [r for r in handler.records
                       if ('Exceeded deadline by' in r.getMessage()
                           and r.levelno == logging.DEBUG)
                       ]
             )

        self.assert_(not [r for r in handler.records
                          if ('Exceeded deadline by' in r.getMessage()
                              and r.levelno == logging.WARNING)
                          ])

        handler.uninstall()

 def close(self):
     """Close underlying zookeeper connections."""
     zookeeper.close(self.handle)
     self.handle = None
     self.session_id = -1
     self.session_password = ""
     self.connected = False

 def connect(self, first=False):
     try:
         if self._handler:
             zookeeper.close(self._handler)
     except:
         pass
     self._handler = Connection(self._name, self.register_watch_cb, first, self.register_node_cb, *self._args, **self._kwargs).handler

 def close(self):
     """
     close the handle. potentially a blocking call?
     """
     if self._zhandle is not None:
         zookeeper.close(self._zhandle)
         # if closed successfully
         self._zhandle = None

 def close(self):
     if self.connected:
         try:
             zookeeper.close(self.handle)
         except:
             self.log.exception('close')
         self.connected = False
         self.handle = None

def close():
    global handle
    global init_flag
    global connected
    if not init_flag: return
    zookeeper.close(handle)
    init_flag = False
    connected = False

 def _safe_close(self):
   if self._zh is not None:
     zh, self._zh = self._zh, None
     try:
       zookeeper.close(zh)
     except zookeeper.ZooKeeperException:
       # the session has been corrupted or otherwise disconnected
       pass
     self._live.clear()