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)