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 __init__(self, hosts, base_znode, log_level=zookeeper.LOG_LEVEL_ERROR):
self._hosts = hosts
self._base_znode = base_znode
zookeeper.set_debug_level(log_level)
self._handler = None
self._local_cache = None
self._main_version = None
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 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, **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 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 init_client(host=default_host):
global init_flag
global handle
global connected
if init_flag: return False
init_flag = True
connected = False
cond = threading.Condition()
def connection_watcher(handle, type, stat, path):
global connected
with cond:
connected = True
cond.notify()
with cond:
zookeeper.set_debug_level(2)
handle = zookeeper.init(host, connection_watcher)
cond.wait(30.0)
if not connected:
raise Exception("Couldn't connect to host -", host)
return True
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 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 get_connected_handles(cnxstr):
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_WARN)
if cnxstr is None:
return
for shard in cnxstr.split(";"):
zh = zookeeper.init(shard)
yield ZkHandle(zh)
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)s@%(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 __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 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 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 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 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 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 __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 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):
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 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 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 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 main():
from optparse import OptionParser as OptionParser
parser = OptionParser()
parser.add_option(
'-v', '--verbose',
action="store_true", dest="flag_verbose",
help='Triggers debugging traces')
parser.add_option(
'-s', '--smart',
action="store_true", dest="SMART", default=False,
help="Delete onle the members belong to services with multiple" \
" members")
parser.add_option(
'-d', '--dry-run',
action="store_true", dest="DRY", default=False,
help="Do not delete, just print")
parser.add_option(
'-n', '--min-services',
type=int, action="store", dest="NUM", default=4,
help="Do not delete election if less the NUM")
parser.add_option(
'-1', '--alone',
action="store_true", dest="ALONE", default=False,
help="Also consider members alone in their group")
(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 TYPE [TYPE...]")
ns = args[1]
cnxstr = load_namespace_conf(ns)['zookeeper']
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_INFO)
zh = zookeeper.init(cnxstr)
for srvtype in args[2:]:
for group in namespace_tree(ns, srvtype):
logging.debug(">DIR %s", group)
for node in list_problematic_nodes(zh, group, options):
delete_node(zh, node, options)
zookeeper.close(zh)
def setUp(self):
super(EC2ProviderFunctionalTest, self).setUp()
self.username = pwd.getpwuid(os.getuid())[0]
self.log = self.capture_logging("juju")
zookeeper.set_debug_level(0)
juju_branch = "" # get_juju_branch_url()
self.provider = MachineProvider("ec2-functional",
{"control-bucket": "juju-test-%s" % (self.username),
"admin-secret": "magic-beans",
"juju-branch": juju_branch})
def __init__(self, zkservers, credential):
threading.Thread.__init__(self)
logger.debug('Initializing ZooKeeperCommunicator thread.')
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_DEBUG)
self.zh = None
self.zkservers = zkservers
self.lock = threading.Lock()
self.acl = [ZOOKEEPER_OPEN_ACL_UNSAFE]
self.safeMode = True
self.credential = credential
def setUp(self):
self.constraints = ConstraintSet("local").parse([]).with_series("foo")
self.provider = MachineProvider(
"local-test", {
"admin-secret": "admin:abc", "data-dir": self.makeDir(),
"authorized-keys": "fooabc123", "default-series": "oneiric"})
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 __init__(self, zkservers, credential):
threading.Thread.__init__(self)
logger.debug('Initializing ZooKeeperCommunicator thread.')
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_DEBUG)
self.zh = None
self.zkservers = zkservers
self.lock = threading.Lock()
self.acl = [ZOOKEEPER_OPEN_ACL_UNSAFE]
self.safeMode = True
self.credential = credential
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
def __init__(self, **config):
logger_name = config.get("logger_name")
self.logger = logging.getLogger(logger_name) if logger_name else Null()
self.zkhandle = None
self.auth = None
self.cv = threading.Condition()
try:
auth_config = config.get("auth")
if auth_config is not None:
auth_scheme = auth_config["scheme"]
auth_data = auth_config["data"]
self.auth = (auth_scheme, auth_data)
zklogfile_path, zklog_level = config.get("ZookeeperLog", ("/dev/stderr", "WARN"))
self.connection_timeout = config["timeout"]
self.zkhosts = ",".join(config["host"])
except KeyError as err:
self.logger.exception("Missing configuration option: %s", err)
raise
except Exception as err:
self.logger.exception("Unknown configuration error: %s", err)
raise
try:
_f = open(zklogfile_path, "a")
except IOError as err:
self.logger.error("Unable to open logfile %s %s", zklogfile_path, err)
else:
zookeeper.set_log_stream(_f)
zookeeper.set_debug_level(LOG_LEVELS.get(zklog_level.upper(), zookeeper.LOG_LEVEL_WARN))
self.connect()
if zookeeper.state(self.zkhandle) == zookeeper.CONNECTED_STATE:
self.logger.info("Connected to Zookeeper successfully")
else:
raise zookeeper.ZooKeeperException("Unable to connect " "to Zookeeper")
def on_auth_callback(state, result):
with self.cv:
if result == zookeeper.AUTHFAILED:
self.logger.error(zookeeper.zerror(zookeeper.AUTHFAILED))
self.logger.info("on_auth: state %s, result %s", state, result)
self.cv.notify()
if self.auth:
self.logger.info("Auth using %s", self.auth[0])
with self.cv:
res = zookeeper.add_auth(self.zkhandle, self.auth[0], self.auth[1], on_auth_callback)
if res != zookeeper.OK:
self.logger.error("Invalid status %d", zookeeper.zerror(res))
raise Exception("Invalid status")
self.cv.wait(self.connection_timeout)
if zookeeper.state(self.zkhandle) == zookeeper.AUTH_FAILED_STATE:
raise zookeeper.ZooKeeperException("authentication failed")
def setUp(self):
zookeeper.set_debug_level(0)
self.client = yield self.get_zookeeper_client().connect()
self.tokens = TokenDatabase(self.client)
self.admin = Principal("admin", "admin")
yield self.tokens.add(self.admin)
self.policy = SecurityPolicy(self.client, self.tokens)
attach_deferred = self.admin.attach(self.client)
self.client.exists("/")
yield attach_deferred
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 main():
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_WARN)
zh = zookeeper.init('127.0.0.1:2181')
ensure_basedirs(zh)
for f in sys.argv[1:]:
try:
manage_type(zh, f)
print "OK", f
except Exception as e:
print "KO", f, e
zookeeper.close(zh)
def __init__(self, options, args):
threading.Thread.__init__(self)
logger.debug("Initializing MyClass thread.")
if options.verbose:
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_DEBUG)
self.zh = zookeeper.init(options.servers)
if zookeeper.OK != zookeeper.aget(self.zh, self.znode, self.watcher, self.handler):
logger.critical("Unable to get znode! Exiting.")
sys.exit(1)
def setUp(self):
super(NodeTest, self).setUp()
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_ERROR)
self.client = ZookeeperClient("127.0.0.1:2181", 2000)
d = self.client.connect()
self.client2 = None
def create_zoo(client):
client.create("/zoo")
d.addCallback(create_zoo)
return d
def main():
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_WARN)
zh = zookeeper.init('127.0.0.1:2181')
ensure_basedirs(zh)
for f in sys.argv[1:]:
try:
manage_type(zh, f)
print "OK", f
except Exception as e:
print "KO", f, e
zookeeper.close(zh)
def setUp(self):
zookeeper.set_debug_level(0)
self.client = yield self.get_zookeeper_client().connect()
self.tokens = TokenDatabase(self.client)
self.admin = Principal("admin", "admin")
yield self.tokens.add(self.admin)
self.policy = SecurityPolicy(self.client, self.tokens)
attach_deferred = self.admin.attach(self.client)
self.client.exists("/")
yield attach_deferred
def setUp(self):
yield super(StateTestBase, self).setUp()
zookeeper.set_debug_level(0)
self.charm = CharmDirectory(sample_directory)
self.client = self.get_zookeeper_client()
yield self.client.connect()
yield self.client.create("/charms")
yield self.client.create("/machines")
yield self.client.create("/services")
yield self.client.create("/units")
yield self.client.create("/relations")
def __init__(self, options, args):
threading.Thread.__init__(self)
logger.debug('Initializing MyClass thread.')
if options.verbose:
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_DEBUG)
self.zh = zookeeper.init(options.servers)
if zookeeper.OK != zookeeper.aget(self.zh, self.znode, self.watcher,
self.handler):
logger.critical('Unable to get znode! Exiting.')
sys.exit(1)
def _set_log_level(self, log_level_override=''):
stderr_log_level = LogOptions.stderr_log_level()
# set default level to FATAL.
# we do this here (instead of add_option) to distinguish when an override is set.
if stderr_log_level == log.INFO and log_level_override != 'INFO':
stderr_log_level = log.FATAL
# default to using stderr logging level, setting override if applicable
log_level = getattr(log, log_level_override, stderr_log_level)
# set the logger
zk_log_level = ZookeeperLoggingSubsystem._ZK_LOG_LEVEL_MAP.get(
log_level, zookeeper.LOG_LEVEL_ERROR)
zookeeper.set_debug_level(zk_log_level)
def setUp(self):
super(EC2ProviderFunctionalTest, self).setUp()
self.username = pwd.getpwuid(os.getuid())[0]
self.log = self.capture_logging("juju")
zookeeper.set_debug_level(0)
juju_branch = "" # get_juju_branch_url()
self.provider = MachineProvider(
"ec2-functional", {
"control-bucket": "juju-test-%s" % (self.username),
"admin-secret": "magic-beans",
"juju-branch": juju_branch
})
def _set_log_level(self, log_level_override=''):
stderr_log_level = LogOptions.stderr_log_level()
# set default level to FATAL.
# we do this here (instead of add_option) to distinguish when an override is set.
if stderr_log_level == log.INFO and log_level_override != 'INFO':
stderr_log_level = log.FATAL
# default to using stderr logging level, setting override if applicable
log_level = getattr(log, log_level_override, stderr_log_level)
# set the logger
zk_log_level = ZookeeperLoggingSubsystem._ZK_LOG_LEVEL_MAP.get(
log_level, zookeeper.LOG_LEVEL_ERROR)
zookeeper.set_debug_level(zk_log_level)
def __init__(self, zk_servers, path):
if zk_servers is None:
try:
zk_servers = os.environ['ZK_SERVERS']
except KeyError:
logger.critical('No ZooKeeper servers specified! Exiting.')
sys.exit(1)
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_ERROR)
self.zh = zookeeper.init(zk_servers)
self.ZOO_OPEN_ACL_UNSAFE = {'perms': 0x1f,
'scheme': 'world', 'id': 'anyone'}
self.path = path
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')
parser.add_option(
'-c',
'--min-children',
type=int,
action="store",
dest="CHILDREN",
default=15,
help="Do not print the children number if less than that value")
parser.add_option('-s',
'--min-size',
type=int,
action="store",
dest="SIZE",
default=0,
help="Do not print unless the size is over that value")
(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 TYPE [TYPE...]")
ns = args[1]
cnxstr = load_namespace_conf(ns)['zookeeper']
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_INFO)
zh = zookeeper.init(cnxstr)
for srvtype in args[2:]:
for group in namespace_tree(ns, srvtype):
for child, meta in list_nodes(zh, group, options):
if meta['dataLength'] > options.SIZE:
print "NODE", meta['dataLength'], child
zookeeper.close(zh)
def setUp(self):
zookeeper.set_debug_level(0)
self.client = yield SecurityPolicyConnection(
get_test_zookeeper_address()).connect()
admin = Principal("admin", "admin")
self.token_db = TokenDatabase(self.client)
yield self.token_db.add(admin)
self.policy = SecurityPolicy(self.client, self.token_db, owner=admin)
attach_defer = admin.attach(self.client)
# Trick to speed up the auth response processing (fixed in ZK trunk)
self.client.exists("/")
yield attach_defer
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')
parser.add_option('-d',
'--data',
action="store",
dest="VALUE",
default='',
help="Data to force")
(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 TYPE [TYPE...]")
ns = args[1]
cnxstr = load_namespace_conf(ns)['zookeeper']
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_INFO)
zh = zookeeper.init(cnxstr)
for srvtype in args[2:]:
for group in namespace_tree(ns, srvtype):
logging.debug(">DIR %s", group)
for mom, key, first, last in list_groups(zh, group, options):
tail = str(1 + int(last)).rjust(10, '0')
path = mom + '/' + key + '-' + tail
create_node(zh, options, path)
logging.debug("Please send a signal to remove the ephemeral nodes")
logging.warn("PAUSED ...")
signal.pause()
zookeeper.close(zh)
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')
parser.add_option(
'--slow',
action="store_true",
dest="SLOW",
help='Only play with small batches to avoid timeouts on slow hosts.')
parser.add_option(
'--avoid',
action="append",
type="string",
dest="AVOID_TYPES",
help='Do not populate entries for the specified service types')
(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_namespace_conf(ns)['zookeeper']
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_INFO)
zh = zookeeper.init(cnxstr)
# synchronous creation of the root
try:
zookeeper.create(zh, PREFIX, '', acl_openbar, 0)
except zookeeper.NodeExistsException:
pass
create_tree(zh, namespace_tree(ns, options), options)
zookeeper.close(zh)
def set_loglevel(level):
"""
Set the ZooKeeper log level.
Valid arguments are DEBUG|ERROR|INFO|WARN
Arguments:
- `level`: string
Return: None
Exceptions: None
"""
zlevel = getattr(zookeeper, 'LOG_LEVEL_{0}'.format(level))
zookeeper.set_debug_level(zlevel)
return
def setUp(self):
super(CharmPublisherTest, self).setUp()
zookeeper.set_debug_level(0)
self.charm = CharmDirectory(self.sample_dir1)
self.charm_id = local_charm_id(self.charm)
self.charm_key = under.quote(self.charm_id)
# provider storage key
self.charm_storage_key = under.quote(
"%s:%s" % (self.charm_id, self.charm.get_sha256()))
self.client = ZookeeperClient(get_test_zookeeper_address())
self.storage_dir = self.makeDir()
self.storage = FileStorage(self.storage_dir)
self.publisher = CharmPublisher(self.client, self.storage)
yield self.client.connect()
yield self.client.create("/charms")
def main():
usage = "usage: %prog [options] NS"
from optparse import OptionParser as OptionParser
parser = OptionParser(usage=usage)
parser.add_option(
'-v', '--verbose',
action="store_true", dest="flag_verbose",
help='Triggers debugging traces')
parser.add_option(
'-a', '--all',
action="store_true", dest="flag_all",
help='Remove all oio-sds nodes (not only meta0)')
(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_namespace_conf(ns)['zookeeper']
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_INFO)
for shard in cnxstr.split(";"):
logging.info("ZK=%s", shard)
zh = zookeeper.init(shard)
if options.flag_all:
logging.warn("FLUSHING all the oio-sds entries in the ZK server")
delete_children(zh, "/hc")
else:
logging.info("Cleaning only the meta0 registrations in ZK server")
delete_children(zh, "/hc/ns/"+ns+"/srv/meta0")
zookeeper.close(zh)
def main():
data = options.znode_data_size * "D"
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_WARN)
s = zookeeper.init(options.server)
if zookeeper.exists(s, options.root_znode, None):
children = zookeeper.get_children(s, options.root_znode, None)
print "delete old entries: %d" % len(children)
for child in children:
zookeeper.delete(s, "%s/%s" % (options.root_znode, child))
else:
zookeeper.create(s, options.root_znode, "zkpy root znode", acl, 0)
evaluation(s, options.root_znode, data, options)
zookeeper.close(s)
print("Performance test complete")
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 SRVTYPE [SRVTYPE...]")
ns = args[1]
cnxstr = load_namespace_conf(ns)['zookeeper']
zookeeper.set_debug_level(zookeeper.LOG_LEVEL_INFO)
zh = zookeeper.init(cnxstr)
for srvtype in args[2:]:
for group in namespace_tree(ns, srvtype):
children = list(list_nodes(zh, group, options))
if len(children) > 0:
logging.info("> %s", group)
for k in children:
data, meta = zookeeper.get(zh, group + '/' + k)
logging.info(" %s : %s", k, data)
zookeeper.close(zh)
def __init__(self,
hosts,
base_znode,
retry_policy=None,
log_level=zookeeper.LOG_LEVEL_ERROR):
# 合法的znode名称是：以/开头，除了根znode，其他znode不能以/结尾
if not isinstance(base_znode, str) or \
not base_znode.startswith("/") or \
(base_znode != "/" and base_znode.endswith("/")):
raise RuntimeError("invalid base_znode")
self._base_znode = base_znode
self._hosts = hosts
zookeeper.set_debug_level(log_level)
self._register_handler = None
self._register_entry_set = None
self._delete_if_exists = True
self._discovery_handler = None
self._local_cache = SafeDict()
def test_managed_zookeeper(self):
zookeeper.set_debug_level(0)
# Start zookeeper
data_dir = self.makeDir()
instance = Zookeeper(data_dir, 12345)
yield instance.start()
self.assertTrue(instance.running)
# Connect a client
client = ZookeeperClient("127.0.1.1:12345")
yield client.connect()
stat = yield client.exists("/")
yield client.close()
self.assertTrue(stat)
# Stop Instance
yield instance.stop()
self.assertFalse(instance.running)
self.assertFalse(os.path.exists(data_dir))
