class GJZookeeper(object):
ZK_HOST = "localhost:2181"
ROOT = "/app"
WORKERS_PATH = join(ROOT, "workers")
MASTERS_NUM = 1
TIMEOUT = 10000
def __init__(self, verbose = True):
self.VERBOSE = verbose
self.path = None
self.is_master = True
self.zk = ZKClient(self.ZK_HOST, timeout = self.TIMEOUT)
self.say("login ok!")
# init
self.__init_zk()
# register
self.register()
def __init_zk(self):
"""
create the zookeeper node if not exist
"""
nodes = (self.ROOT, self.WORKERS_PATH)
for node in nodes:
if not self.zk.exists(node):
try:
self.zk.create(node, "")
except:
pass
def register(self):
@watchmethod
def watcher(event):
self.say("first watcher")
self.path = self.zk.create(self.WORKERS_PATH + "/worker", "1", flags=zookeeper.EPHEMERAL | zookeeper.SEQUENCE)
if not self.zk.exists(self.path, watcher):
print "not exist"
self.zk.set(self.path, "3", -1)
self.zk.exists(self.path, watcher)
self.zk.delete(self.path, -1)
print "_________________________"
def say(self, msg):
"""
print messages to screen
"""
if self.VERBOSE:
if self.path:
log.info("[ %s ] %s" % (self.path , msg))
else:
log.info(msg)
for child in children:
sessions[i].get(rootpath + "/" + child, watchers[i])
# trigger watches
for i, server in enumerate(servers):
sessions[i].delete(child_path(i))
# check all watches fired
for i, watcher in enumerate(watchers):
# ensure this server is up to date with leader
sessions[i]. async ()
if watcher.waitForExpected(len(sessions),
options.timeout) != len(sessions):
raise SmokeError("server %s wrong number of watches: %d" %
(server, watcher.count))
# close sessions
for i, server in enumerate(servers):
# ephemerals will be deleted automatically
sessions[i].close()
# cleanup root node
zk = ZKClient(servers[-1], options.timeout)
# ensure this server is up to date with leader (ephems)
zk. async ()
zk.delete(rootpath)
zk.close()
print("Smoke test successful")
watchers.append(SequentialCountingWatcher(child_path))
for child in children:
sessions[i].get(rootpath + "/" + child, watchers[i])
# trigger watches
for i, server in enumerate(servers):
sessions[i].delete(child_path(i))
# check all watches fired
for i, watcher in enumerate(watchers):
# ensure this server is up to date with leader
sessions[i].async()
if watcher.waitForExpected(len(sessions), options.timeout) != len(sessions):
raise SmokeError("server %s wrong number of watches: %d" %
(server, watcher.count))
# close sessions
for i, server in enumerate(servers):
# ephemerals will be deleted automatically
sessions[i].close()
# cleanup root node
zk = ZKClient(servers[-1], options.timeout)
# ensure this server is up to date with leader (ephems)
zk.async()
zk.delete(rootpath)
zk.close()
print("Smoke test successful")
timer2(func, "deleted %7d permanent znodes " % (options.znode_count))
def get_zk_servers():
return options.cluster
if __name__ == '__main__':
data = options.znode_size * "x"
servers = get_zk_servers()
session_gets = []
for x in xrange(options.watch_session):
session_gets.append(ZKClient(servers, options.timeout))
session_set = ZKClient(servers, options.timeout)
session_set.create(options.root_znode,
"smoketest root, delete after test done, created %s" % (datetime.datetime.now().ctime()))
create_nodes(session_set)
for s in session_gets:
add_wathches(s)
set_nodes(session_set, data)
delete_nodes(session_set)
session_set.delete(options.root_znode)
time.sleep(10)
for s in session_gets:
s.close()
session_set.close()
print 'watch test complete'
import zkclient
from zkclient import ZKClient
zk = ZKClient("10.187.176.194:2181")
newKeyList = [
"goods_homef~~~brand", "qrqm_hp_cfb~~~brand", "goods_homef~~~c3brand",
"qrqm_hp_cfb~~~c3brand_0", "goods_homef~~~c3", "qrqm_hp_cfb~~~c3",
"qrqm_hp_cfb~~~channelBrand_0", "qrqm_hp_cfb~~~channelC3Brand_0",
"qrqm_hp_cfb~~~channelC3_0", "qrqm_hp_cfb~~~channel", "cd3_fzxp_fs",
"cd3_jdjx_fs", "cd3_jdmarket_fs", "cd3_newsh_fs", "cd3_oversea_fs",
"cd3_7toreturn_fs", "seckill_cfb~~~brand_code",
"seckill_cfb~~~cid3_discount_ratio_cat", "seckill_cfb~~~cid3",
"seckill_cfb~~~cid3_pw3_ids", "seckill_cfb~~~discount_amount_cat",
"seckill_cfb~~~discount_ratio_cat"
]
created = zk.exists("/root/redis")
if created:
print 'deleting /root/redis ...'
oldKeyList = zk.get_children("/root/redis")
for k in oldKeyList:
zk.delete("/root/redis/" + k)
else:
zk.create("/root/redis", "")
for k in newKeyList:
zk.create("/root/redis/" + k, k)
print 'add keys on zk success!'
def get_zk_servers():
return options.cluster
if __name__ == '__main__':
data = options.znode_size * "x"
servers = get_zk_servers()
session_gets = []
for x in xrange(options.watch_session):
session_gets.append(ZKClient(servers, options.timeout))
session_set = ZKClient(servers, options.timeout)
session_set.create(
options.root_znode,
"smoketest root, delete after test done, created %s" %
(datetime.datetime.now().ctime()))
create_nodes(session_set)
for s in session_gets:
add_wathches(s)
set_nodes(session_set, data)
delete_nodes(session_set)
session_set.delete(options.root_znode)
time.sleep(10)
for s in session_gets:
s.close()
session_set.close()
print 'watch test complete'
