def silence(__once=[]):
  if __once:
    return
  __once.append(0)

  zookeeper.set_debug_level(zookeeper.LOG_LEVEL_ERROR)
  zookeeper.set_log_stream(file("/dev/null", "w"))

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 __init__(self, **config):
        if config.has_key('logger_name'):
            self.logger = logging.getLogger(config['logger_name'])
        else:
            self.logger = Null()

        # zookeeper client log
        try:
            zklogfile_path, zklog_level = config.get("ZookeeperLog", ("/dev/stderr", "WARN"))
            _f = open(zklogfile_path,'a')
        except Exception as err:
            self.logger.error("In init ZKeeperClient: %s" % str(err))
        else:
            zookeeper.set_log_stream(_f)
            zookeeper.set_debug_level(LOG_LEVELS.get(zklog_level, zookeeper.LOG_LEVEL_WARN))

        try:
            self.connection_timeout = config['timeout']
            self.zkhosts = config['host']
        except KeyError as err:
            self.logger.exception("Cann't init ZKeeperClient: %s" % str(err))

        self.connected = False
        self.zkhandle = None
        if self.connect():
            self.logger.info('Connected to Zookeeper succesfully')

    def _getLogObserver(self):

        if self._logfilename == "-":
            log_file = sys.stdout
        else:
            log_file = open(self._logfilename, "a")

        # Setup file logger
        log_handler = logging.StreamHandler(log_file)
        formatter = logging.Formatter(
            "%(asctime)s: %(name)[email protected]%(levelname)s: %(message)s")
        log_handler.setFormatter(formatter)

        # Also capture zookeeper logs (XXX not compatible with rotation)
        zookeeper.set_log_stream(log_file)
        zookeeper.set_debug_level(0)

        # Configure logging.
        root = logging.getLogger()
        root.addHandler(log_handler)
        root.setLevel(logging.getLevelName(self._loglevel))

        # Twisted logging is painfully verbose on twisted.web, and
        # there isn't a good way to distinguish different channels
        # within twisted, so just utlize error level logging only for
        # all of twisted.
        twisted_log = logging.getLogger("twisted")
        twisted_log.setLevel(logging.ERROR)

        observer = PythonLoggingObserver()
        return observer.emit

    def test_wait_for_initialize(self):
        """
        A connection to a zookeeper that is running, but whose juju state
        is not ready, should wait until that state is ready.
        """
        client = ZookeeperClient()
        self.client = client  # for poke_zk
        self.mock_connect(False, succeed(client))
        self.mocker.replay()

        zookeeper.set_debug_level(0)
        yield client.connect(get_test_zookeeper_address())

        provider = DummyProvider(ProviderMachine("i-amok", "foo.example.com"))
        d = provider.connect()
        client_result = []
        d.addCallback(client_result.append)

        # Give it a chance to do it incorrectly.
        yield self.poke_zk()

        try:
            self.assertEquals(client_result, [])
            yield client.create("/initialized")
            yield d
            self.assertTrue(client_result, client_result)
            self.assertIdentical(client_result[0], client)
        finally:
            deleteTree("/", client.handle)
            client.close()

 def __init__(self, hosts='127.0.0.1:2181', service_name='tutorial', 
     node_name=None, node_data=None, is_provider=False, logger=None):
     self._hosts = hosts
     self._service_name = service_name
     if node_name is None:
         self._node_name = socket.gethostname()
     else:
         self._node_name = node_name
     self._node_data = node_data if node_data is dict else {}
     self._is_provider = is_provider
     if logger is None:
         self._logger = logging.getLogger(__name__)
     else:
         self._logger = logger
         
     if self._logger.level == logging.DEBUG:
         zk_debug_level = zookeeper.LOG_LEVEL_DEBUG
     elif self._logger.level == logging.WARN:
         zk_debug_level = zookeeper.LOG_LEVEL_WARN
     elif self._logger.level == logging.INFO:
         zk_debug_level = zookeeper.LOG_LEVEL_INFO
     else:
         zk_debug_level = zookeeper.LOG_LEVEL_ERROR
     
     zookeeper.set_debug_level(zk_debug_level)
     
     self._init_handle()

 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 setUp(self):
     super(ClientSessionTests, self).setUp()
     self.cluster.start()
     self.client = None
     self.client2 = None
     zookeeper.deterministic_conn_order(True)
     zookeeper.set_debug_level(0)

    def test_full_run(self):
        """Verify a functional agent start via the 'run' method.

        This test requires Zookeeper running on the default port of localhost.
        The mocked portions are to prevent the daemon start from altering the
        test environment (sys.stdout/sys.stderr, and reactor start).
        """
        zookeeper.set_debug_level(0)
        started = Deferred()

        class DummyAgent(BaseAgent):
            started = False

            def start(self):
                started.callback(self)

        def validate_started(agent):
            self.assertTrue(agent.client.connected)

        started.addCallback(validate_started)

        pid_file = self.makeFile()
        self.change_args("es-agent", "--zookeeper-servers", get_test_zookeeper_address(), "--pidfile", pid_file)
        runner = self.mocker.patch(AgentRunner)
        logger = self.mocker.patch(AppLogger)
        logger.start(MATCH_APP)
        runner.startReactor(None, sys.stdout, sys.stderr)
        logger.stop()
        self.mocker.replay()
        DummyAgent.run()
        return started

 def setUp(self):
     self.log = self.capture_logging("juju.state.init")
     zookeeper.set_debug_level(0)
     self.client = ZookeeperClient(get_test_zookeeper_address())
     self.identity = make_identity("admin:genie")
     self.layout = StateHierarchy(
         self.client, self.identity, "i-abcdef", "dummy")
     return self.client.connect()

    def register(self):
        ZOO_OPEN_ACL_UNSAFE = {"perms":zookeeper.PERM_ALL, "scheme":"world", "id" :"anyone"}
        ZOO_ACL_READ = {"perms":zookeeper.PERM_READ, "scheme": "world","id":"anyone"}
        zookeeper.set_debug_level(2)
        self.zk = zookeeper.init('192.168.86.4:2181,192.168.86.14:2181,192.168.86.15:2181/Crawler')

        data ="%s:%s" %(self.worker.get_ip(), self.worker.get_port())
        ret = zookeeper.create(self.zk, "/%s" %data, data, [ZOO_OPEN_ACL_UNSAFE], zookeeper.EPHEMERAL)

 def tearDown(self):
     super(NodeTest, self).tearDown()
     deleteTree(handle=self.client.handle)
     if self.client.connected:
         self.client.close()
     if self.client2 and self.client2.connected:
         self.client2.close()
     zookeeper.set_debug_level(zookeeper.LOG_LEVEL_DEBUG)

 def setUp(self):
     super(ConnectionTest, self).setUp()
     self.username = pwd.getpwuid(os.getuid())[0]
     self.log = self.capture_logging("juju.state.sshforward")
     self.old_user_name = SSHClient.remote_user
     SSHClient.remote_user = self.username
     self.client = SSHClient()
     zookeeper.set_debug_level(0)

    def __init__(self, config):
        # zoopy is really friggin' loud without this
        zookeeper.set_debug_level(0)

        connection_string = config["hostsource"]["connection-string"]
        self.client = ZookeeperClient(connection_string, session_timeout=3000)
        self.user = config["hostsource"]["user"]
        self.password = config["hostsource"]["password"]

