Example #1
0
    async 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 = await self.kvstub.Range(
            range_request,
            self.timeout,
            credentials=self.call_credentials,
        )

        if range_response.count < 1:
            return
        else:
            for kv in range_response.kvs:
                yield (kv.value, KVMetadata(kv))
Example #2
0
    async def watch_prefix_once(self, key_prefix, timeout=None, **kwargs):
        """
        Watches a range of keys with a prefix and stops after the first event.

        If the timeout was specified and event didn't arrived method
        will raise ``WatchTimedOut`` exception.
        """
        kwargs['range_end'] = \
            utils.increment_last_byte(utils.to_bytes(key_prefix))
        return await self.watch_once(key_prefix, timeout=timeout, **kwargs)
Example #3
0
 async 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 await self.kvstub.DeleteRange(
         delete_request,
         self.timeout,
         credentials=self.call_credentials,
     )
Example #4
0
    async def get_count(self, key_prefix=None):
        """
        Get count of all keys or keys with specified prefix.

        :param key_prefix: key_prefix for keys to count
        :type key_prefix: str or bytes
        :return: number of keys with specified prefix
        :rtype: int
        """
        if key_prefix is not None:
            key = key_prefix
            range_end = utils.increment_last_byte(utils.to_bytes(key_prefix))
        else:
            key = range_end = b'\0'

        range_request = self._build_get_range_request(key,
                                                      range_end,
                                                      count_only=True)
        range_response = await self.kvstub.Range(
            range_request, self.timeout, credentials=self.call_credentials)
        return range_response.count
Example #5
0
    async def get_keys(self, key_prefix=None):
        """
        Get keys with specified prefix (all keys if no prefix specified).

        :param prefix: prefix for keys to count
        :type prefix: str or bytes
        :return: async generator of metadata objects
        """
        if key_prefix is not None:
            key = key_prefix
            range_end = utils.increment_last_byte(utils.to_bytes(key_prefix))
        else:
            key = range_end = b'\0'

        range_request = self._build_get_range_request(key,
                                                      range_end,
                                                      keys_only=True)
        range_response = await self.kvstub.Range(
            range_request, self.timeout, credentials=self.call_credentials)
        if range_response.count < 1:
            return
        else:
            for kv in range_response.kvs:
                yield KVMetadata(kv)
Example #6
0
 async def watch_prefix(self, key_prefix, **kwargs):
     """Watches a range of keys with a prefix."""
     kwargs['range_end'] = \
         utils.increment_last_byte(utils.to_bytes(key_prefix))
     return await self.watch(key_prefix, **kwargs)