def create(self, path, value=b"", acl=None,
ephemeral=False, sequence=False, makepath=False):
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
if not isinstance(value, six.binary_type):
raise TypeError("value must be a byte string")
if acl:
raise NotImplementedError(_NO_ACL_MSG)
data_watches = []
child_watches = []
with self.storage.lock:
if sequence:
path = utils.normpath(path, keep_trailing=True)
else:
path = utils.normpath(path, keep_trailing=False)
if makepath:
for parent_path in utils.partition_path(path)[0:-1]:
if parent_path not in self.storage:
result = self.create(parent_path)
data_watches.extend(result[1])
child_watches.extend(result[2])
created, parents, path = self.storage.create(
path, value=value, sequence=sequence,
ephemeral=ephemeral, session_id=self.session_id)
if parents:
event = k_states.WatchedEvent(type=k_states.EventType.CHILD,
state=k_states.KeeperState.CONNECTED,
path=path)
child_watches.append((parents, event))
if created:
event = k_states.WatchedEvent(type=k_states.EventType.CREATED,
state=k_states.KeeperState.CONNECTED,
path=path)
data_watches.append(([path], event))
return (path, data_watches, child_watches)
def get_children(self, path, watch=None, include_data=False):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
def clean_path(p):
return p.strip("/")
path = utils.normpath(path)
with self.storage.lock:
if path not in self.storage:
raise k_exceptions.NoNodeError("Node %s does not exist"
% (path))
paths = self.storage.get_children(path)
if watch:
with self._watches_lock:
self._child_watchers[path].append(watch)
if include_data:
children_with_data = []
for (child_path, data) in six.iteritems(paths):
child_path = clean_path(child_path[len(path):])
children_with_data.append((child_path, data))
return children_with_data
else:
children = []
for child_path in six.iterkeys(paths):
child_path = clean_path(child_path[len(path):])
children.append(child_path)
return children
def get_children(self, path, watch=None, include_data=False):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
def clean_path(p):
return p.strip("/")
path = utils.normpath(path)
with self.storage.lock:
if path not in self.storage:
raise k_exceptions.NoNodeError("Node %s does not exist" %
(path))
paths = self.storage.get_children(path)
if watch:
with self._watches_lock:
self._child_watchers[path].append(watch)
if include_data:
children_with_data = []
for (child_path, data) in six.iteritems(paths):
child_path = clean_path(child_path[len(path):])
children_with_data.append((child_path, data))
return children_with_data
else:
children = []
for child_path in six.iterkeys(paths):
child_path = clean_path(child_path[len(path):])
children.append(child_path)
return children
def ensure_path(self, path):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
path = utils.normpath(path)
for piece in utils.partition_path(path):
try:
self.create(piece)
except k_exceptions.NodeExistsError:
pass
def create(self,
path,
value=b"",
acl=None,
ephemeral=False,
sequence=False,
makepath=False):
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
if not isinstance(value, six.binary_type):
raise TypeError("value must be a byte string")
if acl:
raise NotImplementedError(_NO_ACL_MSG)
data_watches = []
child_watches = []
with self.storage.lock:
if sequence:
path = utils.normpath(path, keep_trailing=True)
else:
path = utils.normpath(path, keep_trailing=False)
if makepath:
for parent_path in utils.partition_path(path)[0:-1]:
if parent_path not in self.storage:
result = self.create(parent_path)
data_watches.extend(result[1])
child_watches.extend(result[2])
created, parents, path = self.storage.create(
path,
value=value,
sequence=sequence,
ephemeral=ephemeral,
session_id=self.session_id)
if parents:
event = k_states.WatchedEvent(type=k_states.EventType.CHILD,
state=k_states.KeeperState.CONNECTED,
path=path)
child_watches.append((parents, event))
if created:
event = k_states.WatchedEvent(type=k_states.EventType.CREATED,
state=k_states.KeeperState.CONNECTED,
path=path)
data_watches.append(([path], event))
return (path, data_watches, child_watches)
def ensure_path(self, path):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
path = utils.normpath(path)
for piece in utils.partition_path(path):
try:
self.create(piece)
except k_exceptions.NodeExistsError:
pass
def exists(self, path, watch=None):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
path = utils.normpath(path)
try:
(data, exists) = self.storage.get(path)
except KeyError:
exists = None
if watch:
with self._watches_lock:
self._data_watchers[path].append(watch)
return exists
def get(self, path, watch=None):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
path = utils.normpath(path)
try:
(data, znode) = self.storage.get(path)
except KeyError:
raise k_exceptions.NoNodeError("Node %s does not exist" % (path))
if watch:
with self._watches_lock:
self._data_watchers[path].append(watch)
return (data, znode)
def exists(self, path, watch=None):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
path = utils.normpath(path)
try:
(data, exists) = self.storage.get(path)
except KeyError:
exists = None
if watch:
with self._watches_lock:
self._data_watchers[path].append(watch)
return exists
def get(self, path, watch=None):
self.verify()
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
path = utils.normpath(path)
try:
(data, znode) = self.storage.get(path)
except KeyError:
raise k_exceptions.NoNodeError("Node %s does not exist" % (path))
if watch:
with self._watches_lock:
self._data_watchers[path].append(watch)
return (data, znode)
def delete(self, path, version=-1, recursive=False):
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
data_watches = []
child_watches = []
path = utils.normpath(path)
with self.storage.lock:
if path not in self.storage:
raise k_exceptions.NoNodeError("Node %s does not exist"
% (path))
path_version = self.storage[path]['version']
if version != -1 and path_version != version:
raise k_exceptions.BadVersionError("Version mismatch"
" (%s != %s)"
% (version, path_version))
if recursive:
paths = [path]
children = self.storage.get_children(path, only_direct=False)
for child_path in six.iterkeys(children):
paths.append(child_path)
else:
children = self.storage.get_children(path, only_direct=False)
if children:
raise k_exceptions.NotEmptyError("Path %s is not-empty"
" (%s children exist)"
% (path, len(children)))
paths = [path]
paths = list(reversed(sorted(set(paths))))
with self.storage.transaction():
for path in paths:
self.storage.pop(path)
parents = []
for path in paths:
parents.extend(self.storage.get_parents(path))
parents = list(reversed(sorted(set(parents))))
for path in parents:
event = k_states.WatchedEvent(
type=k_states.EventType.DELETED,
state=k_states.KeeperState.CONNECTED,
path=path)
child_watches.append(([path], event))
for path in paths:
event = k_states.WatchedEvent(
type=k_states.EventType.DELETED,
state=k_states.KeeperState.CONNECTED,
path=path)
data_watches.append(([path], event))
return (True, data_watches, child_watches)
def delete(self, path, version=-1, recursive=False):
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
data_watches = []
child_watches = []
path = utils.normpath(path)
with self.storage.lock:
if path not in self.storage:
raise k_exceptions.NoNodeError("Node %s does not exist" %
(path))
path_version = self.storage[path]['version']
if version != -1 and path_version != version:
raise k_exceptions.BadVersionError("Version mismatch"
" (%s != %s)" %
(version, path_version))
if recursive:
paths = [path]
children = self.storage.get_children(path, only_direct=False)
for child_path in six.iterkeys(children):
paths.append(child_path)
else:
children = self.storage.get_children(path, only_direct=False)
if children:
raise k_exceptions.NotEmptyError("Path %s is not-empty"
" (%s children exist)" %
(path, len(children)))
paths = [path]
paths = list(reversed(sorted(set(paths))))
with self.storage.transaction():
for path in paths:
self.storage.pop(path)
parents = []
for path in paths:
parents.extend(self.storage.get_parents(path))
parents = list(reversed(sorted(set(parents))))
for path in parents:
event = k_states.WatchedEvent(
type=k_states.EventType.DELETED,
state=k_states.KeeperState.CONNECTED,
path=path)
child_watches.append(([path], event))
for path in paths:
event = k_states.WatchedEvent(
type=k_states.EventType.DELETED,
state=k_states.KeeperState.CONNECTED,
path=path)
data_watches.append(([path], event))
return (True, data_watches, child_watches)
def set(self, path, value, version=-1):
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
if not isinstance(value, six.binary_type):
raise TypeError("value must be a byte string")
if not isinstance(version, int):
raise TypeError("version must be an int")
path = utils.normpath(path)
try:
stat = self.storage.set(path, value, version=version)
except KeyError:
raise k_exceptions.NoNodeError("Node %s does not exist" % (path))
data_watches = []
child_watches = []
event = k_states.WatchedEvent(type=k_states.EventType.CHANGED,
state=k_states.KeeperState.CONNECTED,
path=path)
data_watches.append(([path], event))
return (stat, data_watches, child_watches)
def set(self, path, value, version=-1):
if not isinstance(path, six.string_types):
raise TypeError("path must be a string")
if not isinstance(value, six.binary_type):
raise TypeError("value must be a byte string")
if not isinstance(version, int):
raise TypeError("version must be an int")
path = utils.normpath(path)
try:
stat = self.storage.set(path, value, version=version)
except KeyError:
raise k_exceptions.NoNodeError("Node %s does not exist" % (path))
data_watches = []
child_watches = []
event = k_states.WatchedEvent(type=k_states.EventType.CHANGED,
state=k_states.KeeperState.CONNECTED,
path=path)
data_watches.append(([path], event))
return (stat, data_watches, child_watches)
