def test_multiple_watchers(self):
"""
Test whether multiple watchers are correctly called
"""
cv1, cv2 = threading.Condition(), threading.Condition()
def watcher1(*args, **kwargs):
cv1.acquire()
self.watcher1 = True
cv1.notify()
cv1.release()
def watcher2(*args, **kwargs):
cv2.acquire()
self.watcher2 = True
cv2.notify()
cv2.release()
nodename = "/zk-python-multiple-watcher-test"
self.ensureCreated(nodename, "test")
cv1.acquire()
cv2.acquire()
zookeeper.get(self.handle, nodename, watcher1)
zookeeper.get(self.handle, nodename, watcher2)
zookeeper.set(self.handle, nodename, "test")
cv1.wait(15)
cv2.wait(15)
self.assertTrue(self.watcher1 and self.watcher2,
"One or more watchers failed to fire")
def set(self, path, data='', previous_data=None):
path = '%s%s' % (self.prefix, path)
try:
current_data, current_meta = zookeeper.get(self.handle, path, None)
except zookeeper.NoNodeException:
if not previous_data:
try:
zookeeper.create(self.handle, path, data, [ZOO_OPEN_ACL_UNSAFE])
return True
except:
self.log.exception('Failed to create a missing key %s', path)
return False
else:
return False
except:
self.log.exception('Failed to set key %s', path)
return False
version = None
if previous_data:
if current_data != previous_data:
self.log.error('Previous data constraint failed')
return False
version = current_meta['version']
try:
if version is None:
zookeeper.set(self.handle, path, data)
else:
zookeeper.set(self.handle, path, data, version)
except:
self.log.exception('Set failed')
return False
return True
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 post(self):
request_dict = self.request.arguments
snapshot_id = (request_dict['snapshot_id'])[0]
print snapshot_id
data = ZdSnapshot.get(ZdSnapshot.id == int(snapshot_id) )
zk = zookeeper.init(self.zk_connect(data.cluster_name))
zookeeper.set(zk, data.path ,data.data)
zookeeper.close(zk)
self.write("还原成功!!!!!")
def put_ng(self, ng, val):
# create the new znode that holds the graph data
payload = { 'graph' : ng , 'data' : val }
znode_id = zookeeper.create(self.handle, '/ng', json.dumps(payload), [ZOO_OPEN_ACL_UNSAFE], zookeeper.SEQUENCE)
# now update mNG2znode look-up table:
(self.NG2znode, stat) = zookeeper.get(self.handle, '/look-up', None)
self.NG2znode = json.loads(str(self.NG2znode))
self.NG2znode[ng] = znode_id
zookeeper.set(self.handle, '/look-up', json.dumps(self.NG2znode))
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 update(self):
setvalue = str(self.aID) + "," + str(self.agent_state[1]) + "," + str(self.agent_state[2]) + "," + str(self.agent_state[3])
#IBR: following is not in romi's code, but i think it is needed:
print("updating... car {0}".format(self.aID))
self.agent_state = [self.clock(), self.position(),self.velocity(),self.acceleration()]
self.agent[1] = self.agent_state
zookeeper.set(self.handle, "/root/segment/" + str(self.aID), str(self.agent_state)) #Update values stored in zookeeper
t_update = Timer(self.self.TA, self.update) #Set timer to TA = period of agentstate update
t_update.start()
def __updateNode(self, path, value):
""" Try to update path first.
If the path doesn't exists, this method will try to create it.
"""
self.__waitForConnect()
try:
zookeeper.set(self.handle, path, value)
except zookeeper.NoNodeException:
self.__forceCreatePath(path, value)
def post(self):
request_dict = self.request.arguments
node_value = (request_dict['node_value'])[0]
node_name = (request_dict['node_name'])[0]
cluster_name = (request_dict['cluster_name'])[0]
zk=zookeeper.init(self.zk_connect(cluster_name))
zookeeper.set(zk,node_name,node_value)
zookeeper.close(zk)
logging.info('%s修改了集群%s的节点:%s值为%s'%(self.get_current_user(),cluster_name,node_name ,node_value ))
self.write("修改成功")
def __updateNode(self, path, value):
""" Try to update path first.
If the path doesn't exists, this method will try to create it.
"""
self.__waitForConnect()
try:
zookeeper.set(self.handle, path, value)
except zookeeper.NoNodeException:
self.__forceCreatePath(path, value)
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 del_test_data():
hour = int(get_hour())
zk = zookeeper.init("zk.staging.srv:8080")
try:
if 0 <= hour <= 7: # 00:00~08:00之间的test配置会被清空
zk_children = zookeeper.get_children(zk, "/company/cash/jira")
if 'test' in zk_children:
zk_test = zookeeper.get(zk, "/company/cash/jira/test")
# 如果test节点存在且不为空,则清空配置
if zk_test[0] is not '':
zookeeper.set(zk, "/company/cash/jira/test", "")
except Exception, ex:
print ex.message
def set(self, path, value):
"""
Set the value of the ZooKeeper Node at `path`
Arguments:
- `path`: string
- `value`: string
Return: None
Exceptions: NoNodeError
"""
zookeeper.set(self._zk, path, value)
return
def control():
if request.form.get('restart', default=False):
nodevalue = zookeeper.get(zk, ROOT_NODE)
if nodevalue[0] != '':
config = json.loads(nodevalue[0])
config['restart'] = True
else:
config = {'restart': True}
zookeeper.set(zk, ROOT_NODE, json.dumps(config))
flash('Success')
return render_file('control.html')
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 UpdateProperty(self, prop, value):
if prop in self.props:
if value == self.props[prop]:
return
self.props[prop] = value;
data = ""
for (k,v) in self.props.items():
data += k
data += '='
data += v
data += '\r\n'
print "set zk data " + self.GetPath() + ' : ' + data
zookeeper.set(self.zk , self.GetPath(), data);
def test_sync_getset(self):
self.assertEqual(self.connected, True, "Not connected!")
(data,stat) = zookeeper.get(self.handle, "/zk-python-getsettest", None)
self.assertEqual(data, "on", "Data is not 'on' as expected: " + data)
ret = zookeeper.set(self.handle, "/zk-python-getsettest",
"off", stat["version"])
(data,stat) = zookeeper.get(self.handle, "/zk-python-getsettest", None)
self.assertEqual(data, "off", "Data is not 'off' as expected: " + data)
def UpdateProperty(self, prop, value):
if prop in self.props:
if value == self.props[prop]:
return
self.props[prop] = value;
data = ""
for (k,v) in self.props.items():
data += k
data += '='
data += v
data += '\r\n'
print INFO(datetime.datetime.now().strftime("[%Y-%m-%d %H:%M:%S] ") + "set zk data " + self.GetPath() + ":" + data)
zkinfolog = OpenZkLog("./log.txt")
zookeeper.set(self.zk , self.GetPath(), data);
CloseZkLog(zkinfolog)
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 update_node(self, path, value):
""" Sets the ZooKeeper node at path to value, creating the node if it
doesn't exist.
Args:
path: A PATH_SEPARATOR-separated str that represents the node whose value
should be updated.
value: A str representing the value that should be associated with the
updated node.
"""
logging.debug("Updating node at {0}, with new value {1}".format(path,
value))
self.wait_for_connect()
try:
zookeeper.set(self.handle, path, value)
except zookeeper.NoNodeException:
self.force_create_path(path, value)
except zookeeper.ZooKeeperException, zoo_exception:
logging.error("Problem setting path {0} with {1}, exception {2}"\
.format(path, value, str(zoo_exception)))
def test_lose_scope(self):
"""
The idea is to test that the reference counting doesn't
fail when we retain no references outside of the module
"""
self.ensureDeleted("/zk-python-lose-scope-test")
self.ensureCreated("/zk-python-lose-scope-test")
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() )
)
set_watcher()
gc.collect()
self.cv.acquire()
zookeeper.set(self.handle, "/zk-python-lose-scope-test", "test")
self.cv.wait(15)
self.assertEqual(self.callback_flag, True)
def set(self, value, version, await_update=1):
"""Set the value to store at this node. If this node doesn't exist, this
will raise NoNodeException; if the given version isn't the most recently
stored in zookeeper, this will raise BadVersionException. Other server
errors will raise other exceptions.
To stomp over the value, regardless of what is stored in zookeeper, set
version to -1.
"""
self.__zk._use_socket(lambda z:
zookeeper.set(z, self.path, value, version))
self._wait_version(await_update, version+1)
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)
def updateAgentSM(self, aID):
#t_stamp = rospy.get_rostime()
t_stamp = self.get_time()
#print("tstamp sec = {0}, nsec = {1}, ".format(t_stamp.secs,t_stamp.nsecs))
#print("tstamp = {0}".format(t_stamp))
#return
U = self.getUnsafeAgents(aID, t_stamp + TM + 2 * TD + TMan)
R = self.getReachableAgents(aID, t_stamp + TM + 2 * TD + TMan)
MR = {}
# Determine the MO and SM for every turn
for turn in U.keys():
MO = True
SM = U[turn]
for agent in U[turn]:
if not (agent in R):
MO = False
SM = []
break
MR[turn] = [t_stamp, MO, SM]
#Update MR for agent in zookeeper
zookeeper.set(self.handle, "/root/mr/" + str(aID), str(MR))
def set_data(self, path, data, version=None, return_data=False):
"""Blocking call to set zookeeper node's data.
Args:
path: zookeeper node path
data: zookeeper node data (string)
version = version if version is not None else -1
return_data: if True return data
Raises:
zookeeper.NoNodeException if node already exists.
zookeeper.*Exception for other failure scenarios.
"""
version = version if version is not None else -1
if return_data:
return zookeeper.set2(self.handle, path, data, version)
else:
return zookeeper.set(self.handle, path, data, version)
def set_data(self, path, data, version=None, return_data=False):
"""Blocking call to set zookeeper node's data.
Args:
path: zookeeper node path
data: zookeeper node data (string)
version = version if version is not None else -1
return_data: if True return data
Raises:
zookeeper.NoNodeException if node already exists.
zookeeper.*Exception for other failure scenarios.
"""
version = version if version is not None else -1
if return_data:
return zookeeper.set2(self.handle, path, data, version)
else:
return zookeeper.set(self.handle, path, data, version)
def test_sync_getset(self):
self.assertEqual(self.connected, True, "Not connected!")
(data,stat) = zookeeper.get(self.handle, "/zk-python-getsettest", None)
self.assertEqual(data, "on", "Data is not 'on' as expected: " + data)
ret = zookeeper.set(self.handle, "/zk-python-getsettest",
"off", stat["version"])
(data,stat) = zookeeper.get(self.handle, "/zk-python-getsettest", None)
self.assertEqual(data, "off", "Data is not 'off' as expected: " + data)
self.assertRaises(zookeeper.BadVersionException,
zookeeper.set,
self.handle,
"/zk-python-getsettest",
"test",
stat["version"]+1)
stat2 = zookeeper.set2(self.handle, "/zk-python-getsettest",
"set2", stat["version"])
self.assertNotEqual(stat2, None, "set2 call failed, return should not be None")
self.assertEqual(stat2["numChildren"], 0,
"set2 call failed, numChildren not 0 in set2 call")
(data,stat) = zookeeper.get(self.handle, "/zk-python-getsettest", None)
self.assertEqual(data, "set2", "Data is not 'set2' as expected: " + data)
def ensure_node(zh, path, content):
try: # Ensure the node exists
zookeeper.create(zh, path, content, new_acl_openbar(), 0)
except zookeeper.NodeExistsException as e:
zookeeper.set(zh, path, content)
def set(self, path, value): zookeeper.add_auth(self.handle, 'digest', AUTH, None) return zookeeper.set(self.handle, path, value)
def set(self, path, value):
return zookeeper.set(self.handle, path, value)
def set(self, path, data="", version=-1):
"""
设置节点的value，返回更新结果
"""
return zookeeper.set(self.handle, path, data, version)
def set(self, node, data, version):
assert isinstance(version,int)
return z.set(self.handle, node, data, version)
def set(self, path="", value=""):
try:
zookeeper.set(self.zk, path, value)
except zookeeper.NoNodeException:
self.create(path=path, value=value, refactor=False)
self.set(path=path, value=value, refactor=False)
def set(self, path, value):
zookeeper.add_auth(self.handle, 'digest', AUTH, None)
return zookeeper.set(self.handle, path, value)
def set(self, path, value):
return zookeeper.set(self.handle, path, value)
def modify(self, absname, value):
return zookeeper.set(self.zkhandle, absname, value)
zookeeper.aget(s, path, None, cb)
elif op == Operation.set:
cb = SetCallback()
zookeeper.aset(s, path, data, -1, cb)
elif op == Operation.delete:
cb = DeleteCallback()
zookeeper.adelete(s, path, -1, cb)
async_results.append(cb)
else:
if op == Operation.create:
zookeeper.create(s, path, data, acl,
zookeeper.EPHEMERAL if ephemeral else 0)
elif op == Operation.get:
zookeeper.get(s, path)
elif op == Operation.set:
zookeeper.set(s, path, data)
elif op == Operation.delete:
zookeeper.delete(s, path)
for cb in async_results:
cb.wait()
# only print node type for creation operation
node_type = ""
if op == Operation.create:
node_type = "ephemeral" if ephemeral else "permanent"
return "%5s %6s %8d %10s znodes " % \
("async" if async else "sync", op, count, node_type)
zookeeper.aget(s, path, None, cb)
elif op == Operation.set:
cb = SetCallback()
zookeeper.aset(s, path, data, -1, cb)
elif op == Operation.delete:
cb = DeleteCallback()
zookeeper.adelete(s, path, -1, cb)
async_results.append(cb)
else:
if op == Operation.create:
zookeeper.create(s, path, data, acl,
zookeeper.EPHEMERAL if ephemeral else 0)
elif op == Operation.get:
zookeeper.get(s, path)
elif op == Operation.set:
zookeeper.set(s, path, data)
elif op == Operation.delete:
zookeeper.delete(s, path)
for cb in async_results:
cb.wait()
# only print node type for creation operation
node_type = ""
if op == Operation.create:
node_type = "ephemeral" if ephemeral else "permanent"
return "%5s %6s %8d %10s znodes " % \
("async" if async else "sync", op, count, node_type)
def set(self, path, data="", version=-1):
return zookeeper.set(self.handle, path, data, version)
def set(self, path, data="", version=-1):
return zookeeper.set(self.handle, path, data, version)
def _update_server_status_in_zk(self, servers):
for s in servers:
path = '/'.join([site.ZK_ROOT_NODE, 'workers', s])
zookeeper.set(self._zk, path, '1')
def set(self, path, data):
return zookeeper.set(self.handle, self.root + path, data)
def ensure_node(zh, path, content):
try: # Ensure the node exists
zookeeper.create(zh, path, content, new_acl_openbar(), 0)
except zookeeper.NodeExistsException as e:
zookeeper.set(zh, path, content)
def set(self, path, data="", version=-1):
"""
设置节点的value，返回更新结果
"""
return zookeeper.set(self.handle, path, data, version)
def trigger_watch(client):
zookeeper.set(self.client2.handle, "/foobar-watched", "abc")
return watch_deferred
def modify(self, absname, value):
return zookeeper.set(self.zkhandle, absname, value)
