+++ /dev/null
-# cython: embedsignature=True
-"""
-This module is a thin wrapper around librbd.
-
-It currently provides all the synchronous methods of librbd that do
-not use callbacks.
-
-Error codes from librbd are turned into exceptions that subclass
-:class:`Error`. Almost all methods may raise :class:`Error`
-(the base class of all rbd exceptions), :class:`PermissionError`
-and :class:`IOError`, in addition to those documented for the
-method.
-"""
-# Copyright 2011 Josh Durgin
-# Copyright 2015 Hector Martin <marcan@marcan.st>
-
-import cython
-import sys
-
-from cpython cimport PyObject, ref, exc
-from libc cimport errno
-from libc.stdint cimport *
-from libc.stdlib cimport realloc, free
-from libc.string cimport strdup
-
-from collections import Iterable
-from datetime import datetime
-
-cimport rados
-
-
-cdef extern from "Python.h":
- # These are in cpython/string.pxd, but use "object" types instead of
- # PyObject*, which invokes assumptions in cpython that we need to
- # legitimately break to implement zero-copy string buffers in Image.read().
- # This is valid use of the Python API and documented as a special case.
- PyObject *PyBytes_FromStringAndSize(char *v, Py_ssize_t len) except NULL
- char* PyBytes_AsString(PyObject *string) except NULL
- int _PyBytes_Resize(PyObject **string, Py_ssize_t newsize) except -1
-
-cdef extern from "time.h":
- ctypedef long int time_t
- cdef struct timespec:
- time_t tv_sec
- long tv_nsec
-
-cdef extern from "limits.h":
- cdef uint64_t INT64_MAX
-
-cdef extern from "rbd/librbd.h" nogil:
- enum:
- _RBD_FEATURE_LAYERING "RBD_FEATURE_LAYERING"
- _RBD_FEATURE_STRIPINGV2 "RBD_FEATURE_STRIPINGV2"
- _RBD_FEATURE_EXCLUSIVE_LOCK "RBD_FEATURE_EXCLUSIVE_LOCK"
- _RBD_FEATURE_OBJECT_MAP "RBD_FEATURE_OBJECT_MAP"
- _RBD_FEATURE_FAST_DIFF "RBD_FEATURE_FAST_DIFF"
- _RBD_FEATURE_DEEP_FLATTEN "RBD_FEATURE_DEEP_FLATTEN"
- _RBD_FEATURE_JOURNALING "RBD_FEATURE_JOURNALING"
- _RBD_FEATURE_DATA_POOL "RBD_FEATURE_DATA_POOL"
-
- _RBD_FEATURES_INCOMPATIBLE "RBD_FEATURES_INCOMPATIBLE"
- _RBD_FEATURES_RW_INCOMPATIBLE "RBD_FEATURES_RW_INCOMPATIBLE"
- _RBD_FEATURES_MUTABLE "RBD_FEATURES_MUTABLE"
- _RBD_FEATURES_SINGLE_CLIENT "RBD_FEATURES_SINGLE_CLIENT"
- _RBD_FEATURES_ALL "RBD_FEATURES_ALL"
-
- _RBD_FLAG_OBJECT_MAP_INVALID "RBD_FLAG_OBJECT_MAP_INVALID"
- _RBD_FLAG_FAST_DIFF_INVALID "RBD_FLAG_FAST_DIFF_INVALID"
-
- _RBD_IMAGE_OPTION_FORMAT "RBD_IMAGE_OPTION_FORMAT"
- _RBD_IMAGE_OPTION_FEATURES "RBD_IMAGE_OPTION_FEATURES"
- _RBD_IMAGE_OPTION_ORDER "RBD_IMAGE_OPTION_ORDER"
- _RBD_IMAGE_OPTION_STRIPE_UNIT "RBD_IMAGE_OPTION_STRIPE_UNIT"
- _RBD_IMAGE_OPTION_STRIPE_COUNT "RBD_IMAGE_OPTION_STRIPE_COUNT"
- _RBD_IMAGE_OPTION_DATA_POOL "RBD_IMAGE_OPTION_DATA_POOL"
-
- RBD_MAX_BLOCK_NAME_SIZE
- RBD_MAX_IMAGE_NAME_SIZE
-
- ctypedef void* rados_ioctx_t
- ctypedef void* rbd_image_t
- ctypedef void* rbd_image_options_t
- ctypedef void *rbd_completion_t
-
- ctypedef struct rbd_image_info_t:
- uint64_t size
- uint64_t obj_size
- uint64_t num_objs
- int order
- char block_name_prefix[RBD_MAX_BLOCK_NAME_SIZE]
- uint64_t parent_pool
- char parent_name[RBD_MAX_IMAGE_NAME_SIZE]
-
- ctypedef struct rbd_snap_info_t:
- uint64_t id
- uint64_t size
- char *name
-
- ctypedef enum rbd_mirror_mode_t:
- _RBD_MIRROR_MODE_DISABLED "RBD_MIRROR_MODE_DISABLED"
- _RBD_MIRROR_MODE_IMAGE "RBD_MIRROR_MODE_IMAGE"
- _RBD_MIRROR_MODE_POOL "RBD_MIRROR_MODE_POOL"
-
- ctypedef struct rbd_mirror_peer_t:
- char *uuid
- char *cluster_name
- char *client_name
-
- ctypedef enum rbd_mirror_image_state_t:
- _RBD_MIRROR_IMAGE_DISABLING "RBD_MIRROR_IMAGE_DISABLING"
- _RBD_MIRROR_IMAGE_ENABLED "RBD_MIRROR_IMAGE_ENABLED"
- _RBD_MIRROR_IMAGE_DISABLED "RBD_MIRROR_IMAGE_DISABLED"
-
- ctypedef struct rbd_mirror_image_info_t:
- char *global_id
- rbd_mirror_image_state_t state
- bint primary
-
- ctypedef enum rbd_mirror_image_status_state_t:
- _MIRROR_IMAGE_STATUS_STATE_UNKNOWN "MIRROR_IMAGE_STATUS_STATE_UNKNOWN"
- _MIRROR_IMAGE_STATUS_STATE_ERROR "MIRROR_IMAGE_STATUS_STATE_ERROR"
- _MIRROR_IMAGE_STATUS_STATE_SYNCING "MIRROR_IMAGE_STATUS_STATE_SYNCING"
- _MIRROR_IMAGE_STATUS_STATE_STARTING_REPLAY "MIRROR_IMAGE_STATUS_STATE_STARTING_REPLAY"
- _MIRROR_IMAGE_STATUS_STATE_REPLAYING "MIRROR_IMAGE_STATUS_STATE_REPLAYING"
- _MIRROR_IMAGE_STATUS_STATE_STOPPING_REPLAY "MIRROR_IMAGE_STATUS_STATE_STOPPING_REPLAY"
- _MIRROR_IMAGE_STATUS_STATE_STOPPED "MIRROR_IMAGE_STATUS_STATE_STOPPED"
-
- ctypedef struct rbd_mirror_image_status_t:
- char *name
- rbd_mirror_image_info_t info
- rbd_mirror_image_status_state_t state
- char *description
- time_t last_update
- bint up
-
- ctypedef enum rbd_lock_mode_t:
- _RBD_LOCK_MODE_EXCLUSIVE "RBD_LOCK_MODE_EXCLUSIVE"
- _RBD_LOCK_MODE_SHARED "RBD_LOCK_MODE_SHARED"
-
- ctypedef enum rbd_trash_image_source_t:
- _RBD_TRASH_IMAGE_SOURCE_USER "RBD_TRASH_IMAGE_SOURCE_USER",
- _RBD_TRASH_IMAGE_SOURCE_MIRRORING "RBD_TRASH_IMAGE_SOURCE_MIRRORING"
-
- ctypedef struct rbd_trash_image_info_t:
- char *id
- char *name
- rbd_trash_image_source_t source
- time_t deletion_time
- time_t deferment_end_time
-
- ctypedef void (*rbd_callback_t)(rbd_completion_t cb, void *arg)
- ctypedef int (*librbd_progress_fn_t)(uint64_t offset, uint64_t total, void* ptr)
-
- void rbd_version(int *major, int *minor, int *extra)
-
- void rbd_image_options_create(rbd_image_options_t* opts)
- void rbd_image_options_destroy(rbd_image_options_t opts)
- int rbd_image_options_set_string(rbd_image_options_t opts, int optname,
- const char* optval)
- int rbd_image_options_set_uint64(rbd_image_options_t opts, int optname,
- uint64_t optval)
- int rbd_image_options_get_string(rbd_image_options_t opts, int optname,
- char* optval, size_t maxlen)
- int rbd_image_options_get_uint64(rbd_image_options_t opts, int optname,
- uint64_t* optval)
- int rbd_image_options_unset(rbd_image_options_t opts, int optname)
- void rbd_image_options_clear(rbd_image_options_t opts)
- int rbd_image_options_is_empty(rbd_image_options_t opts)
-
- int rbd_list(rados_ioctx_t io, char *names, size_t *size)
- int rbd_create(rados_ioctx_t io, const char *name, uint64_t size,
- int *order)
- int rbd_create4(rados_ioctx_t io, const char *name, uint64_t size,
- rbd_image_options_t opts)
- int rbd_clone3(rados_ioctx_t p_ioctx, const char *p_name,
- const char *p_snapname, rados_ioctx_t c_ioctx,
- const char *c_name, rbd_image_options_t c_opts)
- int rbd_remove(rados_ioctx_t io, const char *name)
- int rbd_rename(rados_ioctx_t src_io_ctx, const char *srcname,
- const char *destname)
-
- int rbd_trash_move(rados_ioctx_t io, const char *name, uint64_t delay)
- int rbd_trash_get(rados_ioctx_t io, const char *id,
- rbd_trash_image_info_t *info)
- void rbd_trash_get_cleanup(rbd_trash_image_info_t *info)
- int rbd_trash_list(rados_ioctx_t io, rbd_trash_image_info_t *trash_entries,
- size_t *num_entries)
- void rbd_trash_list_cleanup(rbd_trash_image_info_t *trash_entries,
- size_t num_entries)
- int rbd_trash_remove(rados_ioctx_t io, const char *id, int force)
- int rbd_trash_restore(rados_ioctx_t io, const char *id, const char *name)
-
- int rbd_mirror_mode_get(rados_ioctx_t io, rbd_mirror_mode_t *mirror_mode)
- int rbd_mirror_mode_set(rados_ioctx_t io, rbd_mirror_mode_t mirror_mode)
- int rbd_mirror_peer_add(rados_ioctx_t io, char *uuid,
- size_t uuid_max_length, const char *cluster_name,
- const char *client_name)
- int rbd_mirror_peer_remove(rados_ioctx_t io, const char *uuid)
- int rbd_mirror_peer_list(rados_ioctx_t io_ctx, rbd_mirror_peer_t *peers,
- int *max_peers)
- void rbd_mirror_peer_list_cleanup(rbd_mirror_peer_t *peers, int max_peers)
- int rbd_mirror_peer_set_client(rados_ioctx_t io, const char *uuid,
- const char *client_name)
- int rbd_mirror_peer_set_cluster(rados_ioctx_t io_ctx, const char *uuid,
- const char *cluster_name)
- int rbd_mirror_image_status_list(rados_ioctx_t io, const char *start_id,
- size_t max, char **image_ids,
- rbd_mirror_image_status_t *images,
- size_t *len)
- void rbd_mirror_image_status_list_cleanup(char **image_ids,
- rbd_mirror_image_status_t *images,
- size_t len)
- int rbd_mirror_image_status_summary(rados_ioctx_t io,
- rbd_mirror_image_status_state_t *states,
- int *counts, size_t *maxlen)
-
- int rbd_open(rados_ioctx_t io, const char *name,
- rbd_image_t *image, const char *snap_name)
- int rbd_open_read_only(rados_ioctx_t io, const char *name,
- rbd_image_t *image, const char *snap_name)
- int rbd_close(rbd_image_t image)
- int rbd_resize(rbd_image_t image, uint64_t size)
- int rbd_stat(rbd_image_t image, rbd_image_info_t *info, size_t infosize)
- int rbd_get_old_format(rbd_image_t image, uint8_t *old)
- int rbd_get_size(rbd_image_t image, uint64_t *size)
- int rbd_get_features(rbd_image_t image, uint64_t *features)
- int rbd_update_features(rbd_image_t image, uint64_t features,
- uint8_t enabled)
- int rbd_get_stripe_unit(rbd_image_t image, uint64_t *stripe_unit)
- int rbd_get_stripe_count(rbd_image_t image, uint64_t *stripe_count)
- int rbd_get_create_timestamp(rbd_image_t image, timespec *timestamp)
- int rbd_get_overlap(rbd_image_t image, uint64_t *overlap)
- int rbd_get_id(rbd_image_t image, char *id, size_t id_len)
- int rbd_get_block_name_prefix(rbd_image_t image, char *prefix,
- size_t prefix_len)
- int rbd_get_parent_info2(rbd_image_t image,
- char *parent_poolname, size_t ppoolnamelen,
- char *parent_name, size_t pnamelen,
- char *parent_id, size_t pidlen,
- char *parent_snapname, size_t psnapnamelen)
- int rbd_get_flags(rbd_image_t image, uint64_t *flags)
- ssize_t rbd_read2(rbd_image_t image, uint64_t ofs, size_t len,
- char *buf, int op_flags)
- ssize_t rbd_write2(rbd_image_t image, uint64_t ofs, size_t len,
- const char *buf, int op_flags)
- int rbd_discard(rbd_image_t image, uint64_t ofs, uint64_t len)
- int rbd_copy3(rbd_image_t src, rados_ioctx_t dest_io_ctx,
- const char *destname, rbd_image_options_t dest_opts)
- int rbd_snap_list(rbd_image_t image, rbd_snap_info_t *snaps,
- int *max_snaps)
- void rbd_snap_list_end(rbd_snap_info_t *snaps)
- int rbd_snap_create(rbd_image_t image, const char *snapname)
- int rbd_snap_remove(rbd_image_t image, const char *snapname)
- int rbd_snap_remove2(rbd_image_t image, const char *snapname, uint32_t flags,
- librbd_progress_fn_t cb, void *cbdata)
- int rbd_snap_rollback(rbd_image_t image, const char *snapname)
- int rbd_snap_rename(rbd_image_t image, const char *snapname,
- const char* dstsnapsname)
- int rbd_snap_protect(rbd_image_t image, const char *snap_name)
- int rbd_snap_unprotect(rbd_image_t image, const char *snap_name)
- int rbd_snap_is_protected(rbd_image_t image, const char *snap_name,
- int *is_protected)
- int rbd_snap_get_limit(rbd_image_t image, uint64_t *limit)
- int rbd_snap_set_limit(rbd_image_t image, uint64_t limit)
- int rbd_snap_get_timestamp(rbd_image_t image, uint64_t snap_id, timespec *timestamp)
- int rbd_snap_set(rbd_image_t image, const char *snapname)
- int rbd_flatten(rbd_image_t image)
- int rbd_rebuild_object_map(rbd_image_t image, librbd_progress_fn_t cb,
- void *cbdata)
- ssize_t rbd_list_children(rbd_image_t image, char *pools, size_t *pools_len,
- char *images, size_t *images_len)
- ssize_t rbd_list_lockers(rbd_image_t image, int *exclusive,
- char *tag, size_t *tag_len,
- char *clients, size_t *clients_len,
- char *cookies, size_t *cookies_len,
- char *addrs, size_t *addrs_len)
- int rbd_lock_exclusive(rbd_image_t image, const char *cookie)
- int rbd_lock_shared(rbd_image_t image, const char *cookie,
- const char *tag)
- int rbd_unlock(rbd_image_t image, const char *cookie)
- int rbd_break_lock(rbd_image_t image, const char *client,
- const char *cookie)
-
- int rbd_is_exclusive_lock_owner(rbd_image_t image, int *is_owner)
- int rbd_lock_acquire(rbd_image_t image, rbd_lock_mode_t lock_mode)
- int rbd_lock_release(rbd_image_t image)
- int rbd_lock_get_owners(rbd_image_t image, rbd_lock_mode_t *lock_mode,
- char **lock_owners, size_t *max_lock_owners)
- void rbd_lock_get_owners_cleanup(char **lock_owners,
- size_t lock_owner_count)
- int rbd_lock_break(rbd_image_t image, rbd_lock_mode_t lock_mode,
- char *lock_owner)
-
- # We use -9000 to propagate Python exceptions. We use except? to make sure
- # things still work as intended if -9000 happens to be a valid errno value
- # somewhere.
- int rbd_diff_iterate2(rbd_image_t image, const char *fromsnapname,
- uint64_t ofs, uint64_t len,
- uint8_t include_parent, uint8_t whole_object,
- int (*cb)(uint64_t, size_t, int, void *)
- nogil except? -9000,
- void *arg) except? -9000
-
- int rbd_flush(rbd_image_t image)
- int rbd_invalidate_cache(rbd_image_t image)
-
- int rbd_mirror_image_enable(rbd_image_t image)
- int rbd_mirror_image_disable(rbd_image_t image, bint force)
- int rbd_mirror_image_promote(rbd_image_t image, bint force)
- int rbd_mirror_image_demote(rbd_image_t image)
- int rbd_mirror_image_resync(rbd_image_t image)
- int rbd_mirror_image_get_info(rbd_image_t image,
- rbd_mirror_image_info_t *mirror_image_info,
- size_t info_size)
- int rbd_mirror_image_get_status(rbd_image_t image,
- rbd_mirror_image_status_t *mirror_image_status,
- size_t status_size)
-
- int rbd_aio_write2(rbd_image_t image, uint64_t off, size_t len,
- const char *buf, rbd_completion_t c, int op_flags)
- int rbd_aio_read2(rbd_image_t image, uint64_t off, size_t len,
- char *buf, rbd_completion_t c, int op_flags)
- int rbd_aio_discard(rbd_image_t image, uint64_t off, uint64_t len,
- rbd_completion_t c)
-
- int rbd_aio_create_completion(void *cb_arg, rbd_callback_t complete_cb,
- rbd_completion_t *c)
- int rbd_aio_is_complete(rbd_completion_t c)
- int rbd_aio_wait_for_complete(rbd_completion_t c)
- ssize_t rbd_aio_get_return_value(rbd_completion_t c)
- void rbd_aio_release(rbd_completion_t c)
- int rbd_aio_flush(rbd_image_t image, rbd_completion_t c)
-
- int rbd_metadata_get(rbd_image_t image, const char *key, char *value,
- size_t *val_len)
- int rbd_metadata_set(rbd_image_t image, const char *key, const char *value)
- int rbd_metadata_remove(rbd_image_t image, const char *key)
- int rbd_metadata_list(rbd_image_t image, const char *start, uint64_t max,
- char *keys, size_t *key_len, char *values,
- size_t *vals_len)
-
-RBD_FEATURE_LAYERING = _RBD_FEATURE_LAYERING
-RBD_FEATURE_STRIPINGV2 = _RBD_FEATURE_STRIPINGV2
-RBD_FEATURE_EXCLUSIVE_LOCK = _RBD_FEATURE_EXCLUSIVE_LOCK
-RBD_FEATURE_OBJECT_MAP = _RBD_FEATURE_OBJECT_MAP
-RBD_FEATURE_FAST_DIFF = _RBD_FEATURE_FAST_DIFF
-RBD_FEATURE_DEEP_FLATTEN = _RBD_FEATURE_DEEP_FLATTEN
-RBD_FEATURE_JOURNALING = _RBD_FEATURE_JOURNALING
-RBD_FEATURE_DATA_POOL = _RBD_FEATURE_DATA_POOL
-
-RBD_FEATURES_INCOMPATIBLE = _RBD_FEATURES_INCOMPATIBLE
-RBD_FEATURES_RW_INCOMPATIBLE = _RBD_FEATURES_RW_INCOMPATIBLE
-RBD_FEATURES_MUTABLE = _RBD_FEATURES_MUTABLE
-RBD_FEATURES_SINGLE_CLIENT = _RBD_FEATURES_SINGLE_CLIENT
-RBD_FEATURES_ALL = _RBD_FEATURES_ALL
-
-RBD_FLAG_OBJECT_MAP_INVALID = _RBD_FLAG_OBJECT_MAP_INVALID
-
-RBD_MIRROR_MODE_DISABLED = _RBD_MIRROR_MODE_DISABLED
-RBD_MIRROR_MODE_IMAGE = _RBD_MIRROR_MODE_IMAGE
-RBD_MIRROR_MODE_POOL = _RBD_MIRROR_MODE_POOL
-
-RBD_MIRROR_IMAGE_DISABLING = _RBD_MIRROR_IMAGE_DISABLING
-RBD_MIRROR_IMAGE_ENABLED = _RBD_MIRROR_IMAGE_ENABLED
-RBD_MIRROR_IMAGE_DISABLED = _RBD_MIRROR_IMAGE_DISABLED
-
-MIRROR_IMAGE_STATUS_STATE_UNKNOWN = _MIRROR_IMAGE_STATUS_STATE_UNKNOWN
-MIRROR_IMAGE_STATUS_STATE_ERROR = _MIRROR_IMAGE_STATUS_STATE_ERROR
-MIRROR_IMAGE_STATUS_STATE_SYNCING = _MIRROR_IMAGE_STATUS_STATE_SYNCING
-MIRROR_IMAGE_STATUS_STATE_STARTING_REPLAY = _MIRROR_IMAGE_STATUS_STATE_STARTING_REPLAY
-MIRROR_IMAGE_STATUS_STATE_REPLAYING = _MIRROR_IMAGE_STATUS_STATE_REPLAYING
-MIRROR_IMAGE_STATUS_STATE_STOPPING_REPLAY = _MIRROR_IMAGE_STATUS_STATE_STOPPING_REPLAY
-MIRROR_IMAGE_STATUS_STATE_STOPPED = _MIRROR_IMAGE_STATUS_STATE_STOPPED
-
-RBD_LOCK_MODE_EXCLUSIVE = _RBD_LOCK_MODE_EXCLUSIVE
-RBD_LOCK_MODE_SHARED = _RBD_LOCK_MODE_SHARED
-
-RBD_IMAGE_OPTION_FORMAT = _RBD_IMAGE_OPTION_FORMAT
-RBD_IMAGE_OPTION_FEATURES = _RBD_IMAGE_OPTION_FEATURES
-RBD_IMAGE_OPTION_ORDER = _RBD_IMAGE_OPTION_ORDER
-RBD_IMAGE_OPTION_STRIPE_UNIT = _RBD_IMAGE_OPTION_STRIPE_UNIT
-RBD_IMAGE_OPTION_STRIPE_COUNT = _RBD_IMAGE_OPTION_STRIPE_COUNT
-RBD_IMAGE_OPTION_DATA_POOL = _RBD_IMAGE_OPTION_DATA_POOL
-
-class Error(Exception):
- pass
-
-
-class OSError(Error):
- """ `OSError` class, derived from `Error` """
- def __init__(self, message, errno=None):
- super(OSError, self).__init__(message)
- self.errno = errno
-
- def __str__(self):
- msg = super(OSError, self).__str__()
- if self.errno is None:
- return msg
- return '[errno {0}] {1}'.format(self.errno, msg)
-
- def __reduce__(self):
- return (self.__class__, (self.message, self.errno))
-
-class PermissionError(OSError):
- pass
-
-
-class ImageNotFound(OSError):
- pass
-
-
-class ImageExists(OSError):
- pass
-
-
-class IOError(OSError):
- pass
-
-
-class NoSpace(OSError):
- pass
-
-
-class IncompleteWriteError(OSError):
- pass
-
-
-class InvalidArgument(OSError):
- pass
-
-
-class LogicError(Error):
- pass
-
-
-class ReadOnlyImage(OSError):
- pass
-
-
-class ImageBusy(OSError):
- pass
-
-
-class ImageHasSnapshots(OSError):
- pass
-
-
-class FunctionNotSupported(OSError):
- pass
-
-
-class ArgumentOutOfRange(OSError):
- pass
-
-
-class ConnectionShutdown(OSError):
- pass
-
-
-class Timeout(OSError):
- pass
-
-class DiskQuotaExceeded(OSError):
- pass
-
-
-cdef errno_to_exception = {
- errno.EPERM : PermissionError,
- errno.ENOENT : ImageNotFound,
- errno.EIO : IOError,
- errno.ENOSPC : NoSpace,
- errno.EEXIST : ImageExists,
- errno.EINVAL : InvalidArgument,
- errno.EROFS : ReadOnlyImage,
- errno.EBUSY : ImageBusy,
- errno.ENOTEMPTY : ImageHasSnapshots,
- errno.ENOSYS : FunctionNotSupported,
- errno.EDOM : ArgumentOutOfRange,
- errno.ESHUTDOWN : ConnectionShutdown,
- errno.ETIMEDOUT : Timeout,
- errno.EDQUOT : DiskQuotaExceeded,
-}
-
-cdef make_ex(ret, msg):
- """
- Translate a librbd return code into an exception.
-
- :param ret: the return code
- :type ret: int
- :param msg: the error message to use
- :type msg: str
- :returns: a subclass of :class:`Error`
- """
- ret = abs(ret)
- if ret in errno_to_exception:
- return errno_to_exception[ret](msg, errno=ret)
- else:
- return OSError(msg, errno=ret)
-
-
-cdef rados_ioctx_t convert_ioctx(rados.Ioctx ioctx) except? NULL:
- return <rados_ioctx_t>ioctx.io
-
-cdef int no_op_progress_callback(uint64_t offset, uint64_t total, void* ptr) nogil:
- return 0
-
-def cstr(val, name, encoding="utf-8", opt=False):
- """
- Create a byte string from a Python string
-
- :param basestring val: Python string
- :param str name: Name of the string parameter, for exceptions
- :param str encoding: Encoding to use
- :param bool opt: If True, None is allowed
- :rtype: bytes
- :raises: :class:`InvalidArgument`
- """
- if opt and val is None:
- return None
- if isinstance(val, bytes):
- return val
- elif isinstance(val, unicode):
- return val.encode(encoding)
- else:
- raise InvalidArgument('%s must be a string' % name)
-
-def decode_cstr(val, encoding="utf-8"):
- """
- Decode a byte string into a Python string.
-
- :param bytes val: byte string
- :rtype: unicode or None
- """
- if val is None:
- return None
-
- return val.decode(encoding)
-
-
-cdef char* opt_str(s) except? NULL:
- if s is None:
- return NULL
- return s
-
-cdef void* realloc_chk(void* ptr, size_t size) except NULL:
- cdef void *ret = realloc(ptr, size)
- if ret == NULL:
- raise MemoryError("realloc failed")
- return ret
-
-cdef class Completion
-
-cdef void __aio_complete_cb(rbd_completion_t completion, void *args) with gil:
- """
- Callback to oncomplete() for asynchronous operations
- """
- cdef Completion cb = <Completion>args
- cb._complete()
-
-
-cdef class Completion(object):
- """completion object"""
-
- cdef:
- object image
- object oncomplete
- rbd_completion_t rbd_comp
- PyObject* buf
- bint persisted
- object exc_info
-
- def __cinit__(self, image, object oncomplete):
- self.oncomplete = oncomplete
- self.image = image
- self.persisted = False
-
- def is_complete(self):
- """
- Has an asynchronous operation completed?
-
- This does not imply that the callback has finished.
-
- :returns: True if the operation is completed
- """
- with nogil:
- ret = rbd_aio_is_complete(self.rbd_comp)
- return ret == 1
-
- def wait_for_complete_and_cb(self):
- """
- Wait for an asynchronous operation to complete
-
- This method waits for the callback to execute, if one was provided.
- It will also re-raise any exceptions raised by the callback. You
- should call this to "reap" asynchronous completions and ensure that
- any exceptions in the callbacks are handled, as an exception internal
- to this module may have occurred.
- """
- with nogil:
- rbd_aio_wait_for_complete(self.rbd_comp)
-
- if self.exc_info:
- raise self.exc_info[0], self.exc_info[1], self.exc_info[2]
-
- def get_return_value(self):
- """
- Get the return value of an asychronous operation
-
- The return value is set when the operation is complete.
-
- :returns: int - return value of the operation
- """
- with nogil:
- ret = rbd_aio_get_return_value(self.rbd_comp)
- return ret
-
- def __dealloc__(self):
- """
- Release a completion
-
- This is automatically called when the completion object is freed.
- """
- ref.Py_XDECREF(self.buf)
- self.buf = NULL
- if self.rbd_comp != NULL:
- with nogil:
- rbd_aio_release(self.rbd_comp)
- self.rbd_comp = NULL
-
- cdef void _complete(self):
- try:
- self.__unpersist()
- if self.oncomplete:
- self.oncomplete(self)
- # In the event that something raises an exception during the next 2
- # lines of code, we will not be able to catch it, and this may result
- # in the app not noticing a failed callback. However, this should only
- # happen in extreme circumstances (OOM, etc.). KeyboardInterrupt
- # should not be a problem because the callback thread from librbd
- # ought to have SIGINT blocked.
- except:
- self.exc_info = sys.exc_info()
-
- cdef __persist(self):
- if self.oncomplete is not None and not self.persisted:
- # Increment our own reference count to make sure the completion
- # is not freed until the callback is called. The completion is
- # allowed to be freed if there is no callback.
- ref.Py_INCREF(self)
- self.persisted = True
-
- cdef __unpersist(self):
- if self.persisted:
- ref.Py_DECREF(self)
- self.persisted = False
-
-
-class RBD(object):
- """
- This class wraps librbd CRUD functions.
- """
- def version(self):
- """
- Get the version number of the ``librbd`` C library.
-
- :returns: a tuple of ``(major, minor, extra)`` components of the
- librbd version
- """
- cdef int major = 0
- cdef int minor = 0
- cdef int extra = 0
- rbd_version(&major, &minor, &extra)
- return (major, minor, extra)
-
- def create(self, ioctx, name, size, order=None, old_format=True,
- features=None, stripe_unit=None, stripe_count=None,
- data_pool=None):
- """
- Create an rbd image.
-
- :param ioctx: the context in which to create the image
- :type ioctx: :class:`rados.Ioctx`
- :param name: what the image is called
- :type name: str
- :param size: how big the image is in bytes
- :type size: int
- :param order: the image is split into (2**order) byte objects
- :type order: int
- :param old_format: whether to create an old-style image that
- is accessible by old clients, but can't
- use more advanced features like layering.
- :type old_format: bool
- :param features: bitmask of features to enable
- :type features: int
- :param stripe_unit: stripe unit in bytes (default None to let librbd decide)
- :type stripe_unit: int
- :param stripe_count: objects to stripe over before looping
- :type stripe_count: int
- :param data_pool: optional separate pool for data blocks
- :type data_pool: str
- :raises: :class:`ImageExists`
- :raises: :class:`TypeError`
- :raises: :class:`InvalidArgument`
- :raises: :class:`FunctionNotSupported`
- """
- name = cstr(name, 'name')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_name = name
- uint64_t _size = size
- int _order = 0
- rbd_image_options_t opts
- if order is not None:
- _order = order
- if old_format:
- if (features or
- ((stripe_unit is not None) and stripe_unit != 0) or
- ((stripe_count is not None) and stripe_count != 0) or
- data_pool):
- raise InvalidArgument('format 1 images do not support feature '
- 'masks, non-default striping, nor data '
- 'pool')
- with nogil:
- ret = rbd_create(_ioctx, _name, _size, &_order)
- else:
- rbd_image_options_create(&opts)
- try:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_FORMAT,
- 1 if old_format else 2)
- if features is not None:
- rbd_image_options_set_uint64(opts,
- RBD_IMAGE_OPTION_FEATURES,
- features)
- if order is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_ORDER,
- _order)
- if stripe_unit is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_STRIPE_UNIT,
- stripe_unit)
- if stripe_count is not None:
- rbd_image_options_set_uint64(opts,
- RBD_IMAGE_OPTION_STRIPE_COUNT,
- stripe_count)
- if data_pool is not None:
- rbd_image_options_set_string(opts,
- RBD_IMAGE_OPTION_DATA_POOL,
- data_pool)
- with nogil:
- ret = rbd_create4(_ioctx, _name, _size, opts)
- finally:
- rbd_image_options_destroy(opts)
- if ret < 0:
- raise make_ex(ret, 'error creating image')
-
- def clone(self, p_ioctx, p_name, p_snapname, c_ioctx, c_name,
- features=None, order=None, stripe_unit=None, stripe_count=None,
- data_pool=None):
- """
- Clone a parent rbd snapshot into a COW sparse child.
-
- :param p_ioctx: the parent context that represents the parent snap
- :type ioctx: :class:`rados.Ioctx`
- :param p_name: the parent image name
- :type name: str
- :param p_snapname: the parent image snapshot name
- :type name: str
- :param c_ioctx: the child context that represents the new clone
- :type ioctx: :class:`rados.Ioctx`
- :param c_name: the clone (child) name
- :type name: str
- :param features: bitmask of features to enable; if set, must include layering
- :type features: int
- :param order: the image is split into (2**order) byte objects
- :type order: int
- :param stripe_unit: stripe unit in bytes (default None to let librbd decide)
- :type stripe_unit: int
- :param stripe_count: objects to stripe over before looping
- :type stripe_count: int
- :param data_pool: optional separate pool for data blocks
- :type data_pool: str
- :raises: :class:`TypeError`
- :raises: :class:`InvalidArgument`
- :raises: :class:`ImageExists`
- :raises: :class:`FunctionNotSupported`
- :raises: :class:`ArgumentOutOfRange`
- """
- p_snapname = cstr(p_snapname, 'p_snapname')
- p_name = cstr(p_name, 'p_name')
- c_name = cstr(c_name, 'c_name')
- cdef:
- rados_ioctx_t _p_ioctx = convert_ioctx(p_ioctx)
- rados_ioctx_t _c_ioctx = convert_ioctx(c_ioctx)
- char *_p_name = p_name
- char *_p_snapname = p_snapname
- char *_c_name = c_name
- rbd_image_options_t opts
-
- rbd_image_options_create(&opts)
- try:
- if features is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_FEATURES,
- features)
- if order is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_ORDER,
- order)
- if stripe_unit is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_STRIPE_UNIT,
- stripe_unit)
- if stripe_count is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_STRIPE_COUNT,
- stripe_count)
- if data_pool is not None:
- rbd_image_options_set_string(opts, RBD_IMAGE_OPTION_DATA_POOL,
- data_pool)
- with nogil:
- ret = rbd_clone3(_p_ioctx, _p_name, _p_snapname,
- _c_ioctx, _c_name, opts)
- finally:
- rbd_image_options_destroy(opts)
- if ret < 0:
- raise make_ex(ret, 'error creating clone')
-
- def list(self, ioctx):
- """
- List image names.
-
- :param ioctx: determines which RADOS pool is read
- :type ioctx: :class:`rados.Ioctx`
- :returns: list -- a list of image names
- """
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- size_t size = 512
- char *c_names = NULL
- try:
- while True:
- c_names = <char *>realloc_chk(c_names, size)
- with nogil:
- ret = rbd_list(_ioctx, c_names, &size)
- if ret >= 0:
- break
- elif ret != -errno.ERANGE:
- raise make_ex(ret, 'error listing images')
- return [decode_cstr(name) for name in c_names[:ret].split(b'\0')
- if name]
- finally:
- free(c_names)
-
- def remove(self, ioctx, name):
- """
- Delete an RBD image. This may take a long time, since it does
- not return until every object that comprises the image has
- been deleted. Note that all snapshots must be deleted before
- the image can be removed. If there are snapshots left,
- :class:`ImageHasSnapshots` is raised. If the image is still
- open, or the watch from a crashed client has not expired,
- :class:`ImageBusy` is raised.
-
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :param name: the name of the image to remove
- :type name: str
- :raises: :class:`ImageNotFound`, :class:`ImageBusy`,
- :class:`ImageHasSnapshots`
- """
- name = cstr(name, 'name')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_name = name
- with nogil:
- ret = rbd_remove(_ioctx, _name)
- if ret != 0:
- raise make_ex(ret, 'error removing image')
-
- def rename(self, ioctx, src, dest):
- """
- Rename an RBD image.
-
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :param src: the current name of the image
- :type src: str
- :param dest: the new name of the image
- :type dest: str
- :raises: :class:`ImageNotFound`, :class:`ImageExists`
- """
- src = cstr(src, 'src')
- dest = cstr(dest, 'dest')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_src = src
- char *_dest = dest
- with nogil:
- ret = rbd_rename(_ioctx, _src, _dest)
- if ret != 0:
- raise make_ex(ret, 'error renaming image')
-
- def trash_move(self, ioctx, name, delay=0):
- """
- Move an RBD image to the trash.
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :param name: the name of the image to remove
- :type name: str
- :param delay: time delay in seconds before the image can be deleted
- from trash
- :type delay: int
- :raises: :class:`ImageNotFound`
- """
- name = cstr(name, 'name')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_name = name
- uint64_t _delay = delay
- with nogil:
- ret = rbd_trash_move(_ioctx, _name, _delay)
- if ret != 0:
- raise make_ex(ret, 'error moving image to trash')
-
- def trash_remove(self, ioctx, image_id, force=False):
- """
- Delete an RBD image from trash. If image deferment time has not
- expired :class:`PermissionError` is raised.
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :param image_id: the id of the image to remove
- :type image_id: str
- :param force: force remove even if deferment time has not expired
- :type force: bool
- :raises: :class:`ImageNotFound`, :class:`PermissionError`
- """
- image_id = cstr(image_id, 'image_id')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_image_id = image_id
- int _force = force
- with nogil:
- ret = rbd_trash_remove(_ioctx, _image_id, _force)
- if ret != 0:
- raise make_ex(ret, 'error deleting image from trash')
-
- def trash_get(self, ioctx, image_id):
- """
- Retrieve RBD image info from trash
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :param image_id: the id of the image to restore
- :type image_id: str
- :returns: dict - contains the following keys:
-
- * ``id`` (str) - image id
-
- * ``name`` (str) - image name
-
- * ``source`` (str) - source of deletion
-
- * ``deletion_time`` (datetime) - time of deletion
-
- * ``deferment_end_time`` (datetime) - time that an image is allowed
- to be removed from trash
-
- :raises: :class:`ImageNotFound`
- """
- image_id = cstr(image_id, 'image_id')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_image_id = image_id
- rbd_trash_image_info_t c_info
- with nogil:
- ret = rbd_trash_get(_ioctx, _image_id, &c_info)
- if ret != 0:
- raise make_ex(ret, 'error restoring image from trash')
-
- __source_string = ['USER', 'MIRRORING']
- info = {
- 'id' : decode_cstr(c_info.id),
- 'name' : decode_cstr(c_info.name),
- 'source' : __source_string[c_info.source],
- 'deletion_time' : datetime.fromtimestamp(c_info.deletion_time),
- 'deferment_end_time' : datetime.fromtimestamp(c_info.deferment_end_time)
- }
- rbd_trash_get_cleanup(&c_info)
- return info
-
- def trash_list(self, ioctx):
- """
- List all entries from trash.
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :returns: :class:`TrashIterator`
- """
- return TrashIterator(ioctx)
-
- def trash_restore(self, ioctx, image_id, name):
- """
- Restore an RBD image from trash.
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :param image_id: the id of the image to restore
- :type image_id: str
- :param name: the new name of the restored image
- :type name: str
- :raises: :class:`ImageNotFound`
- """
- image_id = cstr(image_id, 'image_id')
- name = cstr(name, 'name')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_image_id = image_id
- char *_name = name
- with nogil:
- ret = rbd_trash_restore(_ioctx, _image_id, _name)
- if ret != 0:
- raise make_ex(ret, 'error restoring image from trash')
-
- def mirror_mode_get(self, ioctx):
- """
- Get pool mirror mode.
-
- :param ioctx: determines which RADOS pool is read
- :type ioctx: :class:`rados.Ioctx`
- :returns: int - pool mirror mode
- """
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- rbd_mirror_mode_t mirror_mode
- with nogil:
- ret = rbd_mirror_mode_get(_ioctx, &mirror_mode)
- if ret != 0:
- raise make_ex(ret, 'error getting mirror mode')
- return mirror_mode
-
- def mirror_mode_set(self, ioctx, mirror_mode):
- """
- Set pool mirror mode.
-
- :param ioctx: determines which RADOS pool is written
- :type ioctx: :class:`rados.Ioctx`
- :param mirror_mode: mirror mode to set
- :type mirror_mode: int
- """
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- rbd_mirror_mode_t _mirror_mode = mirror_mode
- with nogil:
- ret = rbd_mirror_mode_set(_ioctx, _mirror_mode)
- if ret != 0:
- raise make_ex(ret, 'error setting mirror mode')
-
- def mirror_peer_add(self, ioctx, cluster_name, client_name):
- """
- Add mirror peer.
-
- :param ioctx: determines which RADOS pool is used
- :type ioctx: :class:`rados.Ioctx`
- :param cluster_name: mirror peer cluster name
- :type cluster_name: str
- :param client_name: mirror peer client name
- :type client_name: str
- :returns: str - peer uuid
- """
- cluster_name = cstr(cluster_name, 'cluster_name')
- client_name = cstr(client_name, 'client_name')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_uuid = NULL
- size_t _uuid_max_length = 512
- char *_cluster_name = cluster_name
- char *_client_name = client_name
- try:
- _uuid = <char *>realloc_chk(_uuid, _uuid_max_length)
- ret = rbd_mirror_peer_add(_ioctx, _uuid, _uuid_max_length,
- _cluster_name, _client_name)
- if ret != 0:
- raise make_ex(ret, 'error adding mirror peer')
- return decode_cstr(_uuid)
- finally:
- free(_uuid)
-
- def mirror_peer_remove(self, ioctx, uuid):
- """
- Remove mirror peer.
-
- :param ioctx: determines which RADOS pool is used
- :type ioctx: :class:`rados.Ioctx`
- :param uuid: peer uuid
- :type uuid: str
- """
- uuid = cstr(uuid, 'uuid')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_uuid = uuid
- with nogil:
- ret = rbd_mirror_peer_remove(_ioctx, _uuid)
- if ret != 0:
- raise make_ex(ret, 'error removing mirror peer')
-
- def mirror_peer_list(self, ioctx):
- """
- Iterate over the peers of a pool.
-
- :param ioctx: determines which RADOS pool is read
- :type ioctx: :class:`rados.Ioctx`
- :returns: :class:`MirrorPeerIterator`
- """
- return MirrorPeerIterator(ioctx)
-
- def mirror_peer_set_client(self, ioctx, uuid, client_name):
- """
- Set mirror peer client name
-
- :param ioctx: determines which RADOS pool is written
- :type ioctx: :class:`rados.Ioctx`
- :param uuid: uuid of the mirror peer
- :type uuid: str
- :param client_name: client name of the mirror peer to set
- :type client_name: str
- """
- uuid = cstr(uuid, 'uuid')
- client_name = cstr(client_name, 'client_name')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_uuid = uuid
- char *_client_name = client_name
- with nogil:
- ret = rbd_mirror_peer_set_client(_ioctx, _uuid, _client_name)
- if ret != 0:
- raise make_ex(ret, 'error setting mirror peer client')
-
- def mirror_peer_set_cluster(self, ioctx, uuid, cluster_name):
- """
- Set mirror peer cluster name
-
- :param ioctx: determines which RADOS pool is written
- :type ioctx: :class:`rados.Ioctx`
- :param uuid: uuid of the mirror peer
- :type uuid: str
- :param cluster_name: cluster name of the mirror peer to set
- :type cluster_name: str
- """
- uuid = cstr(uuid, 'uuid')
- cluster_name = cstr(cluster_name, 'cluster_name')
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_uuid = uuid
- char *_cluster_name = cluster_name
- with nogil:
- ret = rbd_mirror_peer_set_cluster(_ioctx, _uuid, _cluster_name)
- if ret != 0:
- raise make_ex(ret, 'error setting mirror peer cluster')
-
- def mirror_image_status_list(self, ioctx):
- """
- Iterate over the mirror image statuses of a pool.
-
- :param ioctx: determines which RADOS pool is read
- :type ioctx: :class:`rados.Ioctx`
- :returns: :class:`MirrorImageStatus`
- """
- return MirrorImageStatusIterator(ioctx)
-
- def mirror_image_status_summary(self, ioctx):
- """
- Get mirror image status summary of a pool.
-
- :param ioctx: determines which RADOS pool is read
- :type ioctx: :class:`rados.Ioctx`
- :returns: list - a list of (state, count) tuples
- """
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- rbd_mirror_image_status_state_t *states = NULL
- int *counts = NULL
- size_t maxlen = 32
- try:
- states = <rbd_mirror_image_status_state_t *>realloc_chk(states,
- sizeof(rbd_mirror_image_status_state_t) * maxlen)
- counts = <int *>realloc_chk(counts, sizeof(int) * maxlen)
- with nogil:
- ret = rbd_mirror_image_status_summary(_ioctx, states, counts,
- &maxlen)
- if ret < 0:
- raise make_ex(ret, 'error getting mirror image status summary')
- return [(states[i], counts[i]) for i in range(maxlen)]
- finally:
- free(states)
- free(counts)
-
-cdef class MirrorPeerIterator(object):
- """
- Iterator over mirror peer info for a pool.
-
- Yields a dictionary containing information about a peer.
-
- Keys are:
-
- * ``uuid`` (str) - uuid of the peer
-
- * ``cluster_name`` (str) - cluster name of the peer
-
- * ``client_name`` (str) - client name of the peer
- """
-
- cdef:
- rbd_mirror_peer_t *peers
- int num_peers
-
- def __init__(self, ioctx):
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- self.peers = NULL
- self.num_peers = 10
- while True:
- self.peers = <rbd_mirror_peer_t *>realloc_chk(
- self.peers, self.num_peers * sizeof(rbd_mirror_peer_t))
- with nogil:
- ret = rbd_mirror_peer_list(_ioctx, self.peers, &self.num_peers)
- if ret < 0:
- if ret == -errno.ERANGE:
- continue
- self.num_peers = 0
- raise make_ex(ret, 'error listing peers')
- break
-
- def __iter__(self):
- for i in range(self.num_peers):
- yield {
- 'uuid' : decode_cstr(self.peers[i].uuid),
- 'cluster_name' : decode_cstr(self.peers[i].cluster_name),
- 'client_name' : decode_cstr(self.peers[i].client_name),
- }
-
- def __dealloc__(self):
- if self.peers:
- rbd_mirror_peer_list_cleanup(self.peers, self.num_peers)
- free(self.peers)
-
-cdef class MirrorImageStatusIterator(object):
- """
- Iterator over mirror image status for a pool.
-
- Yields a dictionary containing mirror status of an image.
-
- Keys are:
-
- * ``name`` (str) - mirror image name
-
- * `info` (dict) - mirror image info
-
- * `state` (int) - mirror state
-
- * `description` (str) - status description
-
- * `last_update` (datetime) - last status update time
-
- * ``up`` (bool) - is mirroring agent up
- """
-
- cdef:
- rados_ioctx_t ioctx
- size_t max_read
- char *last_read
- char **image_ids
- rbd_mirror_image_status_t *images
- size_t size
-
- def __init__(self, ioctx):
- self.ioctx = convert_ioctx(ioctx)
- self.max_read = 1024
- self.last_read = strdup("")
- self.image_ids = <char **>realloc_chk(NULL,
- sizeof(char *) * self.max_read)
- self.images = <rbd_mirror_image_status_t *>realloc_chk(NULL,
- sizeof(rbd_mirror_image_status_t) * self.max_read)
- self.size = 0
- self.get_next_chunk()
-
- def __iter__(self):
- while self.size > 0:
- for i in range(self.size):
- yield {
- 'name' : decode_cstr(self.images[i].name),
- 'info' : {
- 'global_id' : decode_cstr(self.images[i].info.global_id),
- 'state' : self.images[i].info.state,
- },
- 'state' : self.images[i].state,
- 'description' : decode_cstr(self.images[i].description),
- 'last_update' : datetime.fromtimestamp(self.images[i].last_update),
- 'up' : self.images[i].up,
- }
- if self.size < self.max_read:
- break
- self.get_next_chunk()
-
- def __dealloc__(self):
- rbd_mirror_image_status_list_cleanup(self.image_ids, self.images,
- self.size)
- if self.last_read:
- free(self.last_read)
- if self.image_ids:
- free(self.image_ids)
- if self.images:
- free(self.images)
-
- def get_next_chunk(self):
- if self.size > 0:
- rbd_mirror_image_status_list_cleanup(self.image_ids, self.images,
- self.size)
- self.size = 0
- with nogil:
- ret = rbd_mirror_image_status_list(self.ioctx, self.last_read,
- self.max_read, self.image_ids,
- self.images, &self.size)
- if ret < 0:
- raise make_ex(ret, 'error listing mirror images status')
- if self.size > 0:
- free(self.last_read)
- last_read = decode_cstr(self.image_ids[self.size - 1])
- self.last_read = strdup(last_read)
- else:
- free(self.last_read)
- self.last_read = strdup("")
-
-cdef int diff_iterate_cb(uint64_t offset, size_t length, int write, void *cb) \
- except? -9000 with gil:
- # Make sure that if we wound up with an exception from a previous callback,
- # we stop calling back (just in case librbd ever fails to bail out on the
- # first negative return, as older versions did)
- if exc.PyErr_Occurred():
- return -9000
- ret = (<object>cb)(offset, length, bool(write))
- if ret is None:
- return 0
- return ret
-
-
-cdef class Image(object):
- """
- This class represents an RBD image. It is used to perform I/O on
- the image and interact with snapshots.
-
- **Note**: Any method of this class may raise :class:`ImageNotFound`
- if the image has been deleted.
- """
- cdef rbd_image_t image
- cdef bint closed
- cdef object name
- cdef object ioctx
- cdef rados_ioctx_t _ioctx
-
- def __init__(self, ioctx, name, snapshot=None, read_only=False):
- """
- Open the image at the given snapshot.
- If a snapshot is specified, the image will be read-only, unless
- :func:`Image.set_snap` is called later.
-
- If read-only mode is used, metadata for the :class:`Image`
- object (such as which snapshots exist) may become obsolete. See
- the C api for more details.
-
- To clean up from opening the image, :func:`Image.close` should
- be called. For ease of use, this is done automatically when
- an :class:`Image` is used as a context manager (see :pep:`343`).
-
- :param ioctx: determines which RADOS pool the image is in
- :type ioctx: :class:`rados.Ioctx`
- :param name: the name of the image
- :type name: str
- :param snapshot: which snapshot to read from
- :type snaphshot: str
- :param read_only: whether to open the image in read-only mode
- :type read_only: bool
- """
- name = cstr(name, 'name')
- snapshot = cstr(snapshot, 'snapshot', opt=True)
- self.closed = True
- self.name = name
- # Keep around a reference to the ioctx, so it won't get deleted
- self.ioctx = ioctx
- cdef:
- rados_ioctx_t _ioctx = convert_ioctx(ioctx)
- char *_name = name
- char *_snapshot = opt_str(snapshot)
- if read_only:
- with nogil:
- ret = rbd_open_read_only(_ioctx, _name, &self.image, _snapshot)
- else:
- with nogil:
- ret = rbd_open(_ioctx, _name, &self.image, _snapshot)
- if ret != 0:
- raise make_ex(ret, 'error opening image %s at snapshot %s' % (name, snapshot))
- self.closed = False
-
- def __enter__(self):
- return self
-
- def __exit__(self, type_, value, traceback):
- """
- Closes the image. See :func:`close`
- """
- self.close()
- return False
-
- def __get_completion(self, oncomplete):
- """
- Constructs a completion to use with asynchronous operations
-
- :param oncomplete: callback for the completion
-
- :raises: :class:`Error`
- :returns: completion object
- """
-
- completion_obj = Completion(self, oncomplete)
-
- cdef:
- rbd_completion_t completion
- PyObject* p_completion_obj= <PyObject*>completion_obj
-
- with nogil:
- ret = rbd_aio_create_completion(p_completion_obj, __aio_complete_cb,
- &completion)
- if ret < 0:
- raise make_ex(ret, "error getting a completion")
-
- completion_obj.rbd_comp = completion
- return completion_obj
-
- def close(self):
- """
- Release the resources used by this image object.
-
- After this is called, this object should not be used.
- """
- if not self.closed:
- self.closed = True
- with nogil:
- ret = rbd_close(self.image)
- if ret < 0:
- raise make_ex(ret, 'error while closing image %s' % (
- self.name,))
-
- def __dealloc__(self):
- self.close()
-
- def __repr__(self):
- return "rbd.Image(ioctx, %r)" % self.name
-
- def resize(self, size):
- """
- Change the size of the image.
-
- :param size: the new size of the image
- :type size: int
- """
- cdef uint64_t _size = size
- with nogil:
- ret = rbd_resize(self.image, _size)
- if ret < 0:
- raise make_ex(ret, 'error resizing image %s' % (self.name,))
-
- def stat(self):
- """
- Get information about the image. Currently parent pool and
- parent name are always -1 and ''.
-
- :returns: dict - contains the following keys:
-
- * ``size`` (int) - the size of the image in bytes
-
- * ``obj_size`` (int) - the size of each object that comprises the
- image
-
- * ``num_objs`` (int) - the number of objects in the image
-
- * ``order`` (int) - log_2(object_size)
-
- * ``block_name_prefix`` (str) - the prefix of the RADOS objects used
- to store the image
-
- * ``parent_pool`` (int) - deprecated
-
- * ``parent_name`` (str) - deprecated
-
- See also :meth:`format` and :meth:`features`.
-
- """
- cdef rbd_image_info_t info
- with nogil:
- ret = rbd_stat(self.image, &info, sizeof(info))
- if ret != 0:
- raise make_ex(ret, 'error getting info for image %s' % (self.name,))
- return {
- 'size' : info.size,
- 'obj_size' : info.obj_size,
- 'num_objs' : info.num_objs,
- 'order' : info.order,
- 'block_name_prefix' : decode_cstr(info.block_name_prefix),
- 'parent_pool' : info.parent_pool,
- 'parent_name' : info.parent_name
- }
-
- def id(self):
- """
- Get the RBD v2 internal image id
-
- :returns: str - image id
- """
- cdef:
- int ret = -errno.ERANGE
- size_t size = 32
- char *image_id = NULL
- try:
- while ret == -errno.ERANGE and size <= 4096:
- image_id = <char *>realloc_chk(image_id, size)
- with nogil:
- ret = rbd_get_id(self.image, image_id, size)
- if ret == -errno.ERANGE:
- size *= 2
-
- if ret != 0:
- raise make_ex(ret, 'error getting id for image %s' % (self.name,))
- return decode_cstr(image_id)
- finally:
- free(image_id)
-
- def block_name_prefix(self):
- """
- Get the RBD block name prefix
-
- :returns: str - block name prefix
- """
- cdef:
- int ret = -errno.ERANGE
- size_t size = 32
- char *prefix = NULL
- try:
- while ret == -errno.ERANGE and size <= 4096:
- prefix = <char *>realloc_chk(prefix, size)
- with nogil:
- ret = rbd_get_block_name_prefix(self.image, prefix, size)
- if ret == -errno.ERANGE:
- size *= 2
-
- if ret != 0:
- raise make_ex(ret, 'error getting block name prefix for image %s' % (self.name,))
- return decode_cstr(prefix)
- finally:
- free(prefix)
-
- def parent_info(self):
- """
- Get information about a cloned image's parent (if any)
-
- :returns: tuple - ``(pool name, image name, snapshot name)`` components
- of the parent image
- :raises: :class:`ImageNotFound` if the image doesn't have a parent
- """
- cdef:
- int ret = -errno.ERANGE
- size_t size = 8
- char *pool = NULL
- char *name = NULL
- char *snapname = NULL
- try:
- while ret == -errno.ERANGE and size <= 4096:
- pool = <char *>realloc_chk(pool, size)
- name = <char *>realloc_chk(name, size)
- snapname = <char *>realloc_chk(snapname, size)
- with nogil:
- ret = rbd_get_parent_info2(self.image, pool, size, name,
- size, NULL, 0, snapname, size)
- if ret == -errno.ERANGE:
- size *= 2
-
- if ret != 0:
- raise make_ex(ret, 'error getting parent info for image %s' % (self.name,))
- return (decode_cstr(pool), decode_cstr(name), decode_cstr(snapname))
- finally:
- free(pool)
- free(name)
- free(snapname)
-
- def parent_id(self):
- """
- Get image id of a cloned image's parent (if any)
-
- :returns: str - the parent id
- :raises: :class:`ImageNotFound` if the image doesn't have a parent
- """
- cdef:
- int ret = -errno.ERANGE
- size_t size = 32
- char *parent_id = NULL
- try:
- while ret == -errno.ERANGE and size <= 4096:
- parent_id = <char *>realloc_chk(parent_id, size)
- with nogil:
- ret = rbd_get_parent_info2(self.image, NULL, 0, NULL, 0,
- parent_id, size, NULL, 0)
- if ret == -errno.ERANGE:
- size *= 2
-
- if ret != 0:
- raise make_ex(ret, 'error getting parent id for image %s' % (self.name,))
- return decode_cstr(parent_id)
- finally:
- free(parent_id)
-
- def old_format(self):
- """
- Find out whether the image uses the old RBD format.
-
- :returns: bool - whether the image uses the old RBD format
- """
- cdef uint8_t old
- with nogil:
- ret = rbd_get_old_format(self.image, &old)
- if ret != 0:
- raise make_ex(ret, 'error getting old_format for image %s' % (self.name))
- return old != 0
-
- def size(self):
- """
- Get the size of the image. If open to a snapshot, returns the
- size of that snapshot.
-
- :returns: the size of the image in bytes
- """
- cdef uint64_t image_size
- with nogil:
- ret = rbd_get_size(self.image, &image_size)
- if ret != 0:
- raise make_ex(ret, 'error getting size for image %s' % (self.name))
- return image_size
-
- def features(self):
- """
- Get the features bitmask of the image.
-
- :returns: int - the features bitmask of the image
- """
- cdef uint64_t features
- with nogil:
- ret = rbd_get_features(self.image, &features)
- if ret != 0:
- raise make_ex(ret, 'error getting features for image %s' % (self.name))
- return features
-
- def update_features(self, features, enabled):
- """
- Update the features bitmask of the image by enabling/disabling
- a single feature. The feature must support the ability to be
- dynamically enabled/disabled.
-
- :param features: feature bitmask to enable/disable
- :type features: int
- :param enabled: whether to enable/disable the feature
- :type enabled: bool
- :raises: :class:`InvalidArgument`
- """
- cdef:
- uint64_t _features = features
- uint8_t _enabled = bool(enabled)
- with nogil:
- ret = rbd_update_features(self.image, _features, _enabled)
- if ret != 0:
- raise make_ex(ret, 'error updating features for image %s' %
- (self.name))
-
- def overlap(self):
- """
- Get the number of overlapping bytes between the image and its parent
- image. If open to a snapshot, returns the overlap between the snapshot
- and the parent image.
-
- :returns: int - the overlap in bytes
- :raises: :class:`ImageNotFound` if the image doesn't have a parent
- """
- cdef uint64_t overlap
- with nogil:
- ret = rbd_get_overlap(self.image, &overlap)
- if ret != 0:
- raise make_ex(ret, 'error getting overlap for image %s' % (self.name))
- return overlap
-
- def flags(self):
- """
- Get the flags bitmask of the image.
-
- :returns: int - the flags bitmask of the image
- """
- cdef uint64_t flags
- with nogil:
- ret = rbd_get_flags(self.image, &flags)
- if ret != 0:
- raise make_ex(ret, 'error getting flags for image %s' % (self.name))
- return flags
-
- def is_exclusive_lock_owner(self):
- """
- Get the status of the image exclusive lock.
-
- :returns: bool - true if the image is exclusively locked
- """
- cdef int owner
- with nogil:
- ret = rbd_is_exclusive_lock_owner(self.image, &owner)
- if ret != 0:
- raise make_ex(ret, 'error getting lock status for image %s' % (self.name))
- return owner == 1
-
- def copy(self, dest_ioctx, dest_name, features=None, order=None,
- stripe_unit=None, stripe_count=None, data_pool=None):
- """
- Copy the image to another location.
-
- :param dest_ioctx: determines which pool to copy into
- :type dest_ioctx: :class:`rados.Ioctx`
- :param dest_name: the name of the copy
- :type dest_name: str
- :param features: bitmask of features to enable; if set, must include layering
- :type features: int
- :param order: the image is split into (2**order) byte objects
- :type order: int
- :param stripe_unit: stripe unit in bytes (default None to let librbd decide)
- :type stripe_unit: int
- :param stripe_count: objects to stripe over before looping
- :type stripe_count: int
- :param data_pool: optional separate pool for data blocks
- :type data_pool: str
- :raises: :class:`TypeError`
- :raises: :class:`InvalidArgument`
- :raises: :class:`ImageExists`
- :raises: :class:`FunctionNotSupported`
- :raises: :class:`ArgumentOutOfRange`
- """
- dest_name = cstr(dest_name, 'dest_name')
- cdef:
- rados_ioctx_t _dest_ioctx = convert_ioctx(dest_ioctx)
- char *_dest_name = dest_name
- rbd_image_options_t opts
-
- rbd_image_options_create(&opts)
- try:
- if features is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_FEATURES,
- features)
- if order is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_ORDER,
- order)
- if stripe_unit is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_STRIPE_UNIT,
- stripe_unit)
- if stripe_count is not None:
- rbd_image_options_set_uint64(opts, RBD_IMAGE_OPTION_STRIPE_COUNT,
- stripe_count)
- if data_pool is not None:
- rbd_image_options_set_string(opts, RBD_IMAGE_OPTION_DATA_POOL,
- data_pool)
- with nogil:
- ret = rbd_copy3(self.image, _dest_ioctx, _dest_name, opts)
- finally:
- rbd_image_options_destroy(opts)
- if ret < 0:
- raise make_ex(ret, 'error copying image %s to %s' % (self.name, dest_name))
-
- def list_snaps(self):
- """
- Iterate over the snapshots of an image.
-
- :returns: :class:`SnapIterator`
- """
- return SnapIterator(self)
-
- def create_snap(self, name):
- """
- Create a snapshot of the image.
-
- :param name: the name of the snapshot
- :type name: str
- :raises: :class:`ImageExists`
- """
- name = cstr(name, 'name')
- cdef char *_name = name
- with nogil:
- ret = rbd_snap_create(self.image, _name)
- if ret != 0:
- raise make_ex(ret, 'error creating snapshot %s from %s' % (name, self.name))
-
- def rename_snap(self, srcname, dstname):
- """
- rename a snapshot of the image.
-
- :param srcname: the src name of the snapshot
- :type srcname: str
- :param dstname: the dst name of the snapshot
- :type dstname: str
- :raises: :class:`ImageExists`
- """
- srcname = cstr(srcname, 'srcname')
- dstname = cstr(dstname, 'dstname')
- cdef:
- char *_srcname = srcname
- char *_dstname = dstname
- with nogil:
- ret = rbd_snap_rename(self.image, _srcname, _dstname)
- if ret != 0:
- raise make_ex(ret, 'error renaming snapshot of %s from %s to %s' % (self.name, srcname, dstname))
-
- def remove_snap(self, name):
- """
- Delete a snapshot of the image.
-
- :param name: the name of the snapshot
- :type name: str
- :raises: :class:`IOError`, :class:`ImageBusy`
- """
- name = cstr(name, 'name')
- cdef char *_name = name
- with nogil:
- ret = rbd_snap_remove(self.image, _name)
- if ret != 0:
- raise make_ex(ret, 'error removing snapshot %s from %s' % (name, self.name))
-
- def remove_snap2(self, name, flags):
- """
- Delete a snapshot of the image.
-
- :param name: the name of the snapshot
- :param flags: the flags for removal
- :type name: str
- :raises: :class:`IOError`, :class:`ImageBusy`
- """
- name = cstr(name, 'name')
- cdef:
- char *_name = name
- uint32_t _flags = flags
- librbd_progress_fn_t prog_cb = &no_op_progress_callback
- with nogil:
- ret = rbd_snap_remove2(self.image, _name, _flags, prog_cb, NULL)
- if ret != 0:
- raise make_ex(ret, 'error removing snapshot %s from %s with flags %llx' % (name, self.name, flags))
-
- def rollback_to_snap(self, name):
- """
- Revert the image to its contents at a snapshot. This is a
- potentially expensive operation, since it rolls back each
- object individually.
-
- :param name: the snapshot to rollback to
- :type name: str
- :raises: :class:`IOError`
- """
- name = cstr(name, 'name')
- cdef char *_name = name
- with nogil:
- ret = rbd_snap_rollback(self.image, _name)
- if ret != 0:
- raise make_ex(ret, 'error rolling back image %s to snapshot %s' % (self.name, name))
-
- def protect_snap(self, name):
- """
- Mark a snapshot as protected. This means it can't be deleted
- until it is unprotected.
-
- :param name: the snapshot to protect
- :type name: str
- :raises: :class:`IOError`, :class:`ImageNotFound`
- """
- name = cstr(name, 'name')
- cdef char *_name = name
- with nogil:
- ret = rbd_snap_protect(self.image, _name)
- if ret != 0:
- raise make_ex(ret, 'error protecting snapshot %s@%s' % (self.name, name))
-
- def unprotect_snap(self, name):
- """
- Mark a snapshot unprotected. This allows it to be deleted if
- it was protected.
-
- :param name: the snapshot to unprotect
- :type name: str
- :raises: :class:`IOError`, :class:`ImageNotFound`
- """
- name = cstr(name, 'name')
- cdef char *_name = name
- with nogil:
- ret = rbd_snap_unprotect(self.image, _name)
- if ret != 0:
- raise make_ex(ret, 'error unprotecting snapshot %s@%s' % (self.name, name))
-
- def is_protected_snap(self, name):
- """
- Find out whether a snapshot is protected from deletion.
-
- :param name: the snapshot to check
- :type name: str
- :returns: bool - whether the snapshot is protected
- :raises: :class:`IOError`, :class:`ImageNotFound`
- """
- name = cstr(name, 'name')
- cdef:
- char *_name = name
- int is_protected
- with nogil:
- ret = rbd_snap_is_protected(self.image, _name, &is_protected)
- if ret != 0:
- raise make_ex(ret, 'error checking if snapshot %s@%s is protected' % (self.name, name))
- return is_protected == 1
-
- def get_snap_limit(self):
- """
- Get the snapshot limit for an image.
- """
-
- cdef:
- uint64_t limit
- with nogil:
- ret = rbd_snap_get_limit(self.image, &limit)
- if ret != 0:
- raise make_ex(ret, 'error getting snapshot limit for %s' % self.name)
- return limit
-
- def set_snap_limit(self, limit):
- """
- Set the snapshot limit for an image.
-
- :param limit: the new limit to set
- """
-
- cdef:
- uint64_t _limit = limit
- with nogil:
- ret = rbd_snap_set_limit(self.image, _limit)
- if ret != 0:
- raise make_ex(ret, 'error setting snapshot limit for %s' % self.name)
- return ret
-
- def get_snap_timestamp(self, snap_id):
- """
- Get the snapshot timestamp for an image.
- :param snap_id: the snapshot id of a snap shot
- """
- cdef:
- timespec timestamp
- uint64_t _snap_id = snap_id
- with nogil:
- ret = rbd_snap_get_timestamp(self.image, _snap_id, ×tamp)
- if ret != 0:
- raise make_ex(ret, 'error getting snapshot timestamp for image: %s, snap_id: %d' % (self.name, snap_id))
- return datetime.fromtimestamp(timestamp.tv_sec)
-
- def remove_snap_limit(self):
- """
- Remove the snapshot limit for an image, essentially setting
- the limit to the maximum size allowed by the implementation.
- """
- with nogil:
- ret = rbd_snap_set_limit(self.image, UINT64_MAX)
- if ret != 0:
- raise make_ex(ret, 'error removing snapshot limit for %s' % self.name)
- return ret
-
- def set_snap(self, name):
- """
- Set the snapshot to read from. Writes will raise ReadOnlyImage
- while a snapshot is set. Pass None to unset the snapshot
- (reads come from the current image) , and allow writing again.
-
- :param name: the snapshot to read from, or None to unset the snapshot
- :type name: str or None
- """
- name = cstr(name, 'name', opt=True)
- cdef char *_name = opt_str(name)
- with nogil:
- ret = rbd_snap_set(self.image, _name)
- if ret != 0:
- raise make_ex(ret, 'error setting image %s to snapshot %s' % (self.name, name))
-
- def read(self, offset, length, fadvise_flags=0):
- """
- Read data from the image. Raises :class:`InvalidArgument` if
- part of the range specified is outside the image.
-
- :param offset: the offset to start reading at
- :type offset: int
- :param length: how many bytes to read
- :type length: int
- :param fadvise_flags: fadvise flags for this read
- :type fadvise_flags: int
- :returns: str - the data read
- :raises: :class:`InvalidArgument`, :class:`IOError`
- """
-
- # This usage of the Python API allows us to construct a string
- # that librbd directly reads into, avoiding an extra copy. Although
- # strings are normally immutable, this usage is explicitly supported
- # for freshly created string objects.
- cdef:
- char *ret_buf
- uint64_t _offset = offset
- size_t _length = length
- int _fadvise_flags = fadvise_flags
- PyObject* ret_s = NULL
- ret_s = PyBytes_FromStringAndSize(NULL, length)
- try:
- ret_buf = PyBytes_AsString(ret_s)
- with nogil:
- ret = rbd_read2(self.image, _offset, _length, ret_buf,
- _fadvise_flags)
- if ret < 0:
- raise make_ex(ret, 'error reading %s %ld~%ld' % (self.name, offset, length))
-
- if ret != <ssize_t>length:
- _PyBytes_Resize(&ret_s, ret)
-
- return <object>ret_s
- finally:
- # We DECREF unconditionally: the cast to object above will have
- # INCREFed if necessary. This also takes care of exceptions,
- # including if _PyString_Resize fails (that will free the string
- # itself and set ret_s to NULL, hence XDECREF).
- ref.Py_XDECREF(ret_s)
-
- def diff_iterate(self, offset, length, from_snapshot, iterate_cb,
- include_parent = True, whole_object = False):
- """
- Iterate over the changed extents of an image.
-
- This will call iterate_cb with three arguments:
-
- (offset, length, exists)
-
- where the changed extent starts at offset bytes, continues for
- length bytes, and is full of data (if exists is True) or zeroes
- (if exists is False).
-
- If from_snapshot is None, it is interpreted as the beginning
- of time and this generates all allocated extents.
-
- The end version is whatever is currently selected (via set_snap)
- for the image.
-
- iterate_cb may raise an exception, which will abort the diff and will be
- propagated to the caller.
-
- Raises :class:`InvalidArgument` if from_snapshot is after
- the currently set snapshot.
-
- Raises :class:`ImageNotFound` if from_snapshot is not the name
- of a snapshot of the image.
-
- :param offset: start offset in bytes
- :type offset: int
- :param length: size of region to report on, in bytes
- :type length: int
- :param from_snapshot: starting snapshot name, or None
- :type from_snapshot: str or None
- :param iterate_cb: function to call for each extent
- :type iterate_cb: function acception arguments for offset,
- length, and exists
- :param include_parent: True if full history diff should include parent
- :type include_parent: bool
- :param whole_object: True if diff extents should cover whole object
- :type whole_object: bool
- :raises: :class:`InvalidArgument`, :class:`IOError`,
- :class:`ImageNotFound`
- """
- from_snapshot = cstr(from_snapshot, 'from_snapshot', opt=True)
- cdef:
- char *_from_snapshot = opt_str(from_snapshot)
- uint64_t _offset = offset, _length = length
- uint8_t _include_parent = include_parent
- uint8_t _whole_object = whole_object
- with nogil:
- ret = rbd_diff_iterate2(self.image, _from_snapshot, _offset,
- _length, _include_parent, _whole_object,
- &diff_iterate_cb, <void *>iterate_cb)
- if ret < 0:
- msg = 'error generating diff from snapshot %s' % from_snapshot
- raise make_ex(ret, msg)
-
- def write(self, data, offset, fadvise_flags=0):
- """
- Write data to the image. Raises :class:`InvalidArgument` if
- part of the write would fall outside the image.
-
- :param data: the data to be written
- :type data: bytes
- :param offset: where to start writing data
- :type offset: int
- :param fadvise_flags: fadvise flags for this write
- :type fadvise_flags: int
- :returns: int - the number of bytes written
- :raises: :class:`IncompleteWriteError`, :class:`LogicError`,
- :class:`InvalidArgument`, :class:`IOError`
- """
- if not isinstance(data, bytes):
- raise TypeError('data must be a byte string')
- cdef:
- uint64_t _offset = offset, length = len(data)
- char *_data = data
- int _fadvise_flags = fadvise_flags
- with nogil:
- ret = rbd_write2(self.image, _offset, length, _data, _fadvise_flags)
-
- if ret == <ssize_t>length:
- return ret
- elif ret < 0:
- raise make_ex(ret, "error writing to %s" % (self.name,))
- elif ret < <ssize_t>length:
- raise IncompleteWriteError("Wrote only %ld out of %ld bytes" % (ret, length))
- else:
- raise LogicError("logic error: rbd_write(%s) \
-returned %d, but %d was the maximum number of bytes it could have \
-written." % (self.name, ret, length))
-
- def discard(self, offset, length):
- """
- Trim the range from the image. It will be logically filled
- with zeroes.
- """
- cdef uint64_t _offset = offset, _length = length
- with nogil:
- ret = rbd_discard(self.image, _offset, _length)
- if ret < 0:
- msg = 'error discarding region %d~%d' % (offset, length)
- raise make_ex(ret, msg)
-
- def flush(self):
- """
- Block until all writes are fully flushed if caching is enabled.
- """
- with nogil:
- ret = rbd_flush(self.image)
- if ret < 0:
- raise make_ex(ret, 'error flushing image')
-
- def invalidate_cache(self):
- """
- Drop any cached data for the image.
- """
- with nogil:
- ret = rbd_invalidate_cache(self.image)
- if ret < 0:
- raise make_ex(ret, 'error invalidating cache')
-
- def stripe_unit(self):
- """
- Return the stripe unit used for the image.
- """
- cdef uint64_t stripe_unit
- with nogil:
- ret = rbd_get_stripe_unit(self.image, &stripe_unit)
- if ret != 0:
- raise make_ex(ret, 'error getting stripe unit for image %s' % (self.name))
- return stripe_unit
-
- def stripe_count(self):
- """
- Return the stripe count used for the image.
- """
- cdef uint64_t stripe_count
- with nogil:
- ret = rbd_get_stripe_count(self.image, &stripe_count)
- if ret != 0:
- raise make_ex(ret, 'error getting stripe count for image %s' % (self.name))
- return stripe_count
-
- def create_timestamp(self):
- """
- Return the create timestamp for the image.
- """
- cdef:
- timespec timestamp
- with nogil:
- ret = rbd_get_create_timestamp(self.image, ×tamp)
- if ret != 0:
- raise make_ex(ret, 'error getting create timestamp for image: %s' % (self.name))
- return datetime.fromtimestamp(timestamp.tv_sec)
-
- def flatten(self):
- """
- Flatten clone image (copy all blocks from parent to child)
- """
- with nogil:
- ret = rbd_flatten(self.image)
- if ret < 0:
- raise make_ex(ret, "error flattening %s" % self.name)
-
- def rebuild_object_map(self):
- """
- Rebuild the object map for the image HEAD or currently set snapshot
- """
- cdef librbd_progress_fn_t prog_cb = &no_op_progress_callback
- with nogil:
- ret = rbd_rebuild_object_map(self.image, prog_cb, NULL)
- if ret < 0:
- raise make_ex(ret, "error rebuilding object map %s" % self.name)
-
- def list_children(self):
- """
- List children of the currently set snapshot (set via set_snap()).
-
- :returns: list - a list of (pool name, image name) tuples
- """
- cdef:
- size_t pools_size = 512, images_size = 512
- char *c_pools = NULL
- char *c_images = NULL
- try:
- while True:
- c_pools = <char *>realloc_chk(c_pools, pools_size)
- c_images = <char *>realloc_chk(c_images, images_size)
- with nogil:
- ret = rbd_list_children(self.image, c_pools, &pools_size,
- c_images, &images_size)
- if ret >= 0:
- break
- elif ret != -errno.ERANGE:
- raise make_ex(ret, 'error listing images')
- if ret == 0:
- return []
- pools = map(decode_cstr, c_pools[:pools_size - 1].split(b'\0'))
- images = map(decode_cstr, c_images[:images_size - 1].split(b'\0'))
- return list(zip(pools, images))
- finally:
- free(c_pools)
- free(c_images)
-
- def list_lockers(self):
- """
- List clients that have locked the image and information
- about the lock.
-
- :returns: dict - contains the following keys:
-
- * ``tag`` - the tag associated with the lock (every
- additional locker must use the same tag)
- * ``exclusive`` - boolean indicating whether the
- lock is exclusive or shared
- * ``lockers`` - a list of (client, cookie, address)
- tuples
- """
- cdef:
- size_t clients_size = 512, cookies_size = 512
- size_t addrs_size = 512, tag_size = 512
- int exclusive = 0
- char *c_clients = NULL
- char *c_cookies = NULL
- char *c_addrs = NULL
- char *c_tag = NULL
-
- try:
- while True:
- c_clients = <char *>realloc_chk(c_clients, clients_size)
- c_cookies = <char *>realloc_chk(c_cookies, cookies_size)
- c_addrs = <char *>realloc_chk(c_addrs, addrs_size)
- c_tag = <char *>realloc_chk(c_tag, tag_size)
- with nogil:
- ret = rbd_list_lockers(self.image, &exclusive,
- c_tag, &tag_size,
- c_clients, &clients_size,
- c_cookies, &cookies_size,
- c_addrs, &addrs_size)
- if ret >= 0:
- break
- elif ret != -errno.ERANGE:
- raise make_ex(ret, 'error listing images')
- if ret == 0:
- return []
- clients = map(decode_cstr, c_clients[:clients_size - 1].split(b'\0'))
- cookies = map(decode_cstr, c_cookies[:cookies_size - 1].split(b'\0'))
- addrs = map(decode_cstr, c_addrs[:addrs_size - 1].split(b'\0'))
- return {
- 'tag' : decode_cstr(c_tag),
- 'exclusive' : exclusive == 1,
- 'lockers' : list(zip(clients, cookies, addrs)),
- }
- finally:
- free(c_clients)
- free(c_cookies)
- free(c_addrs)
- free(c_tag)
-
- def lock_acquire(self, lock_mode):
- """
- Acquire a managed lock on the image.
-
- :param lock_mode: lock mode to set
- :type lock_mode: int
- :raises: :class:`ImageBusy` if the lock could not be acquired
- """
- cdef:
- rbd_lock_mode_t _lock_mode = lock_mode
- with nogil:
- ret = rbd_lock_acquire(self.image, _lock_mode)
- if ret < 0:
- raise make_ex(ret, 'error acquiring lock on image')
-
- def lock_release(self):
- """
- Release a managed lock on the image that was previously acquired.
- """
- with nogil:
- ret = rbd_lock_release(self.image)
- if ret < 0:
- raise make_ex(ret, 'error releasing lock on image')
-
- def lock_get_owners(self):
- """
- Iterate over the lock owners of an image.
-
- :returns: :class:`LockOwnerIterator`
- """
- return LockOwnerIterator(self)
-
- def lock_break(self, lock_mode, lock_owner):
- """
- Break the image lock held by a another client.
-
- :param lock_owner: the owner of the lock to break
- :type lock_owner: str
- """
- lock_owner = cstr(lock_owner, 'lock_owner')
- cdef:
- rbd_lock_mode_t _lock_mode = lock_mode
- char *_lock_owner = lock_owner
- with nogil:
- ret = rbd_lock_break(self.image, _lock_mode, _lock_owner)
- if ret < 0:
- raise make_ex(ret, 'error breaking lock on image')
-
- def lock_exclusive(self, cookie):
- """
- Take an exclusive lock on the image.
-
- :raises: :class:`ImageBusy` if a different client or cookie locked it
- :class:`ImageExists` if the same client and cookie locked it
- """
- cookie = cstr(cookie, 'cookie')
- cdef char *_cookie = cookie
- with nogil:
- ret = rbd_lock_exclusive(self.image, _cookie)
- if ret < 0:
- raise make_ex(ret, 'error acquiring exclusive lock on image')
-
- def lock_shared(self, cookie, tag):
- """
- Take a shared lock on the image. The tag must match
- that of the existing lockers, if any.
-
- :raises: :class:`ImageBusy` if a different client or cookie locked it
- :class:`ImageExists` if the same client and cookie locked it
- """
- cookie = cstr(cookie, 'cookie')
- tag = cstr(tag, 'tag')
- cdef:
- char *_cookie = cookie
- char *_tag = tag
- with nogil:
- ret = rbd_lock_shared(self.image, _cookie, _tag)
- if ret < 0:
- raise make_ex(ret, 'error acquiring shared lock on image')
-
- def unlock(self, cookie):
- """
- Release a lock on the image that was locked by this rados client.
- """
- cookie = cstr(cookie, 'cookie')
- cdef char *_cookie = cookie
- with nogil:
- ret = rbd_unlock(self.image, _cookie)
- if ret < 0:
- raise make_ex(ret, 'error unlocking image')
-
- def break_lock(self, client, cookie):
- """
- Release a lock held by another rados client.
- """
- client = cstr(client, 'client')
- cookie = cstr(cookie, 'cookie')
- cdef:
- char *_client = client
- char *_cookie = cookie
- with nogil:
- ret = rbd_break_lock(self.image, _client, _cookie)
- if ret < 0:
- raise make_ex(ret, 'error unlocking image')
-
- def mirror_image_enable(self):
- """
- Enable mirroring for the image.
- """
- with nogil:
- ret = rbd_mirror_image_enable(self.image)
- if ret < 0:
- raise make_ex(ret, 'error enabling mirroring for image %s'
- % (self.name,))
-
- def mirror_image_disable(self, force):
- """
- Disable mirroring for the image.
-
- :param force: force disabling
- :type force: bool
- """
- cdef bint c_force = force
- with nogil:
- ret = rbd_mirror_image_disable(self.image, c_force)
- if ret < 0:
- raise make_ex(ret, 'error disabling mirroring for image %s' %
- (self.name,))
-
- def mirror_image_promote(self, force):
- """
- Promote the image to primary for mirroring.
-
- :param force: force promoting
- :type force: bool
- """
- cdef bint c_force = force
- with nogil:
- ret = rbd_mirror_image_promote(self.image, c_force)
- if ret < 0:
- raise make_ex(ret, 'error promoting image %s to primary' %
- (self.name,))
-
- def mirror_image_demote(self):
- """
- Demote the image to secondary for mirroring.
- """
- with nogil:
- ret = rbd_mirror_image_demote(self.image)
- if ret < 0:
- raise make_ex(ret, 'error demoting image %s to secondary' %
- (self.name,))
-
- def mirror_image_resync(self):
- """
- Flag the image to resync.
- """
- with nogil:
- ret = rbd_mirror_image_resync(self.image)
- if ret < 0:
- raise make_ex(ret, 'error to resync image %s' % (self.name,))
-
- def mirror_image_get_info(self):
- """
- Get mirror info for the image.
-
- :returns: dict - contains the following keys:
-
- * ``global_id`` (str) - image global id
-
- * ``state`` (int) - mirror state
-
- * ``primary`` (bool) - is image primary
- """
- cdef rbd_mirror_image_info_t c_info
- with nogil:
- ret = rbd_mirror_image_get_info(self.image, &c_info, sizeof(c_info))
- if ret != 0:
- raise make_ex(ret, 'error getting mirror info for image %s' %
- (self.name,))
- info = {
- 'global_id' : decode_cstr(c_info.global_id),
- 'state' : int(c_info.state),
- 'primary' : c_info.primary,
- }
- free(c_info.global_id)
- return info
-
- def mirror_image_get_status(self):
- """
- Get mirror status for the image.
-
- :returns: dict - contains the following keys:
-
- * ``name`` (str) - mirror image name
-
- * `info` (dict) - mirror image info
-
- * ``state`` (int) - status mirror state
-
- * ``description`` (str) - status description
-
- * ``last_update`` (datetime) - last status update time
-
- * ``up`` (bool) - is mirroring agent up
- """
- cdef rbd_mirror_image_status_t c_status
- with nogil:
- ret = rbd_mirror_image_get_status(self.image, &c_status,
- sizeof(c_status))
- if ret != 0:
- raise make_ex(ret, 'error getting mirror status for image %s' %
- (self.name,))
- status = {
- 'name' : decode_cstr(c_status.name),
- 'info' : {
- 'global_id' : decode_cstr(c_status.info.global_id),
- 'state' : int(c_status.info.state),
- 'primary' : c_status.info.primary,
- },
- 'state' : c_status.state,
- 'description' : decode_cstr(c_status.description),
- 'last_update' : datetime.fromtimestamp(c_status.last_update),
- 'up' : c_status.up,
- }
- free(c_status.name)
- free(c_status.info.global_id)
- free(c_status.description)
- return status
-
- def aio_read(self, offset, length, oncomplete, fadvise_flags=0):
- """
- Asynchronously read data from the image
-
- Raises :class:`InvalidArgument` if part of the range specified is
- outside the image.
-
- oncomplete will be called with the returned read value as
- well as the completion:
-
- oncomplete(completion, data_read)
-
- :param offset: the offset to start reading at
- :type offset: int
- :param length: how many bytes to read
- :type length: int
- :param oncomplete: what to do when the read is complete
- :type oncomplete: completion
- :param fadvise_flags: fadvise flags for this read
- :type fadvise_flags: int
- :returns: :class:`Completion` - the completion object
- :raises: :class:`InvalidArgument`, :class:`IOError`
- """
-
- cdef:
- char *ret_buf
- uint64_t _offset = offset
- size_t _length = length
- int _fadvise_flags = fadvise_flags
- Completion completion
-
- def oncomplete_(completion_v):
- cdef Completion _completion_v = completion_v
- return_value = _completion_v.get_return_value()
- if return_value > 0 and return_value != length:
- _PyBytes_Resize(&_completion_v.buf, return_value)
- return oncomplete(_completion_v, <object>_completion_v.buf if return_value >= 0 else None)
-
- completion = self.__get_completion(oncomplete_)
- completion.buf = PyBytes_FromStringAndSize(NULL, length)
- ret_buf = PyBytes_AsString(completion.buf)
- try:
- completion.__persist()
- with nogil:
- ret = rbd_aio_read2(self.image, _offset, _length, ret_buf,
- completion.rbd_comp, _fadvise_flags)
- if ret < 0:
- raise make_ex(ret, 'error reading %s %ld~%ld' %
- (self.name, offset, length))
- except:
- completion.__unpersist()
- raise
-
- return completion
-
- def aio_write(self, data, offset, oncomplete, fadvise_flags=0):
- """
- Asynchronously write data to the image
-
- Raises :class:`InvalidArgument` if part of the write would fall outside
- the image.
-
- oncomplete will be called with the completion:
-
- oncomplete(completion)
-
- :param data: the data to be written
- :type data: bytes
- :param offset: the offset to start writing at
- :type offset: int
- :param oncomplete: what to do when the write is complete
- :type oncomplete: completion
- :param fadvise_flags: fadvise flags for this write
- :type fadvise_flags: int
- :returns: :class:`Completion` - the completion object
- :raises: :class:`InvalidArgument`, :class:`IOError`
- """
-
- cdef:
- uint64_t _offset = offset
- char *_data = data
- size_t _length = len(data)
- int _fadvise_flags = fadvise_flags
- Completion completion
-
- completion = self.__get_completion(oncomplete)
- try:
- completion.__persist()
- with nogil:
- ret = rbd_aio_write2(self.image, _offset, _length, _data,
- completion.rbd_comp, _fadvise_flags)
- if ret < 0:
- raise make_ex(ret, 'error writing %s %ld~%ld' %
- (self.name, offset, _length))
- except:
- completion.__unpersist()
- raise
-
- return completion
-
- def aio_discard(self, offset, length, oncomplete):
- """
- Asynchronously trim the range from the image. It will be logically
- filled with zeroes.
- """
-
- cdef:
- uint64_t _offset = offset
- size_t _length = length
- Completion completion
-
- completion = self.__get_completion(oncomplete)
- try:
- completion.__persist()
- with nogil:
- ret = rbd_aio_discard(self.image, _offset, _length,
- completion.rbd_comp)
- if ret < 0:
- raise make_ex(ret, 'error discarding %s %ld~%ld' %
- (self.name, offset, _length))
- except:
- completion.__unpersist()
- raise
-
- return completion
-
- def aio_flush(self, oncomplete):
- """
- Asyncronously wait until all writes are fully flushed if caching is
- enabled.
- """
-
- cdef Completion completion = self.__get_completion(oncomplete)
- try:
- completion.__persist()
- with nogil:
- ret = rbd_aio_flush(self.image, completion.rbd_comp)
- if ret < 0:
- raise make_ex(ret, 'error flushing')
- except:
- completion.__unpersist()
- raise
-
- return completion
-
- def metadata_get(self, key):
- """
- Get image metadata for the given key.
-
- :param key: metadata key
- :type key: str
- :returns: str - image id
- """
- key = cstr(key, 'key')
- cdef:
- char *_key = key
- size_t size = 4096
- char *value = NULL
- int ret
- try:
- while True:
- value = <char *>realloc_chk(value, size)
- with nogil:
- ret = rbd_metadata_get(self.image, _key, value, &size)
- if ret != -errno.ERANGE:
- break
- if ret != 0:
- raise make_ex(ret, 'error getting metadata %s for image %s' %
- (self.key, self.name,))
- return decode_cstr(value)
- finally:
- free(value)
-
- def metadata_set(self, key, value):
- """
- Set image metadata for the given key.
-
- :param key: metadata key
- :type key: str
- :param value: metadata value
- :type value: str
- """
- key = cstr(key, 'key')
- value = cstr(value, 'value')
- cdef:
- char *_key = key
- char *_value = value
- with nogil:
- ret = rbd_metadata_set(self.image, _key, _value)
-
- if ret != 0:
- raise make_ex(ret, 'error setting metadata %s for image %s' %
- (self.key, self.name,))
-
-
- def metadata_remove(self, key):
- """
- Remove image metadata for the given key.
-
- :param key: metadata key
- :type key: str
- """
- key = cstr(key, 'key')
- cdef:
- char *_key = key
- with nogil:
- ret = rbd_metadata_remove(self.image, _key)
-
- if ret != 0:
- raise make_ex(ret, 'error removing metadata %s for image %s' %
- (self.key, self.name,))
-
- def metadata_list(self):
- """
- List image metadata.
-
- :returns: :class:`MetadataIterator`
- """
- return MetadataIterator(self)
-
-cdef class LockOwnerIterator(object):
- """
- Iterator over managed lock owners for an image
-
- Yields a dictionary containing information about the image's lock
-
- Keys are:
-
- * ``mode`` (int) - active lock mode
-
- * ``owner`` (str) - lock owner name
- """
-
- cdef:
- rbd_lock_mode_t lock_mode
- char **lock_owners
- size_t num_lock_owners
- object image
-
- def __init__(self, Image image):
- self.image = image
- self.lock_owners = NULL
- self.num_lock_owners = 8
- while True:
- self.lock_owners = <char**>realloc_chk(self.lock_owners,
- self.num_lock_owners *
- sizeof(char*))
- with nogil:
- ret = rbd_lock_get_owners(image.image, &self.lock_mode,
- self.lock_owners,
- &self.num_lock_owners)
- if ret >= 0:
- break
- elif ret != -errno.ERANGE:
- raise make_ex(ret, 'error listing lock owners for image %s' % (image.name,))
-
- def __iter__(self):
- for i in range(self.num_lock_owners):
- yield {
- 'mode' : int(self.lock_mode),
- 'owner' : decode_cstr(self.lock_owners[i]),
- }
-
- def __dealloc__(self):
- if self.lock_owners:
- rbd_lock_get_owners_cleanup(self.lock_owners, self.num_lock_owners)
- free(self.lock_owners)
-
-cdef class MetadataIterator(object):
- """
- Iterator over metadata list for an image.
-
- Yields ``(key, value)`` tuple.
-
- * ``key`` (str) - metadata key
- * ``value`` (str) - metadata value
- """
-
- cdef:
- object image_name
- rbd_image_t image
- char *last_read
- uint64_t max_read
- object next_chunk
-
- def __init__(self, Image image):
- self.image_name = image.name
- self.image = image.image
- self.last_read = strdup("")
- self.max_read = 32
- self.get_next_chunk()
-
- def __iter__(self):
- while len(self.next_chunk) > 0:
- for pair in self.next_chunk:
- yield pair
- if len(self.next_chunk) < self.max_read:
- break
- self.get_next_chunk()
-
- def __dealloc__(self):
- if self.last_read:
- free(self.last_read)
-
- def get_next_chunk(self):
- cdef:
- char *c_keys = NULL
- size_t keys_size = 4096
- char *c_vals = NULL
- size_t vals_size = 4096
- try:
- while True:
- c_keys = <char *>realloc_chk(c_keys, keys_size)
- c_vals = <char *>realloc_chk(c_vals, vals_size)
- with nogil:
- ret = rbd_metadata_list(self.image, self.last_read,
- self.max_read, c_keys, &keys_size,
- c_vals, &vals_size)
- if ret >= 0:
- break
- elif ret != -errno.ERANGE:
- raise make_ex(ret, 'error listing metadata for image %s' %
- (self.image_name,))
- keys = [decode_cstr(key) for key in
- c_keys[:keys_size].split(b'\0') if key]
- vals = [decode_cstr(val) for val in
- c_vals[:vals_size].split(b'\0') if val]
- if len(keys) > 0:
- free(self.last_read)
- self.last_read = strdup(keys[-1])
- self.next_chunk = zip(keys, vals)
- finally:
- free(c_keys)
- free(c_vals)
-
-cdef class SnapIterator(object):
- """
- Iterator over snapshot info for an image.
-
- Yields a dictionary containing information about a snapshot.
-
- Keys are:
-
- * ``id`` (int) - numeric identifier of the snapshot
-
- * ``size`` (int) - size of the image at the time of snapshot (in bytes)
-
- * ``name`` (str) - name of the snapshot
- """
-
- cdef rbd_snap_info_t *snaps
- cdef int num_snaps
- cdef object image
-
- def __init__(self, Image image):
- self.image = image
- self.snaps = NULL
- self.num_snaps = 10
- while True:
- self.snaps = <rbd_snap_info_t*>realloc_chk(self.snaps,
- self.num_snaps *
- sizeof(rbd_snap_info_t))
- with nogil:
- ret = rbd_snap_list(image.image, self.snaps, &self.num_snaps)
- if ret >= 0:
- self.num_snaps = ret
- break
- elif ret != -errno.ERANGE:
- raise make_ex(ret, 'error listing snapshots for image %s' % (image.name,))
-
- def __iter__(self):
- for i in range(self.num_snaps):
- yield {
- 'id' : self.snaps[i].id,
- 'size' : self.snaps[i].size,
- 'name' : decode_cstr(self.snaps[i].name),
- }
-
- def __dealloc__(self):
- if self.snaps:
- rbd_snap_list_end(self.snaps)
- free(self.snaps)
-
-cdef class TrashIterator(object):
- """
- Iterator over trash entries.
-
- Yields a dictionary containing trash info of an image.
-
- Keys are:
-
- * `id` (str) - image id
-
- * `name` (str) - image name
-
- * `source` (str) - source of deletion
-
- * `deletion_time` (datetime) - time of deletion
-
- * `deferment_end_time` (datetime) - time that an image is allowed to be
- removed from trash
- """
-
- cdef:
- rados_ioctx_t ioctx
- size_t num_entries
- rbd_trash_image_info_t *entries
-
- def __init__(self, ioctx):
- self.ioctx = convert_ioctx(ioctx)
- self.num_entries = 1024
- self.entries = NULL
- while True:
- self.entries = <rbd_trash_image_info_t*>realloc_chk(self.entries,
- self.num_entries *
- sizeof(rbd_trash_image_info_t))
- with nogil:
- ret = rbd_trash_list(self.ioctx, self.entries, &self.num_entries)
- if ret >= 0:
- self.num_entries = ret
- break
- elif ret != -errno.ERANGE:
- raise make_ex(ret, 'error listing trash entries')
-
- __source_string = ['USER', 'MIRRORING']
-
- def __iter__(self):
- for i in range(self.num_entries):
- yield {
- 'id' : decode_cstr(self.entries[i].id),
- 'name' : decode_cstr(self.entries[i].name),
- 'source' : TrashIterator.__source_string[self.entries[i].source],
- 'deletion_time' : datetime.fromtimestamp(self.entries[i].deletion_time),
- 'deferment_end_time' : datetime.fromtimestamp(self.entries[i].deferment_end_time)
- }
-
- def __dealloc__(self):
- rbd_trash_list_cleanup(self.entries, self.num_entries)
- if self.entries:
- free(self.entries)
-
Code Review / stor4nfv.git / blobdiff