def get_prefix(self,
key_prefix,
sort_order=None,
sort_target='key',
keys_only=False):
"""
Get a range of keys with a prefix.
:param key_prefix: first key in range
:param keys_only: if True, retrieve only the keys, not the values
:returns: sequence of (value, metadata) tuples
"""
range_request = self._build_get_range_request(
key=key_prefix,
range_end=utils.increment_last_byte(utils.to_bytes(key_prefix)),
sort_order=sort_order,
sort_target=sort_target,
keys_only=keys_only,
)
range_response = self.kvstub.Range(range_request,
self.timeout,
credentials=self.call_credentials,
metadata=self.metadata)
if range_response.count < 1:
return
else:
for kv in range_response.kvs:
yield (kv.value, KVMetadata(kv, range_response.header))
def delete_prefix(self, prefix):
"""Delete a range of keys with a prefix in etcd."""
delete_request = self._build_delete_request(
prefix,
range_end=utils.increment_last_byte(utils.to_bytes(prefix))
)
return self.kvstub.DeleteRange(delete_request, self.timeout)
def watch_prefix(self,
key_prefix,
start_revision=None,
progress_notify=False,
filters=None,
prev_kv=False):
"""
Watch a range of key with a prefix.
:param key_prefix: the key prefix wants to watch
:returns: streams of (event, cancel) tuples.
loop `event` to get the events of key changes and
use `cancel` to cancel the watch request
"""
cv = threading.Condition()
def cancel_watch():
cv.acquire()
cv.notify()
cv.release()
range_end = utils.increment_last_byte(utils.to_bytes(key_prefix))
request = self._build_watch_request(cv,
key_prefix,
range_end=range_end,
start_revision=start_revision,
progress_notify=progress_notify,
filters=filters,
prev_kv=prev_kv)
watcher = self.watchstub.Watch(request)
for event in watcher:
yield (event, cancel_watch)
def watch_range(db, key, cb):
kwargs = {}
kwargs['range_end'] = \
utils.increment_last_byte(utils.to_bytes(key))
def cb1(*args):
cb(key, *args)
return db.add_watch_callback(key=key, callback=cb1, **kwargs)
def watch_prefix_once(self, key_prefix, timeout=None, **kwargs):
"""
Watch a range of keys with a prefix and stop after the first event.
If the timeout was specified and event didn't arrive method
will raise ``WatchTimedOut`` exception.
"""
kwargs['range_end'] = \
utils.increment_last_byte(utils.to_bytes(key_prefix))
return self.watch_once(key_prefix, timeout=timeout, **kwargs)
def test_transaction_range_conditions(self, etcd):
etcdctl('put', '/doot/key1', 'dootdoot')
etcdctl('put', '/doot/key2', 'notdootdoot')
range_end = utils.increment_last_byte(utils.to_bytes('/doot/'))
compare = [etcd.transactions.value('/doot/', range_end) == 'dootdoot']
status, _ = etcd.transaction(compare=compare, success=[], failure=[])
assert not status
etcdctl('put', '/doot/key2', 'dootdoot')
status, _ = etcd.transaction(compare=compare, success=[], failure=[])
assert status
def watch_prefix(self, key_prefix, **kwargs):
"""
Watch a range of keys with a prefix.
:param key_prefix: prefix to watch
:returns: tuple of ``events_iterator`` and ``cancel``.
"""
kwargs['range_end'] = \
utils.increment_last_byte(utils.to_bytes(key_prefix))
return self.watch(key_prefix, **kwargs)
def get_prefix_response(self, key_prefix, **kwargs):
"""Get a range of keys with a prefix."""
if any(kwarg in kwargs for kwarg in ("key", "range_end")):
raise TypeError("Don't use key or range_end with prefix")
range_request = self._build_get_range_request(
key=key_prefix,
range_end=utils.increment_last_byte(utils.to_bytes(key_prefix)),
**kwargs)
return self.kvstub.Range(range_request,
self.timeout,
credentials=self.call_credentials,
metadata=self.metadata)
def add_watch_prefix_callback(self, key_prefix, callback, **kwargs):
"""
Watch a prefix and call a callback on every response.
If timeout was declared during the client initialization and
the watch cannot be created during that time the method raises
a ``WatchTimedOut`` exception.
:param key_prefix: prefix to watch
:param callback: callback function
:returns: watch_id. Later it could be used for cancelling watch.
"""
kwargs['range_end'] = \
utils.increment_last_byte(utils.to_bytes(key_prefix))
return self.add_watch_callback(key_prefix, callback, **kwargs)
def rolegrantpermission(self, role, path, perm_type, prefix):
perm = {"key": utils.to_bytes(path), "permType": perm_type}
rolegrantpermission_request = etcdrpc.AuthRoleGrantPermissionRequest(
name=role, perm=perm)
if prefix:
rolegrantpermission_request.perm.range_end = utils.increment_last_byte(
utils.to_bytes(path))
rolegrantpermission_responce = self.authstub.RoleGrantPermission(
rolegrantpermission_request,
self.timeout,
credentials=self.call_credentials,
metadata=self.metadata)
return rolegrantpermission_responce
def get_prefix_response(self, key_prefix, sort_order=None,
sort_target='key', keys_only=False):
"""Get a range of keys with a prefix."""
range_request = self._build_get_range_request(
key=key_prefix,
range_end=utils.increment_last_byte(utils.to_bytes(key_prefix)),
sort_order=sort_order,
sort_target=sort_target,
keys_only=keys_only,
)
return self.kvstub.Range(
range_request,
self.timeout,
credentials=self.call_credentials,
metadata=self.metadata
)
def watch_range_queue(queue: Queue, db: Etcd3Client, prefix):
kwargs = {}
kwargs['range_end'] = \
utils.increment_last_byte(utils.to_bytes(prefix))
def cb(event):
ident = event.key.decode()[len(prefix):]
if isinstance(event, DeleteEvent):
queue.put(
RangeEvent(prefix, ident, Ev.Delete, event.value,
event.version))
elif isinstance(event, PutEvent):
queue.put(
RangeEvent(prefix, ident, Ev.Put, event.value, event.version))
else:
logger.error(f'UnknownEvent: {event}')
return db.add_watch_callback(key=prefix, callback=cb, **kwargs)
def rolerevokepermission(self, role, path, prefix):
rolerevokepermission_request = etcdrpc.AuthRoleRevokePermissionRequest(
role=role, key=path)
if prefix:
rolerevokepermission_request.range_end = utils.increment_last_byte(
utils.to_bytes(path))
# else:
# rolerevokepermission_request.range_end = utils.to_bytes(path)
print(rolerevokepermission_request)
rolerevokepermission_responce = self.authstub.RoleRevokePermission(
rolerevokepermission_request,
self.timeout,
credentials=self.call_credentials,
metadata=self.metadata)
return rolerevokepermission_responce
def get_prefix(self, key_prefix, sort_order=None, sort_target='key'):
"""
Get a range of keys with a prefix.
:param key_prefix: first key in range
:returns: sequence of (value, metadata) tuples
"""
range_request = self._build_get_range_request(
key=key_prefix,
range_end=utils.increment_last_byte(utils.to_bytes(key_prefix)),
sort_order=sort_order,
)
range_response = self.kvstub.Range(range_request, self.timeout)
if range_response.count < 1:
return
else:
for kv in range_response.kvs:
yield (kv.value, KVMetadata(kv))
def get_prefix(self, key_prefix, sort_order=None, sort_target='key'):
"""
Get a range of keys with a prefix.
:param key_prefix: first key in range
:returns: sequence of (key, value) tuples
"""
range_request = self._build_get_range_request(
key=key_prefix,
range_end=utils.increment_last_byte(utils.to_bytes(key_prefix)),
sort_order=sort_order,
)
range_response = self.kvstub.Range(range_request)
if range_response.count < 1:
raise exceptions.KeyNotFoundError('no keys found')
else:
for kv in range_response.kvs:
yield (kv.key, kv.value)
def watch_prefix(self, key_prefix, **kwargs):
"""The same as ``watch``, but watches a range of keys with a prefix."""
kwargs['range_end'] = \
utils.increment_last_byte(utils.to_bytes(key_prefix))
return self.watch(key_prefix, **kwargs)
