def queue_callback(self, zh, rc, data): if zookeeper.OK == rc: try: for child in sorted(data): action = self.actionNode + '/' + child workLog = self.actionNode + '/' + child + '/worklog' statusLog = self.statusNode + '/status-' """ Launch the task if the task has not been executed """ if zookeeper.exists(zh, workLog, None) == None: self.launch(zh, workLog, action, statusLog) else: """ If task has been previous launched, check for partial execution """ buffer = zookeeper.get(zh, workLog, 0) state = simplejson.loads(buffer[0]) """ If task is incompleted in execution, launch again """ if 'status' in state and state['status'] == 'STARTING': logger.info('Relaunch '+child) self.launch(zh, workLog, action, statusLog) else: """ If the task has been launched, and completed, update status queue """ if zookeeper.exists(zh, statusLog, None) == None: logger.info('Update status.') self.update(zh, statusLog, state) except NoNodeException, err: """ Skip no node exception """ except Exception, err: logger.exception(err)
def set_watcher(): def fn(): self.callback_flag = True self.callback_flag = False zookeeper.exists( self.handle, "/zk-python-lose-scope-test", self.create_callback(lambda handle, type, state, path: fn()))
def notifyFailedTransaction(self, app_id, txid): """ Notify failed transaction id. This method will add the transaction id into black list. After this call, the transaction becomes invalid. """ self.__waitForConnect() self.checkTransaction(app_id, txid) print "notify failed transaction app:%s, txid:%d" % (app_id, txid) txpath = self.__getTransactionPath(app_id, txid) lockpath = None try: lockpath = zookeeper.get(self.handle, PATH_SEPARATOR.join([txpath, TX_LOCK_PATH]), None)[0] except zookeeper.NoNodeException: # there is no lock. it means there is no need to rollback. pass if lockpath: # add transacion id to black list. now = str(time.time()) broot = self.__getBlacklistRootPath(app_id) if not zookeeper.exists(self.handle, broot): self.__forceCreatePath(broot) zookeeper.acreate(self.handle, PATH_SEPARATOR.join([broot, str(txid)]), now, ZOO_ACL_OPEN) # update local cache before notification if app_id in self.blacklistcache: with self.blacklistcv: self.blacklistcache[app_id].add(str(txid)) # copy valid transaction id for each updated key into valid list. for child in zookeeper.get_children(self.handle, txpath): if re.match("^" + TX_UPDATEDKEY_PREFIX, child): value = zookeeper.get(self.handle, PATH_SEPARATOR.join([txpath, child]), None)[0] valuelist = value.split(PATH_SEPARATOR) key = urllib.unquote_plus(valuelist[0]) vid = valuelist[1] vtxroot = self.__getValidTransactionRootPath(app_id) if not zookeeper.exists(self.handle, vtxroot): self.__forceCreatePath(vtxroot) vtxpath = self.__getValidTransactionPath(app_id, key) zookeeper.acreate(self.handle, vtxpath, vid, ZOO_ACL_OPEN) # release the lock try: zookeeper.adelete(self.handle, lockpath) except zookeeper.NoNodeException: # this should be retry. pass # just remove transaction node try: for item in zookeeper.get_children(self.handle, txpath): zookeeper.adelete(self.handle, PATH_SEPARATOR.join([txpath, item])) zookeeper.adelete(self.handle, txpath) except zookeeper.NoNodeException: # something wrong. next GC will take care of it. return False return True
def write(self, path, contents, ephemeral=False, exclusive=False): """ Writes the contents to the path in zookeeper. It will create the path in zookeeper if it does not already exist. This method will return True if the value is written, False otherwise. (The value will not be written if the exclusive is True and the node already exists.) """ partial_path = '' # We start from the second element because we do not want to inclued # the initial empty string before the first "/" because all paths begin # with "/". We also don't want to include the final node because that # is dealt with later. for path_part in path.split("/")[1:-1]: partial_path = partial_path + "/" + path_part if not(zookeeper.exists(self.handle, partial_path)): try: zookeeper.create(self.handle, partial_path, '', [self.acl], 0) except zookeeper.NodeExistsException: pass exists = zookeeper.exists(self.handle, path) # Don't create it if we're exclusive. if exists and exclusive: return False # We make sure that we have the creation flags for ephemeral nodes, # otherwise they could be associated with previous connections that # have not yet timed out. if ephemeral and exists: try: zookeeper.delete(self.handle, path) except zookeeper.NoNodeException: pass exists = False if exists: zookeeper.set(self.handle, path, contents) return True else: flags = (ephemeral and zookeeper.EPHEMERAL or 0) try: zookeeper.create(self.handle, path, contents, [self.acl], flags) return True except zookeeper.NodeExistsException: if not(exclusive): # Woah, something happened between the top and here. # We just restart and retry the whole routine. self.write(path, contents, ephemeral=ephemeral) return True else: return False
def initialize_node_structure(self): if not zk.exists(self.zh, self.ROOT): self.create(self.ROOT) if not zk.exists(self.zh, self.NODE_SERVERS): self.create(self.NODE_SERVERS) self.NODE_GJOBS = self.ROOT + '/jobs' if not zk.exists(self.zh, self.NODE_GJOBS): self.create(self.NODE_GJOBS)
def _write(self, path, contents, ephemeral, exclusive, sequential, mustexist): # We start from the second element because we do not want to inclued # the initial empty string before the first "/" because all paths begin # with "/". We also don't want to include the final node because that # is dealt with later. partial_path = '' for path_part in path.split("/")[1:-1]: partial_path = partial_path + "/" + path_part if not (zookeeper.exists(self.handle, partial_path)): try: zookeeper.create(self.handle, partial_path, '', [self.acl], 0) except zookeeper.NodeExistsException: pass if sequential: exists = False else: exists = zookeeper.exists(self.handle, path) # Don't create it if we're exclusive. if exists and exclusive: return False # Check if we require the node to exist. if not exists and mustexist: return False # We make sure that we have the creation flags for ephemeral nodes, # otherwise they could be associated with previous connections that # have not yet timed out. if ephemeral and exists: try: zookeeper.delete(self.handle, path) except zookeeper.NoNodeException: pass exists = False if exists: zookeeper.set(self.handle, path, contents) return path else: flags = 0 if ephemeral: flags = flags | zookeeper.EPHEMERAL if sequential: flags = flags | zookeeper.SEQUENCE # NOTE: We return the final path created. return zookeeper.create(self.handle, path, contents, [self.acl], flags)
def node_add(): basepath = request.args.get('path', '') if request.method == 'POST': path = request.form.get('path') data = request.form.get('data') print request.form print request.values verify = True if len(path) == 0: verify = False flash('"Node Path" not allow empty') elif path[0] == '/': verify = False flash('"Node Path" can not start with "/"') else: path = CONFIG_NODE / basepath / path if zookeeper.exists(zk, path): verify = False flash('Path already exists:"%s"' % (path)) if verify: nodepath = FilePath('/') try: for node in path.split('/'): nodepath = nodepath / node if not zookeeper.exists(zk, nodepath): if nodepath != path: zookeeper.create(zk, nodepath, '', [{ "perms": zookeeper.PERM_ALL, "scheme": 'world', "id": 'anyone' }], 0) else: zookeeper.create(zk, nodepath, data, [{ "perms": zookeeper.PERM_ALL, "scheme": 'world', "id": 'anyone' }], 0) return redirect('/node') except BaseException, e: flash(e.message) formdata = { 'path': request.form.get('path') if path != '' else '', 'data': data }
def add_twemproxy(host, port, zookeeper_str, product_prefix): try: zk = zookeeper.init(zookeeper_str) if not zookeeper.exists(zk, "/twemproxy"): create_zookeeper(zk, "/twemproxy", "") zk_twproxy_path = "/twemproxy/%s/%s:%d" % (product_prefix, host, port) if not zookeeper.exists(zk, zk_twproxy_path): create_zookeeper(zk, zk_twproxy_path, "") return True else: return False except zookeeper.NodeExistsException, e: handle_output(False, "path %s exist\n" % pathstr)
def before_request(): if not zookeeper.exists(zk, ROOT_NODE): zookeeper.create(zk, ROOT_NODE, '', [{ "perms": zookeeper.PERM_ALL, "scheme": "world", "id": "anyone" }], 0) elif not zookeeper.exists(zk, CONFIG_NODE): zookeeper.create(zk, CONFIG_NODE, '', [{ "perms": zookeeper.PERM_ALL, "scheme": "world", "id": "anyone" }], 0)
def server_delete(): name = request.args.get('name', '') if name == '': return redirect(request.referrer) if zookeeper.exists(zk, ONLINE_NODE / name): flash('"%s" is already online and can not be deleted' % (name)) return redirect(request.referrer) nodepath = SERVIE_NODE / name if zookeeper.exists(zk, nodepath): zookeeper_delete_node(zk, nodepath) return redirect(request.referrer)
def _write(self, path, contents, ephemeral, exclusive, sequential, mustexist): # We start from the second element because we do not want to inclued # the initial empty string before the first "/" because all paths begin # with "/". We also don't want to include the final node because that # is dealt with later. partial_path = '' for path_part in path.split("/")[1:-1]: partial_path = partial_path + "/" + path_part if not(zookeeper.exists(self.handle, partial_path)): try: zookeeper.create(self.handle, partial_path, '', [self.acl], 0) except zookeeper.NodeExistsException: pass if sequential: exists = False else: exists = zookeeper.exists(self.handle, path) # Don't create it if we're exclusive. if exists and exclusive: return False # Check if we require the node to exist. if not exists and mustexist: return False # We make sure that we have the creation flags for ephemeral nodes, # otherwise they could be associated with previous connections that # have not yet timed out. if ephemeral and exists: try: zookeeper.delete(self.handle, path) except zookeeper.NoNodeException: pass exists = False if exists: zookeeper.set(self.handle, path, contents) return path else: flags = 0 if ephemeral: flags = flags | zookeeper.EPHEMERAL if sequential: flags = flags | zookeeper.SEQUENCE # NOTE: We return the final path created. return zookeeper.create(self.handle, path, contents, [self.acl], flags)
def zookeeper_node_set(nodepath, nodevalue, perms, **option): ephemeral = 0 if option.has_key('ephemeral') and option['ephemeral']: ephemeral = zookeeper.EPHEMERAL parent_perms = perms if option.has_key('parent_perms'): parent_perms = option['parent_perms'] p = FilePath('/') for v in nodepath.split('/'): p = p / v if not zookeeper.exists(G.zookeeper, p): if not option.has_key('nocreate') or not option['nocreate']: if p == nodepath: print zookeeper.create(G.zookeeper, p, nodevalue, [{ "perms": perms, "scheme": "world", "id": "anyone" }], ephemeral) return True else: zookeeper.create(G.zookeeper, p, '', [{ "perms": parent_perms, "scheme": "world", "id": "anyone" }], 0) elif p == nodepath: print zookeeper.set(G.zookeeper, p, nodevalue) return True return False
def exists(path): init_client() global handle try: return zookeeper.exists(handle,path) is not None except zookeeper.NoNodeException: return False
def set_node(delurl,addurl): handler = zookeeper.init("127.0.0.1:2181") delnode = zookeeper.exists(handler,delurl) addnode = zookeeper.exists(handler,addurl) #找到旧的URL就删除 if delnode: zookeeper.delete(handler,delurl)#删除旧的URL else: write_log(' zookeeper not found old url '+delurl) #如果新的URL不存在就创建 if addnode == None: try: zookeeper.create(handler,addurl,'',[{"perms":0x1f,"scheme":"world","id":"anyone"}],0)#zookeeper重设URL write_log(' zookeeper url from '+delurl+' change to '+addurl+' success') except Exception, e: write_log(' zookeeper url from '+delurl+' change to '+addurl+' failed')
def getReadLock(self, metadata): #Acquire read lock on file through ZooKeeper fn = metadata.filename print "Trying to acquire read lock for " + self.root + fn self.zpath = self.createLockNode(fn, 'r') myLock = self.zpath.rsplit('/',1)[1] while True: children = sorted(zookeeper.get_children(self.zh, self.root + fn)) lastLock = '' for child in children: try: if child == myLock: break elif zookeeper.get(self.zh, self.root+fn+'/'+child)[0] == 'w': lastLock = child except: pass if lastLock != '': def watcher (handle, type, state, path): self.cv2.acquire() self.cv2.notify() self.cv2.release() self.cv2.acquire() if zookeeper.exists(self.zh, self.root+fn+'/'+lastLock, watcher): self.cv2.wait() self.cv2.release() else: break print "Acquired read lock for " + self.root + fn
def test_sync_exists(self): self.assertEqual(self.connected, True) ret = zookeeper.exists(self.handle, "/zk-python-existstest", None) self.assertNotEqual( ret, None, "/zk-python-existstest does not exist (possibly means creation failure)" )
def __init__(self, zkhosts, root=NODE_HQ_ROOT, alivenode='alive'): """zkhosts: a string or a list. list will be ','.join-ed into a string. root: root node path (any parents must exist, if any) """ if not isinstance(zkhosts, basestring): zkhosts = ','.join(zkhosts) self.zkhosts = zkhosts self.ROOT = root self.alivenode = alivenode self.nodename = os.uname()[1] self.NODE_SERVERS = self.ROOT + '/servers' self.NODE_ME = self.NODE_SERVERS+'/'+self.nodename self.zh = zk.init(self.zkhosts, self.__watcher) self.jobs = {} self.initialize_node_structure() if not zk.exists(self.zh, self.NODE_ME): zk.create(self.zh, self.NODE_ME, '', PERM_WORLD) # setup notification zk.get_children(self.zh, self.NODE_SERVERS, self.__servers_watcher) #zk.get_children(self.zh, self.NODE_ME, self.__watcher) self.NODE_JOBS = self.NODE_ME+'/jobs' zk.acreate(self.zh, self.NODE_JOBS, '', PERM_WORLD)
def getReadLock(self, metadata): #Acquire read lock on file through ZooKeeper fn = metadata.filename print "Trying to acquire read lock for " + self.root + fn self.zpath = self.createLockNode(fn, 'r') myLock = self.zpath.rsplit('/', 1)[1] while True: children = sorted(zookeeper.get_children(self.zh, self.root + fn)) lastLock = '' for child in children: try: if child == myLock: break elif zookeeper.get(self.zh, self.root + fn + '/' + child)[0] == 'w': lastLock = child except: pass if lastLock != '': def watcher(handle, type, state, path): self.cv2.acquire() self.cv2.notify() self.cv2.release() self.cv2.acquire() if zookeeper.exists(self.zh, self.root + fn + '/' + lastLock, watcher): self.cv2.wait() self.cv2.release() else: break print "Acquired read lock for " + self.root + fn
def exists(path): init_client() global handle try: return zookeeper.exists(handle, path) is not None except zookeeper.NoNodeException: return False
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])
def list_children(self, path): """ Returns a list of all the children nodes in the path. None is returned if the path does not exist. """ if zookeeper.exists(self.handle, path): value = zookeeper.get_children(self.handle, path) return value
def watcher(zk, type, state, nodepath): log('watcher', { 'type': type, 'state': state, 'nodepath': nodepath }, 'DEBUG') if type == zookeeper.SESSION_EVENT: zookeeper.set_watcher(zk, watcher) if state == zookeeper.CONNECTED_STATE: for k in G.project: if zookeeper.exists(zk, k, watcher): # 启动时马上就通知一次,防止在断线过程中出现了数据更改,而服务又不知道 on_zookeeper_node_change(zookeeper.get(zk, k), k) if zookeeper.exists(zk, ROOT_NODE, watcher): config = zookeeper.get(zk, ROOT_NODE)[0] if config != '': G.config = json.loads(config) if not isinstance(G.config, dict): raise TypeError() else: G.config = {} log('config', G.config, 'DEBUG') elif type == zookeeper.CREATED_EVENT or type == zookeeper.CHANGED_EVENT: nodevalue = zookeeper.get(zk, nodepath, watcher) if nodepath == ROOT_NODE: if nodevalue[0] != '': G.config = json.loads(nodevalue[0]) if not isinstance(G.config, dict): raise TypeError() else: G.config = {} log('config', G.config, 'DEBUG') # restart process if G.config.has_key('restart') and G.config['restart'] in [ True, G.name ]: G.queue.put((0, {'type': 'restart'})) else: on_zookeeper_node_change(nodevalue, nodepath) elif type == zookeeper.DELETED_EVENT: zookeeper.exists(zk, nodepath, watcher) # 期待再次创建节点
def register_service(self, service, port=0): path = "" if service == "master": path = ZKConf.ZK_PATH_TEMP_MASTER elif service == "stats": path = ZKConf.ZK_PATH_TEMP_STATS elif service == "proxy": path = ZKConf.ZK_PATH_TEMP_PROXY if not path: raise Exception("service type '%s' doesn't exist" % (service, )) node = zookeeper.exists(self._handler, path, None) if not node: if not zookeeper.exists(self._handler, ZKConf.ZK_PATH_ROOT, None): zookeeper.create(self._handler, ZKConf.ZK_PATH_ROOT, "", [ZKConf.ZOO_CREATOR_ALL_ACL], 0) zookeeper.create(self._handler, path, "", [ZKConf.ZOO_CREATOR_ALL_ACL], 0) ip = utils.getip() mepath = "".join([path, "/", ip, ":", str(port), "-"]) if not port: mepath = "".join([path, "/", ip, "-"]) childs = zookeeper.get_children(self._handler, path, None) is_created = False pathme = mepath.split("/")[-1] for child in childs: if child.startswith(pathme): is_created = child.split("-")[-1] break if is_created: meflag = mepath + is_created utils.log(utils.cur(), "%s none-callback %s" % ("*" * 10, "*" * 10), meflag) else: utils.log(utils.cur(), "%s %s %s" % ("*" * 10, self.register_node_cb, "*" * 10), mepath) meflag = zookeeper.create(self._handler, mepath, "", [ZKConf.ZOO_CREATOR_ALL_ACL], zookeeper.SEQUENCE | zookeeper.EPHEMERAL) utils.log(utils.cur(), "-" * 10, meflag)
def read(self, path, default=None): """ Returns the conents in the path. default is returned if the path does not exists. """ value = default if zookeeper.exists(self.handle, path): value, timeinfo = zookeeper.get(self.handle, path) return value
def registUpdatedKey(self, app_id, current_txid, target_txid, entity_key): """ Regist valid transaction id for entity. target_txid must be the latest valid transaction id for the entity. """ self.__waitForConnect() vtxpath = self.__getValidTransactionPath(app_id, entity_key) if zookeeper.exists(self.handle, vtxpath): # just update transaction id for entity if there is valid transaction node. zookeeper.aset(self.handle, vtxpath, str(target_txid)) else: # store the updated key info into current transaction node. value = PATH_SEPARATOR.join([urllib.quote_plus(entity_key), str(target_txid)]) txpath = self.__getTransactionPath(app_id, current_txid) if zookeeper.exists(self.handle, txpath): zookeeper.acreate(self.handle, PATH_SEPARATOR.join([txpath, TX_UPDATEDKEY_PREFIX]), value, ZOO_ACL_OPEN, zookeeper.SEQUENCE) else: raise ZKTransactionException(ZKTransactionException.TYPE_INVALID, "Transaction %d is not valid." % current_txid)
def __make_presence(self): if not zookeeper.exists(self.zk, '/present/%s' % self.queue): self.__create_node('/present/%s' % self.queue, '', perms, 0) self.__create_node('/present/%s/%d' % (self.queue, self.zk), '', perms, zookeeper.EPHEMERAL) self.__log('Created presence node successfully')
def delete(dry_run=False): wc = ctx.get_write_context() LOG.info("Deleting recursively " + str(cnt.ZOOM_ZK_ROOTS) + " from server(s) " + wc.zk_servers) handle = zookeeper.init(wc.zk_servers) for root in cnt.ZOOM_ZK_ROOTS: if zookeeper.exists(handle, root): _recursive_delete(handle, root, dry_run=dry_run)
def __get_message(self): messages = self.__get_children('/queues/%s' % self.queue) self.__log('got %d children of the queue' % len(messages), level=logging.Logger.debug) for message in sorted(messages): if not zookeeper.exists(self.zk, '/queues/%s/%s/taken' % (self.queue, message)): self.__create_node('/queues/%s/%s/taken' % (self.queue, message), str(self.zk), perms, zookeeper.EPHEMERAL) self._current_message = '/queues/%s/%s' % (self.queue, message) return self.__get_node('/queues/%s/%s' % (self.queue, message)) return None
def register_service(self, service, port=0): path = "" if service == "master": path = ZKConf.ZK_PATH_TEMP_MASTER elif service == "stats": path = ZKConf.ZK_PATH_TEMP_STATS elif service == "proxy": path = ZKConf.ZK_PATH_TEMP_PROXY if not path: raise Exception("service type '%s' doesn't exist" % (service,)) node = zookeeper.exists(self._handler, path, None) if not node: if not zookeeper.exists(self._handler, ZKConf.ZK_PATH_ROOT, None): zookeeper.create(self._handler, ZKConf.ZK_PATH_ROOT, "", [ZKConf.ZOO_CREATOR_ALL_ACL], 0) zookeeper.create(self._handler, path, "", [ZKConf.ZOO_CREATOR_ALL_ACL], 0) ip = utils.getip() mepath = "".join([path, "/", ip, ":", str(port), "-"]) if not port: mepath = "".join([path, "/", ip, "-"]) childs = zookeeper.get_children(self._handler, path, None) is_created = False pathme = mepath.split("/")[-1] for child in childs: if child.startswith(pathme): is_created = child.split("-")[-1] break if is_created: meflag = mepath + is_created utils.log(utils.cur(), "%s none-callback %s" % ("*"*10, "*"*10), meflag) else: utils.log(utils.cur(), "%s %s %s" % ("*"*10, self.register_node_cb, "*"*10), mepath) meflag = zookeeper.create(self._handler, mepath, "", [ZKConf.ZOO_CREATOR_ALL_ACL], zookeeper.SEQUENCE|zookeeper.EPHEMERAL) utils.log(utils.cur(), "-"*10, meflag)
def exists(self, path, watch=None): """ Determine whether the ZooKeeper Node at `path` exists Arguments: - `path`: string Return: dict of stats or None Exceptions: None """ return zookeeper.exists(self._zk, path, watch)
def create_zookeeper_without_delete_children(zk, path, data): try: if zookeeper.exists(zk, path): return zookeeper.create(zk, path, data, [{ "perms": 15, "scheme": "world", "id": "anyone" }], 0) except zookeeper.NodeExistsException, e: err_str = "path %s exist\n" % path handle_output(False, err_str)
def clean_tree(zh, root): """Recursively removes the zookeeper subtree underneath :root given zookeeper handle :zh.""" try: if not zookeeper.exists(zh, root): return True for child in zookeeper.get_children(zh, root): if not ZookeeperUtil.clean_tree(zh, posixpath.join(root, child)): return False zookeeper.delete(zh, root) except zookeeper.ZooKeeperException as e: return False return True
def cached_exists(self, path): cache = self._caches.setdefault('exists', dict()) retval = cache.get(path, Ellipsis) if retval is not Ellipsis: return retval def invalidator(event): cache.pop(path, None) retval = zookeeper.exists(self.handle, path, self._wrap_watcher(invalidator)) cache[path] = retval return retval
def clean_tree(zh, root): """Recursively removes the zookeeper subtree underneath :root given zookeeper handle :zh.""" try: if not zookeeper.exists(zh, root): return True for child in zookeeper.get_children(zh, root): if not ZookeeperUtil.clean_tree(zh, posixpath.join( root, child)): return False zookeeper.delete(zh, root) except zookeeper.ZooKeeperException as e: return False return True
def post(self): request_dict = self.request.arguments cluster_name = (request_dict['cluster_name'])[0] zk=zookeeper.init(self.zk_connect(cluster_name)) new_node = (request_dict['New_post_node'])[0] new_value = (request_dict['new_node_value'])[0] if zookeeper.exists(zk,new_node): zookeeper.close(zk) self.write("此节点存在") else: zookeeper.create(zk,new_node,new_value,[{"perms":0x1f,"scheme":"world","id":"anyone"}],0) zookeeper.close(zk) self.write("增加成功")
def checkTransaction(self, app_id, txid): """ Get status of specified transaction. Returns: True - If transaction is alive. Raises: ZKTransactionException - If transaction is timeout or not exist. """ self.__waitForConnect() txpath = self.__getTransactionPath(app_id, txid) if self.isBlacklisted(app_id, txid): raise ZKTransactionException(ZKTransactionException.TYPE_EXPIRED, "Transaction %d is timeout." % txid) if not zookeeper.exists(self.handle, txpath): raise ZKTransactionException(ZKTransactionException.TYPE_INVALID, "TransactionID %d is not valid." % txid) return True
def watch_contents(self, path, fn, default_value="", clean=False): if not zookeeper.exists(self.handle, path): self.write(path, default_value) self.cond.acquire() try: if clean: self.watches[path] = [] if not(fn in self.watches.get(path, [])): self.watches[path] = self.watches.get(path, []) + [fn] value, timeinfo = zookeeper.get(self.handle, path, self.zookeeper_watch) finally: self.cond.release() return value
def ready(self): if not zookeeper.exists(self.zk, '/waiting/%s' % self.queue): self.__create_node('/waiting/%s' % self.queue, '', perms, 0) self.__log('Created waiting queue %s' % self.queue) last_waiting = self.__get_nth_waiting(-1) if last_waiting: self.__set_watch(last_waiting, self.__in_line_watch) self.waiting_node = self.__create_node('/waiting/%s/w-' % self.queue, str(self.zk), perms, zookeeper.SEQUENCE | zookeeper.EPHEMERAL) else: self[0].waiting_node = self.__create_node('/waiting/%s/w-' % self.queue, str(self.zk), perms, zookeeper.SEQUENCE | zookeeper.EPHEMERAL) return self.__message_check()
def watch_children(self, path, fn, default_value="", clean=False): self.cond.acquire() if not zookeeper.exists(self.handle, path): self.write(path, default_value) try: if clean: self.watches[path] = [] if not(fn in self.watches.get(path, [])): self.watches[path] = self.watches.get(path, []) + [fn] rval = zookeeper.get_children(self.handle, path, self.zookeeper_watch) finally: self.cond.release() return rval
def wait(self, file): def ret_watcher(handle, event, state, path): self.cv.acquire() self.cv.notify() self.cv.release() while True: self.cv.acquire() data = zookeeper.exists(self.handle, file, ret_watcher) if data != None: data = self.get_and_delete(file) self.cv.release() return data self.cv.wait() self.cv.release()
def read(self, path, default=None): """ Returns the conents in the path. default is returned if the path does not exists. """ if not path: raise BadArgumentsException("Invalid path: %s" % (path)) value = default if zookeeper.exists(self.handle, path): try: value, _ = zookeeper.get(self.handle, path) except zookeeper.NoNodeException: pass return value
def list_children(self, path): """ Returns a list of all the children nodes in the path. None is returned if the path does not exist. """ if not path: raise BadArgumentsException("Invalid path: %s" % (path)) if zookeeper.exists(self.handle, path): try: value = zookeeper.get_children(self.handle, path) return value except zookeeper.NoNodeException: pass return []
def checkTransaction(self, app_id, txid): """ Get status of specified transaction. Returns: True - If transaction is alive. Raises: ZKTransactionException - If transaction is timeout or not exist. """ self.__waitForConnect() txpath = self.__getTransactionPath(app_id, txid) if self.isBlacklisted(app_id, txid): raise ZKTransactionException(ZKTransactionException.TYPE_EXPIRED, "zktransaction.checkTransaction: Transaction %d is timeout." % txid) if not zookeeper.exists(self.handle, txpath): raise ZKTransactionException(ZKTransactionException.TYPE_INVALID, "zktransaction.checkTransaction: TransactionID %d is not valid." % txid) return True
def delete(self, path): """ Delete the path. """ if zookeeper.exists(self.handle, path): path_children = zookeeper.get_children(self.handle, path) for child in path_children: try: self.delete(path + "/" + child) except zookeeper.NoNodeException: pass try: zookeeper.delete(self.handle, path) except zookeeper.NoNodeException: pass
def post(self): request_dict = self.request.arguments node_json_list = (eval(request_dict['node_json'][0])).values() cluster_name = (request_dict['cluster_name'])[0] current_node = (request_dict['current_node'])[0] if current_node == "/" : current_node = "" zk=zookeeper.init(self.zk_connect(cluster_name)) for item in node_json_list: key = current_node + "/" + item[0] value = item[1] if not zookeeper.exists(zk, key): zookeeper.create(zk, key , value , [{"perms":0x1f,"scheme":"world","id":"anyone"}],0) self.write("写入成功") zookeeper.close(zk)
def acquireLock(self, app_id, txid, entity_key = GLOBAL_LOCK_KEY): """ Acquire lock for transaction. You must call getTransactionID() first to obtain transaction ID. You could call this method anytime if the root entity key is same. Args: app_id: The application ID to acquire a lock for. txid: The transaction ID you are acquiring a lock for. Built into the path. entity_key: Used to get the root path. Raises: ZKTransactionException: If it could not get the lock. """ self.__waitForConnect() txpath = self.__getTransactionPath(app_id, txid) lockrootpath = self.__getLockRootPath(app_id, entity_key) lockpath = None if zookeeper.exists(self.handle, PATH_SEPARATOR.join([txpath, TX_LOCK_PATH])): # use current lock prelockpath = zookeeper.get(self.handle, PATH_SEPARATOR.join([txpath, TX_LOCK_PATH]), None)[0] if not lockrootpath == prelockpath: raise ZKTransactionException(ZKTransactionException.TYPE_DIFFERENT_ROOTKEY, "zktransaction.acquireLock: You can not lock different root entity in same transaction.") print "Already has lock: %s" % lockrootpath return True self.checkTransaction(app_id, txid) # create new lock retry = True while retry: retry = False try: lockpath = zookeeper.create(self.handle, lockrootpath, txpath, ZOO_ACL_OPEN) except zookeeper.NoNodeException: self.__forceCreatePath(PATH_SEPARATOR.join(lockrootpath.split(PATH_SEPARATOR)[:-1])) retry = True except zookeeper.NodeExistsException: # fail to get lock raise ZKTransactionException(ZKTransactionException.TYPE_CONCURRENT, "zktransaction.acquireLock: There is already another transaction using this lock") # set lockpath for transaction node # TODO: we should think about atomic operation or recovery of # inconsistent lockpath node. zookeeper.acreate(self.handle, PATH_SEPARATOR.join([txpath, TX_LOCK_PATH]), lockpath, ZOO_ACL_OPEN) return True
def watch_children(self, path, fn, clean=False): if not (path and fn): raise BadArgumentsException("Invalid path/fn: %s/%s" % (path, fn)) self.cond.acquire() if not zookeeper.exists(self.handle, path): self.write(path, "") try: if clean: self.child_watches[path] = [] if not(fn in self.child_watches.get(path, [])): self.child_watches[path] = self.child_watches.get(path, []) + [fn] rval = zookeeper.get_children(self.handle, path, self.zookeeper_watch) finally: self.cond.release() return rval
def node_modify(): path = request.args.get('path', '') if request.method == 'POST': data = request.form.get('data') verify = True if not zookeeper.exists(zk, CONFIG_NODE / path): flash('Path already exists:"%s"' % (CONFIG_NODE / path)) verify = False if verify: try: zookeeper.set(zk, CONFIG_NODE / path, data) return redirect('/node') except BaseException, e: flash(e.message)
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 watch_children(self, path, fn, clean=False): if not (path and fn): raise BadArgumentsException("Invalid path/fn: %s/%s" % (path, fn)) if not zookeeper.exists(self.handle, path): self.write(path, "") self.cond.acquire() try: if clean: self.child_watches[path] = [] if not (fn in self.child_watches.get(path, [])): self.child_watches[path] = self.child_watches.get(path, []) + [fn] finally: self.cond.release() rval = zookeeper.get_children(self.handle, path, self.zookeeper_watch) return rval
def watch_contents(self, path, fn, default_value="", clean=False): if not (path and fn): raise BadArgumentsException("Invalid path/fn: %s/%s" % (path, fn)) if not zookeeper.exists(self.handle, path): self.write(path, default_value) self.cond.acquire() try: if clean: self.content_watches[path] = [] if not (fn in self.content_watches.get(path, [])): self.content_watches[path] = self.content_watches.get( path, []) + [fn] finally: self.cond.release() value, _ = zookeeper.get(self.handle, path, self.zookeeper_watch) return value
def exists(self, path, watcher=None): """Blocking call to check if zookeeper node exists. Args: watcher: watcher method to be invoked upon node creation or removal with Zookeeper.Event as its sole argument. watcher will be invoked in the context of the underlying zookeeper API threads. Returns: zookeeper state dict if node exists, otherwise None. i.e. {'pzxid': 4522L, 'ctime': 1333654407863L, 'aversion': 0, 'mzxid': 4522L, 'numChildren': 0, 'ephemeralOwner': 0L, 'version': 0, 'dataLength': 0, 'mtime': 1333654407863L, 'cversion': 0, 'czxid': 4522L} Raises: zookeeper.*Exception for other failure scenarios. """ return zookeeper.exists(self.handle, path, self._watcher_proxy(watcher))
def server_restart(): name = request.args.get('name', '') if name == '': return redirect(request.referrer) if not zookeeper.exists(zk, ONLINE_NODE / name): flash('"%s" is not online and can not be restart' % (name)) return redirect(request.referrer) nodevalue = zookeeper.get(zk, ROOT_NODE) if nodevalue[0] != '': config = json.loads(nodevalue[0]) config['restart'] = name else: config = {'restart': name} zookeeper.set(zk, ROOT_NODE, json.dumps(config)) flash('Success') return redirect(request.referrer)