def main():
    zk_server = "10.232.71.108:2181,10.221.224.131:2181,10.104.145.101:2181"
    zookeeper.set_debug_level(zookeeper.LOG_LEVEL_ERROR)
    try:
        zk = zookeeper.init(zk_server)
        get_job_list(zk)
    except Exception, e:
        print "Create zookeeper session Failed:%s" % e

    def start(self) :
        self.conn_wr.acquire()

        try :
            if self.thread_ptr != None :
                print "NameService already started."
                return False

            if (self.servers == None) or (len(self.servers) == 0) :
                print "'Servers' needed."
                return False

            if (len(self.service_name) == 0) and (len(self.watch_service_set) == 0) :
                print "Must register service or watch services."
                return False

            #self.local_ip = self.__get_local_ip_address__(LOCAL_IP_ETH_NAME)

            if (self.ip_method != None) and (len(self.ip_method) != 0) :
                self.local_ip = self.__get_local_ip_address__(self.ip_method)

                if len(self.local_ip) == 0 :
                    print "Failed to get local ip : ip_method(%s)." % str(self.ip_method)
                    return False

            else :
                self.local_ip = self.__get_local_ip_address__(LOCAL_IP_BOND_NAME)

                if len(self.local_ip) == 0 :
                    print "Failed to get local ip : ip_method(%s)." % LOCAL_IP_BOND_NAME

                    self.local_ip = self.__get_local_ip_address__(LOCAL_IP_EM_NAME)

                    if len(self.local_ip) == 0 :
                        print "Failed to get local ip : ip_method(%s)." % LOCAL_IP_EM_NAME
                        return False

            print "Got [%s]'s ip : %s" % (self.ip_method, self.local_ip)


            for watch_item in self.watch_service_set :
                self.watch_service_info_dict[watch_item] = {"host_list" : [], "rewatch_ts" : 0}

            zookeeper.set_debug_level(zookeeper.LOG_LEVEL_WARN)

            self.thread_ptr = threading.Thread(target=self.__thread_main__, args=())

            if self.thread_ptr == None :
                print "Failed to create thread."
                return False

            self.thread_ptr.start()

            return True

        except Exception, e :
            print "Exception in start() :", Exception, e
            return False

 def setUp(self):
     self.provider = MachineProvider(
         "local-test", {
             "admin-secret": "admin:abc", "data-dir": self.makeDir(),
             "authorized-keys": "fooabc123"})
     self.output = self.capture_logging(
         "juju.local-dev", level=logging.DEBUG)
     zookeeper.set_debug_level(0)
     self.client = yield self.get_zookeeper_client().connect()

def setup_logging(options):
    level = logging.DEBUG if options.verbose else logging.INFO
    logging.basicConfig(
        format="%(asctime)s %(levelname)s %(message)s",
        level=level,
        stream=options.log_file)

    if level is not logging.DEBUG:
        zookeeper.set_debug_level(0)

 def tearDown(self):
     zookeeper.set_debug_level(0)
     if self.proxied_client.connected:
         yield self.proxied_client.close()
     if not self.direct_client.connected:
         yield self.direct_client.connect()
     utils.deleteTree(handle=self.direct_client.handle)
     yield self.direct_client.close()
     self.proxy.lose_connection()
     yield self.proxy_port.stopListening()

def main():
    given_args = opt_parser()
    server = '10.232.71.108:2181,10.221.224.131:2181,10.104.145.101:2181'
    root_path = given_args.root_path
    action =  given_args.action
    zookeeper.set_debug_level(zookeeper.LOG_LEVEL_ERROR)
    try:
        zk = zookeeper.init(server)
    except Exception, e:
        print "Create zookeeper session Failed:%s" %e