summaryrefslogtreecommitdiffstats
path: root/src/pybind/rados
diff options
context:
space:
mode:
Diffstat (limited to 'src/pybind/rados')
-rw-r--r--src/pybind/rados/CMakeLists.txt7
-rw-r--r--src/pybind/rados/MANIFEST.in2
-rw-r--r--src/pybind/rados/c_rados.pxd312
-rw-r--r--src/pybind/rados/ctime.pxd11
-rw-r--r--src/pybind/rados/mock_rados.pxi465
-rw-r--r--src/pybind/rados/rados.pxd45
-rw-r--r--src/pybind/rados/rados.pyx4363
-rwxr-xr-xsrc/pybind/rados/setup.py206
8 files changed, 5411 insertions, 0 deletions
diff --git a/src/pybind/rados/CMakeLists.txt b/src/pybind/rados/CMakeLists.txt
new file mode 100644
index 000000000..fe700fb0b
--- /dev/null
+++ b/src/pybind/rados/CMakeLists.txt
@@ -0,0 +1,7 @@
+distutils_add_cython_module(cython_rados
+ rados
+ ${CMAKE_CURRENT_SOURCE_DIR}/rados.pyx
+ DISABLE_VTA)
+add_dependencies(cython_rados rados)
+distutils_install_cython_module(cython_rados
+ DISABLE_VTA)
diff --git a/src/pybind/rados/MANIFEST.in b/src/pybind/rados/MANIFEST.in
new file mode 100644
index 000000000..79f1d9ce8
--- /dev/null
+++ b/src/pybind/rados/MANIFEST.in
@@ -0,0 +1,2 @@
+include rados.pyx
+include rados.pxd
diff --git a/src/pybind/rados/c_rados.pxd b/src/pybind/rados/c_rados.pxd
new file mode 100644
index 000000000..563f3ec6a
--- /dev/null
+++ b/src/pybind/rados/c_rados.pxd
@@ -0,0 +1,312 @@
+# cython: embedsignature=True
+
+from libc.stdint cimport *
+from ctime cimport time_t, timeval
+from rados cimport rados_t, rados_config_t, rados_ioctx_t
+
+cdef extern from "err.h" nogil:
+ cdef int _MAX_ERRNO "MAX_ERRNO"
+
+
+cdef extern from "rados/rados_types.h" nogil:
+ cdef char* _LIBRADOS_ALL_NSPACES "LIBRADOS_ALL_NSPACES"
+ cdef struct notify_ack_t:
+ unsigned long notifier_id
+ unsigned long cookie
+ char *payload
+ unsigned long payload_len
+
+ cdef struct notify_timeout_t:
+ unsigned long notifier_id
+ unsigned long cookie
+
+cdef extern from "rados/librados.h" nogil:
+ enum:
+ _LIBRADOS_OP_FLAG_EXCL "LIBRADOS_OP_FLAG_EXCL"
+ _LIBRADOS_OP_FLAG_FAILOK "LIBRADOS_OP_FLAG_FAILOK"
+ _LIBRADOS_OP_FLAG_FADVISE_RANDOM "LIBRADOS_OP_FLAG_FADVISE_RANDOM"
+ _LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL "LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL"
+ _LIBRADOS_OP_FLAG_FADVISE_WILLNEED "LIBRADOS_OP_FLAG_FADVISE_WILLNEED"
+ _LIBRADOS_OP_FLAG_FADVISE_DONTNEED "LIBRADOS_OP_FLAG_FADVISE_DONTNEED"
+ _LIBRADOS_OP_FLAG_FADVISE_NOCACHE "LIBRADOS_OP_FLAG_FADVISE_NOCACHE"
+
+
+ enum:
+ _LIBRADOS_CMPXATTR_OP_EQ "LIBRADOS_CMPXATTR_OP_EQ"
+ _LIBRADOS_CMPXATTR_OP_NE "LIBRADOS_CMPXATTR_OP_NE"
+ _LIBRADOS_CMPXATTR_OP_GT "LIBRADOS_CMPXATTR_OP_GT"
+ _LIBRADOS_CMPXATTR_OP_GTE "LIBRADOS_CMPXATTR_OP_GTE"
+ _LIBRADOS_CMPXATTR_OP_LT "LIBRADOS_CMPXATTR_OP_LT"
+ _LIBRADOS_CMPXATTR_OP_LTE "LIBRADOS_CMPXATTR_OP_LTE"
+
+ enum:
+ _LIBRADOS_OPERATION_NOFLAG "LIBRADOS_OPERATION_NOFLAG"
+ _LIBRADOS_OPERATION_BALANCE_READS "LIBRADOS_OPERATION_BALANCE_READS"
+ _LIBRADOS_OPERATION_LOCALIZE_READS "LIBRADOS_OPERATION_LOCALIZE_READS"
+ _LIBRADOS_OPERATION_ORDER_READS_WRITES "LIBRADOS_OPERATION_ORDER_READS_WRITES"
+ _LIBRADOS_OPERATION_IGNORE_CACHE "LIBRADOS_OPERATION_IGNORE_CACHE"
+ _LIBRADOS_OPERATION_SKIPRWLOCKS "LIBRADOS_OPERATION_SKIPRWLOCKS"
+ _LIBRADOS_OPERATION_IGNORE_OVERLAY "LIBRADOS_OPERATION_IGNORE_OVERLAY"
+ _LIBRADOS_CREATE_EXCLUSIVE "LIBRADOS_CREATE_EXCLUSIVE"
+ _LIBRADOS_CREATE_IDEMPOTENT "LIBRADOS_CREATE_IDEMPOTENT"
+
+ cdef uint64_t _LIBRADOS_SNAP_HEAD "LIBRADOS_SNAP_HEAD"
+
+ ctypedef void* rados_xattrs_iter_t
+ ctypedef void* rados_omap_iter_t
+ ctypedef void* rados_list_ctx_t
+ ctypedef uint64_t rados_snap_t
+ ctypedef void *rados_write_op_t
+ ctypedef void *rados_read_op_t
+ ctypedef void *rados_completion_t
+ ctypedef void (*rados_callback_t)(rados_completion_t cb, void *arg)
+ ctypedef void (*rados_log_callback_t)(void *arg, const char *line, const char *who,
+ uint64_t sec, uint64_t nsec, uint64_t seq, const char *level, const char *msg)
+ ctypedef void (*rados_log_callback2_t)(void *arg, const char *line, const char *channel, const char *who, const char *name,
+ uint64_t sec, uint64_t nsec, uint64_t seq, const char *level, const char *msg)
+ ctypedef void (*rados_watchcb2_t)(void *arg, int64_t notify_id,
+ uint64_t handle, uint64_t notifier_id,
+ void *data, size_t data_len)
+ ctypedef void (*rados_watcherrcb_t)(void *pre, uint64_t cookie, int err)
+
+
+ cdef struct rados_cluster_stat_t:
+ uint64_t kb
+ uint64_t kb_used
+ uint64_t kb_avail
+ uint64_t num_objects
+
+ cdef struct rados_pool_stat_t:
+ uint64_t num_bytes
+ uint64_t num_kb
+ uint64_t num_objects
+ uint64_t num_object_clones
+ uint64_t num_object_copies
+ uint64_t num_objects_missing_on_primary
+ uint64_t num_objects_unfound
+ uint64_t num_objects_degraded
+ uint64_t num_rd
+ uint64_t num_rd_kb
+ uint64_t num_wr
+ uint64_t num_wr_kb
+
+ void rados_buffer_free(char *buf)
+
+ void rados_version(int *major, int *minor, int *extra)
+ int rados_create2(rados_t *pcluster, const char *const clustername,
+ const char * const name, uint64_t flags)
+ int rados_create_with_context(rados_t *cluster, rados_config_t cct)
+ int rados_connect(rados_t cluster)
+ void rados_shutdown(rados_t cluster)
+ uint64_t rados_get_instance_id(rados_t cluster)
+ int rados_conf_read_file(rados_t cluster, const char *path)
+ int rados_conf_parse_argv_remainder(rados_t cluster, int argc, const char **argv, const char **remargv)
+ int rados_conf_parse_env(rados_t cluster, const char *var)
+ int rados_conf_set(rados_t cluster, char *option, const char *value)
+ int rados_conf_get(rados_t cluster, char *option, char *buf, size_t len)
+
+ rados_t rados_ioctx_get_cluster(rados_ioctx_t io)
+ int rados_ioctx_pool_stat(rados_ioctx_t io, rados_pool_stat_t *stats)
+ int64_t rados_pool_lookup(rados_t cluster, const char *pool_name)
+ int rados_pool_reverse_lookup(rados_t cluster, int64_t id, char *buf, size_t maxlen)
+ int rados_pool_create(rados_t cluster, const char *pool_name)
+ int rados_pool_create_with_crush_rule(rados_t cluster, const char *pool_name, uint8_t crush_rule_num)
+ int rados_pool_create_with_auid(rados_t cluster, const char *pool_name, uint64_t auid)
+ int rados_pool_create_with_all(rados_t cluster, const char *pool_name, uint64_t auid, uint8_t crush_rule_num)
+ int rados_pool_get_base_tier(rados_t cluster, int64_t pool, int64_t *base_tier)
+ int rados_pool_list(rados_t cluster, char *buf, size_t len)
+ int rados_pool_delete(rados_t cluster, const char *pool_name)
+ int rados_inconsistent_pg_list(rados_t cluster, int64_t pool, char *buf, size_t len)
+
+ int rados_cluster_stat(rados_t cluster, rados_cluster_stat_t *result)
+ int rados_cluster_fsid(rados_t cluster, char *buf, size_t len)
+ int rados_blocklist_add(rados_t cluster, char *client_address, uint32_t expire_seconds)
+ int rados_getaddrs(rados_t cluster, char** addrs)
+ int rados_application_enable(rados_ioctx_t io, const char *app_name,
+ int force)
+ void rados_set_pool_full_try(rados_ioctx_t io)
+ void rados_unset_pool_full_try(rados_ioctx_t io)
+ int rados_application_list(rados_ioctx_t io, char *values,
+ size_t *values_len)
+ int rados_application_metadata_get(rados_ioctx_t io, const char *app_name,
+ const char *key, char *value,
+ size_t *value_len)
+ int rados_application_metadata_set(rados_ioctx_t io, const char *app_name,
+ const char *key, const char *value)
+ int rados_application_metadata_remove(rados_ioctx_t io,
+ const char *app_name, const char *key)
+ int rados_application_metadata_list(rados_ioctx_t io,
+ const char *app_name, char *keys,
+ size_t *key_len, char *values,
+ size_t *value_len)
+ int rados_ping_monitor(rados_t cluster, const char *mon_id, char **outstr, size_t *outstrlen)
+ int rados_mon_command(rados_t cluster, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen)
+ int rados_mgr_command(rados_t cluster, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen)
+ int rados_mgr_command_target(rados_t cluster,
+ const char *name,
+ const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen)
+ int rados_mon_command_target(rados_t cluster, const char *name, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen)
+ int rados_osd_command(rados_t cluster, int osdid, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen)
+ int rados_pg_command(rados_t cluster, const char *pgstr, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen)
+ int rados_monitor_log(rados_t cluster, const char *level, rados_log_callback_t cb, void *arg)
+ int rados_monitor_log2(rados_t cluster, const char *level, rados_log_callback2_t cb, void *arg)
+
+ int rados_wait_for_latest_osdmap(rados_t cluster)
+
+ int rados_service_register(rados_t cluster, const char *service, const char *daemon, const char *metadata_dict)
+ int rados_service_update_status(rados_t cluster, const char *status_dict)
+
+ int rados_ioctx_create(rados_t cluster, const char *pool_name, rados_ioctx_t *ioctx)
+ int rados_ioctx_create2(rados_t cluster, int64_t pool_id, rados_ioctx_t *ioctx)
+ void rados_ioctx_destroy(rados_ioctx_t io)
+ void rados_ioctx_locator_set_key(rados_ioctx_t io, const char *key)
+ void rados_ioctx_set_namespace(rados_ioctx_t io, const char * nspace)
+
+ uint64_t rados_get_last_version(rados_ioctx_t io)
+ int rados_stat(rados_ioctx_t io, const char *o, uint64_t *psize, time_t *pmtime)
+ int rados_write(rados_ioctx_t io, const char *oid, const char *buf, size_t len, uint64_t off)
+ int rados_write_full(rados_ioctx_t io, const char *oid, const char *buf, size_t len)
+ int rados_writesame(rados_ioctx_t io, const char *oid, const char *buf, size_t data_len, size_t write_len, uint64_t off)
+ int rados_append(rados_ioctx_t io, const char *oid, const char *buf, size_t len)
+ int rados_read(rados_ioctx_t io, const char *oid, char *buf, size_t len, uint64_t off)
+ int rados_remove(rados_ioctx_t io, const char *oid)
+ int rados_trunc(rados_ioctx_t io, const char *oid, uint64_t size)
+ int rados_cmpext(rados_ioctx_t io, const char *o, const char *cmp_buf, size_t cmp_len, uint64_t off)
+ int rados_getxattr(rados_ioctx_t io, const char *o, const char *name, char *buf, size_t len)
+ int rados_setxattr(rados_ioctx_t io, const char *o, const char *name, const char *buf, size_t len)
+ int rados_rmxattr(rados_ioctx_t io, const char *o, const char *name)
+ int rados_getxattrs(rados_ioctx_t io, const char *oid, rados_xattrs_iter_t *iter)
+ int rados_getxattrs_next(rados_xattrs_iter_t iter, const char **name, const char **val, size_t *len)
+ void rados_getxattrs_end(rados_xattrs_iter_t iter)
+
+ int rados_nobjects_list_open(rados_ioctx_t io, rados_list_ctx_t *ctx)
+ int rados_nobjects_list_next2(rados_list_ctx_t ctx,
+ const char **entry,
+ const char **key,
+ const char **nspace,
+ size_t *entry_size,
+ size_t *key_size,
+ size_t *nspace)
+ void rados_nobjects_list_close(rados_list_ctx_t ctx)
+
+ int rados_ioctx_pool_requires_alignment2(rados_ioctx_t io, int * requires)
+ int rados_ioctx_pool_required_alignment2(rados_ioctx_t io, uint64_t * alignment)
+
+ int rados_ioctx_snap_rollback(rados_ioctx_t io, const char * oid, const char * snapname)
+ int rados_ioctx_snap_create(rados_ioctx_t io, const char * snapname)
+ int rados_ioctx_snap_remove(rados_ioctx_t io, const char * snapname)
+ int rados_ioctx_snap_lookup(rados_ioctx_t io, const char * name, rados_snap_t * id)
+ int rados_ioctx_snap_get_name(rados_ioctx_t io, rados_snap_t id, char * name, int maxlen)
+ void rados_ioctx_snap_set_read(rados_ioctx_t io, rados_snap_t snap)
+ int rados_ioctx_snap_list(rados_ioctx_t io, rados_snap_t * snaps, int maxlen)
+ int rados_ioctx_snap_get_stamp(rados_ioctx_t io, rados_snap_t id, time_t * t)
+ int64_t rados_ioctx_get_id(rados_ioctx_t io)
+ int rados_ioctx_get_pool_name(rados_ioctx_t io, char *buf, unsigned maxlen)
+
+ int rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io,
+ rados_snap_t *snapid)
+ int rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io,
+ rados_snap_t snapid)
+ int rados_ioctx_selfmanaged_snap_set_write_ctx(rados_ioctx_t io,
+ rados_snap_t snap_seq,
+ rados_snap_t *snap,
+ int num_snaps)
+ int rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io, const char *oid,
+ rados_snap_t snapid)
+
+ int rados_lock_exclusive(rados_ioctx_t io, const char * oid, const char * name,
+ const char * cookie, const char * desc,
+ timeval * duration, uint8_t flags)
+ int rados_lock_shared(rados_ioctx_t io, const char * o, const char * name,
+ const char * cookie, const char * tag, const char * desc,
+ timeval * duration, uint8_t flags)
+ int rados_unlock(rados_ioctx_t io, const char * o, const char * name, const char * cookie)
+
+ rados_write_op_t rados_create_write_op()
+ void rados_release_write_op(rados_write_op_t write_op)
+
+ rados_read_op_t rados_create_read_op()
+ void rados_release_read_op(rados_read_op_t read_op)
+
+ int rados_aio_create_completion2(void * cb_arg, rados_callback_t cb_complete, rados_completion_t * pc)
+ void rados_aio_release(rados_completion_t c)
+ int rados_aio_stat(rados_ioctx_t io, const char *oid, rados_completion_t completion, uint64_t *psize, time_t *pmtime)
+ int rados_aio_write(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, size_t len, uint64_t off)
+ int rados_aio_append(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, size_t len)
+ int rados_aio_write_full(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, size_t len)
+ int rados_aio_writesame(rados_ioctx_t io, const char *oid, rados_completion_t completion, const char *buf, size_t data_len, size_t write_len, uint64_t off)
+ int rados_aio_remove(rados_ioctx_t io, const char * oid, rados_completion_t completion)
+ int rados_aio_read(rados_ioctx_t io, const char * oid, rados_completion_t completion, char * buf, size_t len, uint64_t off)
+ int rados_aio_flush(rados_ioctx_t io)
+ int rados_aio_cmpext(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *cmp_buf, size_t cmp_len, uint64_t off)
+ int rados_aio_rmxattr(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *name)
+
+ int rados_aio_get_return_value(rados_completion_t c)
+ int rados_aio_wait_for_complete_and_cb(rados_completion_t c)
+ int rados_aio_wait_for_complete(rados_completion_t c)
+ int rados_aio_is_complete(rados_completion_t c)
+
+ int rados_exec(rados_ioctx_t io, const char * oid, const char * cls, const char * method,
+ const char * in_buf, size_t in_len, char * buf, size_t out_len)
+ int rados_aio_exec(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * cls, const char * method,
+ const char * in_buf, size_t in_len, char * buf, size_t out_len)
+ int rados_aio_setxattr(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *name, const char *buf, size_t len)
+
+ int rados_write_op_operate(rados_write_op_t write_op, rados_ioctx_t io, const char * oid, time_t * mtime, int flags)
+ int rados_aio_write_op_operate(rados_write_op_t write_op, rados_ioctx_t io, rados_completion_t completion, const char *oid, time_t *mtime, int flags)
+ void rados_write_op_cmpext(rados_write_op_t write_op, const char *cmp_buf, size_t cmp_len, uint64_t off, int *prval)
+ void rados_write_op_omap_cmp(rados_write_op_t write_op, const char *key, uint8_t comparison_operator, const char *val, size_t val_len, int *prval)
+ void rados_write_op_omap_set(rados_write_op_t write_op, const char * const* keys, const char * const* vals, const size_t * lens, size_t num)
+ void rados_write_op_omap_rm_keys(rados_write_op_t write_op, const char * const* keys, size_t keys_len)
+ void rados_write_op_omap_clear(rados_write_op_t write_op)
+ void rados_write_op_omap_rm_range2(rados_write_op_t write_op, const char *key_begin, size_t key_begin_len, const char *key_end, size_t key_end_len)
+ void rados_write_op_set_flags(rados_write_op_t write_op, int flags)
+ void rados_write_op_setxattr(rados_write_op_t write_op, const char *name, const char *value, size_t value_len)
+ void rados_write_op_rmxattr(rados_write_op_t write_op, const char *name)
+
+ void rados_write_op_create(rados_write_op_t write_op, int exclusive, const char *category)
+ void rados_write_op_append(rados_write_op_t write_op, const char *buffer, size_t len)
+ void rados_write_op_write_full(rados_write_op_t write_op, const char *buffer, size_t len)
+ void rados_write_op_assert_version(rados_write_op_t write_op, uint64_t ver)
+ void rados_write_op_write(rados_write_op_t write_op, const char *buffer, size_t len, uint64_t offset)
+ void rados_write_op_remove(rados_write_op_t write_op)
+ void rados_write_op_truncate(rados_write_op_t write_op, uint64_t offset)
+ void rados_write_op_zero(rados_write_op_t write_op, uint64_t offset, uint64_t len)
+ void rados_write_op_exec(rados_write_op_t write_op, const char *cls, const char *method, const char *in_buf, size_t in_len, int *prval)
+ void rados_write_op_writesame(rados_write_op_t write_op, const char *buffer, size_t data_len, size_t write_len, uint64_t offset)
+ void rados_read_op_cmpext(rados_read_op_t read_op, const char *cmp_buf, size_t cmp_len, uint64_t off, int *prval)
+ void rados_read_op_omap_get_vals2(rados_read_op_t read_op, const char * start_after, const char * filter_prefix, uint64_t max_return, rados_omap_iter_t * iter, unsigned char *pmore, int * prval)
+ void rados_read_op_omap_get_keys2(rados_read_op_t read_op, const char * start_after, uint64_t max_return, rados_omap_iter_t * iter, unsigned char *pmore, int * prval)
+ void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, const char * const* keys, size_t keys_len, rados_omap_iter_t * iter, int * prval)
+ int rados_read_op_operate(rados_read_op_t read_op, rados_ioctx_t io, const char * oid, int flags)
+ int rados_aio_read_op_operate(rados_read_op_t read_op, rados_ioctx_t io, rados_completion_t completion, const char *oid, int flags)
+ void rados_read_op_set_flags(rados_read_op_t read_op, int flags)
+ int rados_omap_get_next(rados_omap_iter_t iter, const char * const* key, const char * const* val, size_t * len)
+ void rados_omap_get_end(rados_omap_iter_t iter)
+ int rados_notify2(rados_ioctx_t io, const char * o, const char *buf, int buf_len, uint64_t timeout_ms, char **reply_buffer, size_t *reply_buffer_len)
+ int rados_aio_notify(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, int len, uint64_t timeout_ms, char **reply_buffer, size_t *reply_buffer_len)
+ int rados_decode_notify_response(char *reply_buffer, size_t reply_buffer_len, notify_ack_t **acks, size_t *nr_acks, notify_timeout_t **timeouts, size_t *nr_timeouts)
+ void rados_free_notify_response(notify_ack_t *acks, size_t nr_acks, notify_timeout_t *timeouts)
+ int rados_notify_ack(rados_ioctx_t io, const char *o, uint64_t notify_id, uint64_t cookie, const char *buf, int buf_len)
+ int rados_watch3(rados_ioctx_t io, const char *o, uint64_t *cookie, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, uint32_t timeout, void *arg)
+ int rados_watch_check(rados_ioctx_t io, uint64_t cookie)
+ int rados_unwatch2(rados_ioctx_t io, uint64_t cookie)
+ int rados_watch_flush(rados_t cluster)
diff --git a/src/pybind/rados/ctime.pxd b/src/pybind/rados/ctime.pxd
new file mode 100644
index 000000000..3e16ce4c2
--- /dev/null
+++ b/src/pybind/rados/ctime.pxd
@@ -0,0 +1,11 @@
+# cython: embedsignature=True
+
+cdef extern from "time.h":
+ ctypedef long int time_t
+ ctypedef long int suseconds_t
+
+
+cdef extern from "sys/time.h":
+ cdef struct timeval:
+ time_t tv_sec
+ suseconds_t tv_usec
diff --git a/src/pybind/rados/mock_rados.pxi b/src/pybind/rados/mock_rados.pxi
new file mode 100644
index 000000000..36f5aad7d
--- /dev/null
+++ b/src/pybind/rados/mock_rados.pxi
@@ -0,0 +1,465 @@
+# cython: embedsignature=True
+
+from libc.stdint cimport *
+from ctime cimport time_t, timeval
+
+# mirrors the structure of c_rados, but instead *defines* the rados functions
+
+# err.h
+cdef:
+ int _MAX_ERRNO "MAX_ERRNO"
+
+# rados/rados_types.h
+cdef:
+ char* _LIBRADOS_ALL_NSPACES = "\001"
+ struct notify_ack_t:
+ unsigned long notifier_id
+ unsigned long cookie
+ char *payload
+ unsigned long payload_len
+
+ struct notify_timeout_t:
+ unsigned long notifier_id
+ unsigned long cookie
+
+# rados/librados.h
+cdef nogil:
+ enum:
+ _LIBRADOS_OP_FLAG_EXCL "LIBRADOS_OP_FLAG_EXCL"
+ _LIBRADOS_OP_FLAG_FAILOK "LIBRADOS_OP_FLAG_FAILOK"
+ _LIBRADOS_OP_FLAG_FADVISE_RANDOM "LIBRADOS_OP_FLAG_FADVISE_RANDOM"
+ _LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL "LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL"
+ _LIBRADOS_OP_FLAG_FADVISE_WILLNEED "LIBRADOS_OP_FLAG_FADVISE_WILLNEED"
+ _LIBRADOS_OP_FLAG_FADVISE_DONTNEED "LIBRADOS_OP_FLAG_FADVISE_DONTNEED"
+ _LIBRADOS_OP_FLAG_FADVISE_NOCACHE "LIBRADOS_OP_FLAG_FADVISE_NOCACHE"
+
+
+ enum:
+ _LIBRADOS_CMPXATTR_OP_EQ "LIBRADOS_CMPXATTR_OP_EQ"
+ _LIBRADOS_CMPXATTR_OP_NE "LIBRADOS_CMPXATTR_OP_NE"
+ _LIBRADOS_CMPXATTR_OP_GT "LIBRADOS_CMPXATTR_OP_GT"
+ _LIBRADOS_CMPXATTR_OP_GTE "LIBRADOS_CMPXATTR_OP_GTE"
+ _LIBRADOS_CMPXATTR_OP_LT "LIBRADOS_CMPXATTR_OP_LT"
+ _LIBRADOS_CMPXATTR_OP_LTE "LIBRADOS_CMPXATTR_OP_LTE"
+
+
+ enum:
+ _LIBRADOS_OPERATION_NOFLAG "LIBRADOS_OPERATION_NOFLAG"
+ _LIBRADOS_OPERATION_BALANCE_READS "LIBRADOS_OPERATION_BALANCE_READS"
+ _LIBRADOS_OPERATION_LOCALIZE_READS "LIBRADOS_OPERATION_LOCALIZE_READS"
+ _LIBRADOS_OPERATION_ORDER_READS_WRITES "LIBRADOS_OPERATION_ORDER_READS_WRITES"
+ _LIBRADOS_OPERATION_IGNORE_CACHE "LIBRADOS_OPERATION_IGNORE_CACHE"
+ _LIBRADOS_OPERATION_SKIPRWLOCKS "LIBRADOS_OPERATION_SKIPRWLOCKS"
+ _LIBRADOS_OPERATION_IGNORE_OVERLAY "LIBRADOS_OPERATION_IGNORE_OVERLAY"
+ _LIBRADOS_CREATE_EXCLUSIVE "LIBRADOS_CREATE_EXCLUSIVE"
+ _LIBRADOS_CREATE_IDEMPOTENT "LIBRADOS_CREATE_IDEMPOTENT"
+
+ uint64_t _LIBRADOS_SNAP_HEAD "LIBRADOS_SNAP_HEAD"
+
+ ctypedef void* rados_xattrs_iter_t
+ ctypedef void* rados_omap_iter_t
+ ctypedef void* rados_list_ctx_t
+ ctypedef uint64_t rados_snap_t
+ ctypedef void *rados_write_op_t
+ ctypedef void *rados_read_op_t
+ ctypedef void *rados_completion_t
+ ctypedef void (*rados_callback_t)(rados_completion_t cb, void *arg)
+ ctypedef void (*rados_log_callback_t)(void *arg, const char *line, const char *who,
+ uint64_t sec, uint64_t nsec, uint64_t seq, const char *level, const char *msg)
+ ctypedef void (*rados_log_callback2_t)(void *arg, const char *line, const char *channel, const char *who, const char *name,
+ uint64_t sec, uint64_t nsec, uint64_t seq, const char *level, const char *msg)
+ ctypedef void (*rados_watchcb2_t)(void *arg, int64_t notify_id,
+ uint64_t handle, uint64_t notifier_id,
+ void *data, size_t data_len)
+ ctypedef void (*rados_watcherrcb_t)(void *pre, uint64_t cookie, int err)
+
+
+ struct rados_cluster_stat_t:
+ uint64_t kb
+ uint64_t kb_used
+ uint64_t kb_avail
+ uint64_t num_objects
+
+ struct rados_pool_stat_t:
+ uint64_t num_bytes
+ uint64_t num_kb
+ uint64_t num_objects
+ uint64_t num_object_clones
+ uint64_t num_object_copies
+ uint64_t num_objects_missing_on_primary
+ uint64_t num_objects_unfound
+ uint64_t num_objects_degraded
+ uint64_t num_rd
+ uint64_t num_rd_kb
+ uint64_t num_wr
+ uint64_t num_wr_kb
+
+ void rados_buffer_free(char *buf):
+ pass
+
+ void rados_version(int *major, int *minor, int *extra):
+ pass
+
+ int rados_create2(rados_t *pcluster, const char *const clustername,
+ const char * const name, uint64_t flags):
+ pass
+
+ int rados_create_with_context(rados_t *cluster, rados_config_t cct):
+ pass
+ int rados_connect(rados_t cluster):
+ pass
+ void rados_shutdown(rados_t cluster):
+ pass
+ cdef uint64_t rados_get_instance_id(rados_t cluster):
+ pass
+ int rados_conf_read_file(rados_t cluster, const char *path):
+ pass
+ int rados_conf_parse_argv_remainder(rados_t cluster, int argc, const char **argv, const char **remargv):
+ pass
+ int rados_conf_parse_env(rados_t cluster, const char *var):
+ pass
+ int rados_conf_set(rados_t cluster, char *option, const char *value):
+ pass
+ int rados_conf_get(rados_t cluster, char *option, char *buf, size_t len):
+ pass
+
+ rados_t rados_ioctx_get_cluster(rados_ioctx_t io):
+ pass
+ int rados_ioctx_pool_stat(rados_ioctx_t io, rados_pool_stat_t *stats):
+ pass
+ int64_t rados_pool_lookup(rados_t cluster, const char *pool_name):
+ pass
+ int rados_pool_reverse_lookup(rados_t cluster, int64_t id, char *buf, size_t maxlen):
+ pass
+ int rados_pool_create(rados_t cluster, const char *pool_name):
+ pass
+ int rados_pool_create_with_crush_rule(rados_t cluster, const char *pool_name, uint8_t crush_rule_num):
+ pass
+ int rados_pool_create_with_auid(rados_t cluster, const char *pool_name, uint64_t auid):
+ pass
+ int rados_pool_create_with_all(rados_t cluster, const char *pool_name, uint64_t auid, uint8_t crush_rule_num):
+ pass
+ int rados_pool_get_base_tier(rados_t cluster, int64_t pool, int64_t *base_tier):
+ pass
+ int rados_pool_list(rados_t cluster, char *buf, size_t len):
+ pass
+ int rados_pool_delete(rados_t cluster, const char *pool_name):
+ pass
+ int rados_inconsistent_pg_list(rados_t cluster, int64_t pool, char *buf, size_t len):
+ pass
+
+ int rados_cluster_stat(rados_t cluster, rados_cluster_stat_t *result):
+ pass
+ int rados_cluster_fsid(rados_t cluster, char *buf, size_t len):
+ pass
+ int rados_blocklist_add(rados_t cluster, char *client_address, uint32_t expire_seconds):
+ pass
+ int rados_getaddrs(rados_t cluster, char** addrs):
+ pass
+ int rados_application_enable(rados_ioctx_t io, const char *app_name,
+ int force):
+ pass
+ void rados_set_pool_full_try(rados_ioctx_t io):
+ pass
+ void rados_unset_pool_full_try(rados_ioctx_t io):
+ pass
+ int rados_application_list(rados_ioctx_t io, char *values,
+ size_t *values_len):
+ pass
+ int rados_application_metadata_get(rados_ioctx_t io, const char *app_name,
+ const char *key, char *value,
+ size_t *value_len):
+ pass
+ int rados_application_metadata_set(rados_ioctx_t io, const char *app_name,
+ const char *key, const char *value):
+ pass
+ int rados_application_metadata_remove(rados_ioctx_t io,
+ const char *app_name, const char *key):
+ pass
+ int rados_application_metadata_list(rados_ioctx_t io,
+ const char *app_name, char *keys,
+ size_t *key_len, char *values,
+ size_t *value_len):
+ pass
+ int rados_ping_monitor(rados_t cluster, const char *mon_id, char **outstr, size_t *outstrlen):
+ pass
+ int rados_mon_command(rados_t cluster, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen):
+ pass
+ int rados_mgr_command(rados_t cluster, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen):
+ pass
+ int rados_mgr_command_target(rados_t cluster,
+ const char *name,
+ const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen):
+ pass
+ int rados_mon_command_target(rados_t cluster, const char *name, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen):
+ pass
+ int rados_osd_command(rados_t cluster, int osdid, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen):
+ pass
+ int rados_pg_command(rados_t cluster, const char *pgstr, const char **cmd, size_t cmdlen,
+ const char *inbuf, size_t inbuflen,
+ char **outbuf, size_t *outbuflen,
+ char **outs, size_t *outslen):
+ pass
+ int rados_monitor_log(rados_t cluster, const char *level, rados_log_callback_t cb, void *arg):
+ pass
+ int rados_monitor_log2(rados_t cluster, const char *level, rados_log_callback2_t cb, void *arg):
+ pass
+
+ int rados_wait_for_latest_osdmap(rados_t cluster):
+ pass
+
+ int rados_service_register(rados_t cluster, const char *service, const char *daemon, const char *metadata_dict):
+ pass
+ int rados_service_update_status(rados_t cluster, const char *status_dict):
+ pass
+
+ int rados_ioctx_create(rados_t cluster, const char *pool_name, rados_ioctx_t *ioctx):
+ pass
+ int rados_ioctx_create2(rados_t cluster, int64_t pool_id, rados_ioctx_t *ioctx):
+ pass
+ void rados_ioctx_destroy(rados_ioctx_t io):
+ pass
+ void rados_ioctx_locator_set_key(rados_ioctx_t io, const char *key):
+ pass
+ void rados_ioctx_set_namespace(rados_ioctx_t io, const char * nspace):
+ pass
+
+ cdef uint64_t rados_get_last_version(rados_ioctx_t io):
+ pass
+ int rados_stat(rados_ioctx_t io, const char *o, uint64_t *psize, time_t *pmtime):
+ pass
+ int rados_write(rados_ioctx_t io, const char *oid, const char *buf, size_t len, uint64_t off):
+ pass
+ int rados_write_full(rados_ioctx_t io, const char *oid, const char *buf, size_t len):
+ pass
+ int rados_writesame(rados_ioctx_t io, const char *oid, const char *buf, size_t data_len, size_t write_len, uint64_t off):
+ pass
+ int rados_append(rados_ioctx_t io, const char *oid, const char *buf, size_t len):
+ pass
+ int rados_read(rados_ioctx_t io, const char *oid, char *buf, size_t len, uint64_t off):
+ pass
+ int rados_remove(rados_ioctx_t io, const char *oid):
+ pass
+ int rados_trunc(rados_ioctx_t io, const char *oid, uint64_t size):
+ pass
+ int rados_cmpext(rados_ioctx_t io, const char *o, const char *cmp_buf, size_t cmp_len, uint64_t off):
+ pass
+ int rados_getxattr(rados_ioctx_t io, const char *o, const char *name, char *buf, size_t len):
+ pass
+ int rados_setxattr(rados_ioctx_t io, const char *o, const char *name, const char *buf, size_t len):
+ pass
+ int rados_rmxattr(rados_ioctx_t io, const char *o, const char *name):
+ pass
+ int rados_getxattrs(rados_ioctx_t io, const char *oid, rados_xattrs_iter_t *iter):
+ pass
+ int rados_getxattrs_next(rados_xattrs_iter_t iter, const char **name, const char **val, size_t *len):
+ pass
+ void rados_getxattrs_end(rados_xattrs_iter_t iter):
+ pass
+
+ int rados_nobjects_list_open(rados_ioctx_t io, rados_list_ctx_t *ctx):
+ pass
+ int rados_nobjects_list_next2(rados_list_ctx_t ctx, const char **entry, const char **key, const char **nspace,
+ size_t *entry_size, size_t *key_size, size_t *nspace_size):
+ pass
+ void rados_nobjects_list_close(rados_list_ctx_t ctx):
+ pass
+
+ int rados_ioctx_pool_requires_alignment2(rados_ioctx_t io, int * requires):
+ pass
+ int rados_ioctx_pool_required_alignment2(rados_ioctx_t io, uint64_t * alignment):
+ pass
+
+ int rados_ioctx_snap_rollback(rados_ioctx_t io, const char * oid, const char * snapname):
+ pass
+ int rados_ioctx_snap_create(rados_ioctx_t io, const char * snapname):
+ pass
+ int rados_ioctx_snap_remove(rados_ioctx_t io, const char * snapname):
+ pass
+ int rados_ioctx_snap_lookup(rados_ioctx_t io, const char * name, rados_snap_t * id):
+ pass
+ int rados_ioctx_snap_get_name(rados_ioctx_t io, rados_snap_t id, char * name, int maxlen):
+ pass
+ void rados_ioctx_snap_set_read(rados_ioctx_t io, rados_snap_t snap):
+ pass
+ int rados_ioctx_snap_list(rados_ioctx_t io, rados_snap_t * snaps, int maxlen):
+ pass
+ int rados_ioctx_snap_get_stamp(rados_ioctx_t io, rados_snap_t id, time_t * t):
+ pass
+ int64_t rados_ioctx_get_id(rados_ioctx_t io):
+ pass
+ int rados_ioctx_get_pool_name(rados_ioctx_t io, char *buf, unsigned maxlen):
+ pass
+
+ int rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io,
+ rados_snap_t *snapid):
+ pass
+ int rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io,
+ rados_snap_t snapid):
+ pass
+ int rados_ioctx_selfmanaged_snap_set_write_ctx(rados_ioctx_t io,
+ rados_snap_t snap_seq,
+ rados_snap_t *snap,
+ int num_snaps):
+ pass
+ int rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io, const char *oid,
+ rados_snap_t snapid):
+ pass
+
+ int rados_lock_exclusive(rados_ioctx_t io, const char * oid, const char * name,
+ const char * cookie, const char * desc,
+ timeval * duration, uint8_t flags):
+ pass
+ int rados_lock_shared(rados_ioctx_t io, const char * o, const char * name,
+ const char * cookie, const char * tag, const char * desc,
+ timeval * duration, uint8_t flags):
+ pass
+ int rados_unlock(rados_ioctx_t io, const char * o, const char * name, const char * cookie):
+ pass
+
+ rados_write_op_t rados_create_write_op():
+ pass
+ void rados_release_write_op(rados_write_op_t write_op):
+ pass
+
+ rados_read_op_t rados_create_read_op():
+ pass
+ void rados_release_read_op(rados_read_op_t read_op):
+ pass
+
+ int rados_aio_create_completion2(void * cb_arg, rados_callback_t cb_complete, rados_completion_t * pc):
+ pass
+ void rados_aio_release(rados_completion_t c):
+ pass
+ int rados_aio_stat(rados_ioctx_t io, const char *oid, rados_completion_t completion, uint64_t *psize, time_t *pmtime):
+ pass
+ int rados_aio_write(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, size_t len, uint64_t off):
+ pass
+ int rados_aio_append(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, size_t len):
+ pass
+ int rados_aio_write_full(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, size_t len):
+ pass
+ int rados_aio_writesame(rados_ioctx_t io, const char *oid, rados_completion_t completion, const char *buf, size_t data_len, size_t write_len, uint64_t off):
+ pass
+ int rados_aio_remove(rados_ioctx_t io, const char * oid, rados_completion_t completion):
+ pass
+ int rados_aio_read(rados_ioctx_t io, const char * oid, rados_completion_t completion, char * buf, size_t len, uint64_t off):
+ pass
+ int rados_aio_flush(rados_ioctx_t io):
+ pass
+ int rados_aio_cmpext(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *cmp_buf, size_t cmp_len, uint64_t off):
+ pass
+ int rados_aio_rmxattr(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *name):
+ pass
+
+ int rados_aio_get_return_value(rados_completion_t c):
+ pass
+ int rados_aio_wait_for_complete_and_cb(rados_completion_t c):
+ pass
+ int rados_aio_wait_for_complete(rados_completion_t c):
+ pass
+ int rados_aio_is_complete(rados_completion_t c):
+ pass
+
+ int rados_exec(rados_ioctx_t io, const char * oid, const char * cls, const char * method,
+ const char * in_buf, size_t in_len, char * buf, size_t out_len):
+ pass
+ int rados_aio_exec(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * cls, const char * method,
+ const char * in_buf, size_t in_len, char * buf, size_t out_len):
+ pass
+ int rados_aio_setxattr(rados_ioctx_t io, const char *o, rados_completion_t completion, const char *name, const char *buf, size_t len):
+ pass
+ int rados_write_op_operate(rados_write_op_t write_op, rados_ioctx_t io, const char * oid, time_t * mtime, int flags):
+ pass
+ int rados_aio_write_op_operate(rados_write_op_t write_op, rados_ioctx_t io, rados_completion_t completion, const char *oid, time_t *mtime, int flags):
+ pass
+ void rados_write_op_cmpext(rados_write_op_t write_op, const char *cmp_buf, size_t cmp_len, uint64_t off, int *prval):
+ pass
+ void rados_write_op_omap_cmp(rados_write_op_t write_op, const char *key, uint8_t comparison_operator, const char *val, size_t val_len, int *prval):
+ pass
+ void rados_write_op_omap_set(rados_write_op_t write_op, const char * const* keys, const char * const* vals, const size_t * lens, size_t num):
+ pass
+ void rados_write_op_omap_rm_keys(rados_write_op_t write_op, const char * const* keys, size_t keys_len):
+ pass
+ void rados_write_op_omap_clear(rados_write_op_t write_op):
+ pass
+ void rados_write_op_omap_rm_range2(rados_write_op_t write_op, const char *key_begin, size_t key_begin_len, const char *key_end, size_t key_end_len):
+ pass
+ void rados_write_op_set_flags(rados_write_op_t write_op, int flags):
+ pass
+ void rados_write_op_setxattr(rados_write_op_t write_op, const char *name, const char *value, size_t value_len):
+ pass
+ void rados_write_op_rmxattr(rados_write_op_t write_op, const char *name):
+ pass
+
+ void rados_write_op_create(rados_write_op_t write_op, int exclusive, const char *category):
+ pass
+ void rados_write_op_append(rados_write_op_t write_op, const char *buffer, size_t len):
+ pass
+ void rados_write_op_write_full(rados_write_op_t write_op, const char *buffer, size_t len):
+ pass
+ void rados_write_op_assert_version(rados_write_op_t write_op, uint64_t ver):
+ pass
+ void rados_write_op_write(rados_write_op_t write_op, const char *buffer, size_t len, uint64_t offset):
+ pass
+ void rados_write_op_remove(rados_write_op_t write_op):
+ pass
+ void rados_write_op_truncate(rados_write_op_t write_op, uint64_t offset):
+ pass
+ void rados_write_op_zero(rados_write_op_t write_op, uint64_t offset, uint64_t len):
+ pass
+ void rados_write_op_exec(rados_write_op_t write_op, const char *cls, const char *method, const char *in_buf, size_t in_len, int *prval):
+ pass
+ void rados_write_op_writesame(rados_write_op_t write_op, const char *buffer, size_t data_len, size_t write_len, uint64_t offset):
+ pass
+ void rados_read_op_cmpext(rados_read_op_t read_op, const char *cmp_buf, size_t cmp_len, uint64_t off, int *prval):
+ pass
+ void rados_read_op_omap_get_vals2(rados_read_op_t read_op, const char * start_after, const char * filter_prefix, uint64_t max_return, rados_omap_iter_t * iter, unsigned char *pmore, int * prval):
+ pass
+ void rados_read_op_omap_get_keys2(rados_read_op_t read_op, const char * start_after, uint64_t max_return, rados_omap_iter_t * iter, unsigned char *pmore, int * prval):
+ pass
+ void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, const char * const* keys, size_t keys_len, rados_omap_iter_t * iter, int * prval):
+ pass
+ int rados_read_op_operate(rados_read_op_t read_op, rados_ioctx_t io, const char * oid, int flags):
+ pass
+ int rados_aio_read_op_operate(rados_read_op_t read_op, rados_ioctx_t io, rados_completion_t completion, const char *oid, int flags):
+ pass
+ void rados_read_op_set_flags(rados_read_op_t read_op, int flags):
+ pass
+ int rados_omap_get_next(rados_omap_iter_t iter, const char * const* key, const char * const* val, size_t * len):
+ pass
+ void rados_omap_get_end(rados_omap_iter_t iter):
+ pass
+ int rados_notify2(rados_ioctx_t io, const char * o, const char *buf, int buf_len, uint64_t timeout_ms, char **reply_buffer, size_t *reply_buffer_len):
+ pass
+ int rados_aio_notify(rados_ioctx_t io, const char * oid, rados_completion_t completion, const char * buf, int len, uint64_t timeout_ms, char **reply_buffer, size_t *reply_buffer_len):
+ pass
+ int rados_decode_notify_response(char *reply_buffer, size_t reply_buffer_len, notify_ack_t **acks, size_t *nr_acks, notify_timeout_t **timeouts, size_t *nr_timeouts):
+ pass
+ void rados_free_notify_response(notify_ack_t *acks, size_t nr_acks, notify_timeout_t *timeouts):
+ pass
+ int rados_notify_ack(rados_ioctx_t io, const char *o, uint64_t notify_id, uint64_t cookie, const char *buf, int buf_len):
+ pass
+ int rados_watch3(rados_ioctx_t io, const char *o, uint64_t *cookie, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, uint32_t timeout, void *arg):
+ pass
+ int rados_watch_check(rados_ioctx_t io, uint64_t cookie):
+ pass
+ int rados_unwatch2(rados_ioctx_t io, uint64_t cookie):
+ pass
+ int rados_watch_flush(rados_t cluster):
+ pass
diff --git a/src/pybind/rados/rados.pxd b/src/pybind/rados/rados.pxd
new file mode 100644
index 000000000..fec534e8c
--- /dev/null
+++ b/src/pybind/rados/rados.pxd
@@ -0,0 +1,45 @@
+# cython: embedsignature=True
+#
+# Shared object for librbdpy
+#
+# Copyright 2016 Mehdi Abaakouk <sileht@redhat.com>
+
+IF BUILD_DOC:
+ cdef:
+ ctypedef void* rados_t
+ ctypedef void* rados_config_t
+ ctypedef void* rados_ioctx_t
+ELSE:
+ cdef extern from "rados/librados.h" nogil:
+ ctypedef void* rados_t
+ ctypedef void* rados_config_t
+ ctypedef void* rados_ioctx_t
+
+
+cdef class Rados(object):
+ cdef:
+ rados_t cluster
+ public object state
+ public object monitor_callback
+ public object monitor_callback2
+ public object parsed_args
+ public object conf_defaults
+ public object conffile
+ public object rados_id
+
+
+cdef class Ioctx(object):
+ cdef:
+ object rados
+ rados_ioctx_t io
+ public object name
+ public object state
+ public object locator_key
+ public object nspace
+
+ # TODO(sileht): we need to track leaving completion objects
+ # I guess we can do that in a lighter ways, but keep code simple
+ # as before for now
+ public object safe_completions
+ public object complete_completions
+ public object lock
diff --git a/src/pybind/rados/rados.pyx b/src/pybind/rados/rados.pyx
new file mode 100644
index 000000000..15198f6e6
--- /dev/null
+++ b/src/pybind/rados/rados.pyx
@@ -0,0 +1,4363 @@
+# cython: embedsignature=True, binding=True
+"""
+This module is a thin wrapper around librados.
+
+Error codes from librados are turned into exceptions that subclass
+:class:`Error`. Almost all methods may raise :class:`Error(the base class of all rados exceptions), :class:`PermissionError`
+(the base class of all rados exceptions), :class:`PermissionError`
+and :class:`IOError`, in addition to those documented for the
+method.
+"""
+# Copyright 2011 Josh Durgin
+# Copyright 2011, Hannu Valtonen <hannu.valtonen@ormod.com>
+# Copyright 2015 Hector Martin <marcan@marcan.st>
+# Copyright 2016 Mehdi Abaakouk <sileht@redhat.com>
+
+from cpython cimport PyObject, ref
+from cpython.pycapsule cimport *
+from libc cimport errno
+from libc.stdint cimport *
+from libc.stdlib cimport malloc, realloc, free
+IF BUILD_DOC:
+ include "mock_rados.pxi"
+ELSE:
+ from c_rados cimport *
+
+import threading
+import time
+
+from datetime import datetime, timedelta
+from functools import partial, wraps
+from itertools import chain
+from typing import Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+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 Ioctx.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
+ void PyEval_InitThreads()
+
+LIBRADOS_OP_FLAG_EXCL = _LIBRADOS_OP_FLAG_EXCL
+LIBRADOS_OP_FLAG_FAILOK = _LIBRADOS_OP_FLAG_FAILOK
+LIBRADOS_OP_FLAG_FADVISE_RANDOM = _LIBRADOS_OP_FLAG_FADVISE_RANDOM
+LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL = _LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL
+LIBRADOS_OP_FLAG_FADVISE_WILLNEED = _LIBRADOS_OP_FLAG_FADVISE_WILLNEED
+LIBRADOS_OP_FLAG_FADVISE_DONTNEED = _LIBRADOS_OP_FLAG_FADVISE_DONTNEED
+LIBRADOS_OP_FLAG_FADVISE_NOCACHE = _LIBRADOS_OP_FLAG_FADVISE_NOCACHE
+
+LIBRADOS_CMPXATTR_OP_EQ = _LIBRADOS_CMPXATTR_OP_EQ
+LIBRADOS_CMPXATTR_OP_NE = _LIBRADOS_CMPXATTR_OP_NE
+LIBRADOS_CMPXATTR_OP_GT = _LIBRADOS_CMPXATTR_OP_GT
+LIBRADOS_CMPXATTR_OP_GTE = _LIBRADOS_CMPXATTR_OP_GTE
+LIBRADOS_CMPXATTR_OP_LT = _LIBRADOS_CMPXATTR_OP_LT
+LIBRADOS_CMPXATTR_OP_LTE = _LIBRADOS_CMPXATTR_OP_LTE
+
+LIBRADOS_SNAP_HEAD = _LIBRADOS_SNAP_HEAD
+
+LIBRADOS_OPERATION_NOFLAG = _LIBRADOS_OPERATION_NOFLAG
+LIBRADOS_OPERATION_BALANCE_READS = _LIBRADOS_OPERATION_BALANCE_READS
+LIBRADOS_OPERATION_LOCALIZE_READS = _LIBRADOS_OPERATION_LOCALIZE_READS
+LIBRADOS_OPERATION_ORDER_READS_WRITES = _LIBRADOS_OPERATION_ORDER_READS_WRITES
+LIBRADOS_OPERATION_IGNORE_CACHE = _LIBRADOS_OPERATION_IGNORE_CACHE
+LIBRADOS_OPERATION_SKIPRWLOCKS = _LIBRADOS_OPERATION_SKIPRWLOCKS
+LIBRADOS_OPERATION_IGNORE_OVERLAY = _LIBRADOS_OPERATION_IGNORE_OVERLAY
+
+LIBRADOS_ALL_NSPACES = _LIBRADOS_ALL_NSPACES.decode('utf-8')
+
+LIBRADOS_CREATE_EXCLUSIVE = _LIBRADOS_CREATE_EXCLUSIVE
+LIBRADOS_CREATE_IDEMPOTENT = _LIBRADOS_CREATE_IDEMPOTENT
+
+MAX_ERRNO = _MAX_ERRNO
+
+ANONYMOUS_AUID = 0xffffffffffffffff
+ADMIN_AUID = 0
+
+OMAP_KEY_TYPE = Union[str,bytes]
+
+class Error(Exception):
+ """ `Error` class, derived from `Exception` """
+ def __init__(self, message, errno=None):
+ super(Exception, self).__init__(message)
+ self.errno = errno
+
+ def __str__(self):
+ msg = super(Exception, 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 InvalidArgumentError(Error):
+ def __init__(self, message, errno=None):
+ super(InvalidArgumentError, self).__init__(
+ "RADOS invalid argument (%s)" % message, errno)
+
+class ExtendMismatch(Error):
+ def __init__(self, message, errno, offset):
+ super().__init__(
+ "object content does not match (%s)" % message, errno)
+ self.offset = offset
+
+class OSError(Error):
+ """ `OSError` class, derived from `Error` """
+ pass
+
+class InterruptedOrTimeoutError(OSError):
+ """ `InterruptedOrTimeoutError` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(InterruptedOrTimeoutError, self).__init__(
+ "RADOS interrupted or timeout (%s)" % message, errno)
+
+
+class PermissionError(OSError):
+ """ `PermissionError` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(PermissionError, self).__init__(
+ "RADOS permission error (%s)" % message, errno)
+
+
+class PermissionDeniedError(OSError):
+ """ deal with EACCES related. """
+ def __init__(self, message, errno=None):
+ super(PermissionDeniedError, self).__init__(
+ "RADOS permission denied (%s)" % message, errno)
+
+
+class ObjectNotFound(OSError):
+ """ `ObjectNotFound` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(ObjectNotFound, self).__init__(
+ "RADOS object not found (%s)" % message, errno)
+
+
+class NoData(OSError):
+ """ `NoData` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(NoData, self).__init__(
+ "RADOS no data (%s)" % message, errno)
+
+
+class ObjectExists(OSError):
+ """ `ObjectExists` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(ObjectExists, self).__init__(
+ "RADOS object exists (%s)" % message, errno)
+
+
+class ObjectBusy(OSError):
+ """ `ObjectBusy` class, derived from `IOError` """
+ def __init__(self, message, errno=None):
+ super(ObjectBusy, self).__init__(
+ "RADOS object busy (%s)" % message, errno)
+
+
+class IOError(OSError):
+ """ `ObjectBusy` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(IOError, self).__init__(
+ "RADOS I/O error (%s)" % message, errno)
+
+
+class NoSpace(OSError):
+ """ `NoSpace` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(NoSpace, self).__init__(
+ "RADOS no space (%s)" % message, errno)
+
+class NotConnected(OSError):
+ """ `NotConnected` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(NotConnected, self).__init__(
+ "RADOS not connected (%s)" % message, errno)
+
+class RadosStateError(Error):
+ """ `RadosStateError` class, derived from `Error` """
+ def __init__(self, message, errno=None):
+ super(RadosStateError, self).__init__(
+ "RADOS rados state (%s)" % message, errno)
+
+
+class IoctxStateError(Error):
+ """ `IoctxStateError` class, derived from `Error` """
+ def __init__(self, message, errno=None):
+ super(IoctxStateError, self).__init__(
+ "RADOS Ioctx state error (%s)" % message, errno)
+
+
+class ObjectStateError(Error):
+ """ `ObjectStateError` class, derived from `Error` """
+ def __init__(self, message, errno=None):
+ super(ObjectStateError, self).__init__(
+ "RADOS object state error (%s)" % message, errno)
+
+
+class LogicError(Error):
+ """ `` class, derived from `Error` """
+ def __init__(self, message, errno=None):
+ super(LogicError, self).__init__(
+ "RADOS logic error (%s)" % message, errno)
+
+
+class TimedOut(OSError):
+ """ `TimedOut` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(TimedOut, self).__init__(
+ "RADOS timed out (%s)" % message, errno)
+
+
+class InProgress(Error):
+ """ `InProgress` class, derived from `Error` """
+ def __init__(self, message, errno=None):
+ super(InProgress, self).__init__(
+ "RADOS in progress error (%s)" % message, errno)
+
+
+class IsConnected(Error):
+ """ `IsConnected` class, derived from `Error` """
+ def __init__(self, message, errno=None):
+ super(IsConnected, self).__init__(
+ "RADOS is connected error (%s)" % message, errno)
+
+
+class ConnectionShutdown(OSError):
+ """ `ConnectionShutdown` class, derived from `OSError` """
+ def __init__(self, message, errno=None):
+ super(ConnectionShutdown, self).__init__(
+ "RADOS connection was shutdown (%s)" % message, errno)
+
+
+IF UNAME_SYSNAME == "FreeBSD":
+ cdef errno_to_exception = {
+ errno.EPERM : PermissionError,
+ errno.ENOENT : ObjectNotFound,
+ errno.EIO : IOError,
+ errno.ENOSPC : NoSpace,
+ errno.EEXIST : ObjectExists,
+ errno.EBUSY : ObjectBusy,
+ errno.ENOATTR : NoData,
+ errno.EINTR : InterruptedOrTimeoutError,
+ errno.ETIMEDOUT : TimedOut,
+ errno.EACCES : PermissionDeniedError,
+ errno.EINPROGRESS : InProgress,
+ errno.EISCONN : IsConnected,
+ errno.EINVAL : InvalidArgumentError,
+ errno.ENOTCONN : NotConnected,
+ errno.ESHUTDOWN : ConnectionShutdown,
+ }
+ELSE:
+ cdef errno_to_exception = {
+ errno.EPERM : PermissionError,
+ errno.ENOENT : ObjectNotFound,
+ errno.EIO : IOError,
+ errno.ENOSPC : NoSpace,
+ errno.EEXIST : ObjectExists,
+ errno.EBUSY : ObjectBusy,
+ errno.ENODATA : NoData,
+ errno.EINTR : InterruptedOrTimeoutError,
+ errno.ETIMEDOUT : TimedOut,
+ errno.EACCES : PermissionDeniedError,
+ errno.EINPROGRESS : InProgress,
+ errno.EISCONN : IsConnected,
+ errno.EINVAL : InvalidArgumentError,
+ errno.ENOTCONN : NotConnected,
+ errno.ESHUTDOWN : ConnectionShutdown,
+ }
+
+
+cdef make_ex(ret: int, msg: str):
+ """
+ Translate a librados 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)
+ elif ret > MAX_ERRNO:
+ offset = ret - MAX_ERRNO
+ return ExtendMismatch(msg, ret, offset)
+ else:
+ return OSError(msg, errno=ret)
+
+
+def cstr(val, name, encoding="utf-8", opt=False) -> Optional[bytes]:
+ """
+ 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
+ :raises: :class:`InvalidArgument`
+ """
+ if opt and val is None:
+ return None
+ if isinstance(val, bytes):
+ return val
+ elif isinstance(val, str):
+ return val.encode(encoding)
+ else:
+ raise TypeError('%s must be a string' % name)
+
+
+def cstr_list(list_str, name, encoding="utf-8"):
+ return [cstr(s, name) for s in list_str]
+
+
+def decode_cstr(val, encoding="utf-8") -> Optional[str]:
+ """
+ Decode a byte string into a Python string.
+
+ :param bytes val: byte string
+ """
+ if val is None:
+ return None
+
+ return val.decode(encoding)
+
+
+def flatten_dict(d, name):
+ items = chain.from_iterable(d.items())
+ return cstr(''.join(i + '\0' for i in items), name)
+
+
+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 size_t * to_csize_t_array(list_int):
+ cdef size_t *ret = <size_t *>malloc(len(list_int) * sizeof(size_t))
+ if ret == NULL:
+ raise MemoryError("malloc failed")
+ for i in range(len(list_int)):
+ ret[i] = <size_t>list_int[i]
+ return ret
+
+
+cdef char ** to_bytes_array(list_bytes):
+ cdef char **ret = <char **>malloc(len(list_bytes) * sizeof(char *))
+ if ret == NULL:
+ raise MemoryError("malloc failed")
+ for i in range(len(list_bytes)):
+ ret[i] = <char *>list_bytes[i]
+ return ret
+
+cdef int __monitor_callback(void *arg, const char *line, const char *who,
+ uint64_t sec, uint64_t nsec, uint64_t seq,
+ const char *level, const char *msg) with gil:
+ cdef object cb_info = <object>arg
+ cb_info[0](cb_info[1], line, who, sec, nsec, seq, level, msg)
+ return 0
+
+cdef int __monitor_callback2(void *arg, const char *line, const char *channel,
+ const char *who,
+ const char *name,
+ uint64_t sec, uint64_t nsec, uint64_t seq,
+ const char *level, const char *msg) with gil:
+ cdef object cb_info = <object>arg
+ cb_info[0](cb_info[1], line, channel, name, who, sec, nsec, seq, level, msg)
+ return 0
+
+
+class Version(object):
+ """ Version information """
+ def __init__(self, major, minor, extra):
+ self.major = major
+ self.minor = minor
+ self.extra = extra
+
+ def __str__(self):
+ return "%d.%d.%d" % (self.major, self.minor, self.extra)
+
+
+cdef class Rados(object):
+ """This class wraps librados functions"""
+ # NOTE(sileht): attributes declared in .pyd
+
+ def __init__(self, *args, **kwargs):
+ PyEval_InitThreads()
+ self.__setup(*args, **kwargs)
+
+ NO_CONF_FILE = -1
+ "special value that indicates no conffile should be read when creating a mount handle"
+ DEFAULT_CONF_FILES = -2
+ "special value that indicates the default conffiles should be read when creating a mount handle"
+
+ def __setup(self,
+ rados_id: Optional[str] = None,
+ name: Optional[str] = None,
+ clustername: Optional[str] = None,
+ conf_defaults: Optional[Dict[str, str]] = None,
+ conffile: Union[str, int, None] = NO_CONF_FILE,
+ conf: Optional[Dict[str, str]] = None,
+ flags: int = 0,
+ context: object = None):
+ self.monitor_callback = None
+ self.monitor_callback2 = None
+ self.parsed_args = []
+ self.conf_defaults = conf_defaults
+ self.conffile = conffile
+ self.rados_id = rados_id
+
+ if rados_id and name:
+ raise Error("Rados(): can't supply both rados_id and name")
+ elif rados_id:
+ name = 'client.' + rados_id
+ elif name is None:
+ name = 'client.admin'
+ if clustername is None:
+ clustername = ''
+
+ name_raw = cstr(name, 'name')
+ clustername_raw = cstr(clustername, 'clustername')
+ cdef:
+ char *_name = name_raw
+ char *_clustername = clustername_raw
+ int _flags = flags
+ int ret
+
+ if context:
+ # Unpack void* (aka rados_config_t) from capsule
+ rados_config = <rados_config_t> PyCapsule_GetPointer(context, NULL)
+ with nogil:
+ ret = rados_create_with_context(&self.cluster, rados_config)
+ else:
+ with nogil:
+ ret = rados_create2(&self.cluster, _clustername, _name, _flags)
+ if ret != 0:
+ raise Error("rados_initialize failed with error code: %d" % ret)
+
+ self.state = "configuring"
+ # order is important: conf_defaults, then conffile, then conf
+ if conf_defaults:
+ for key, value in conf_defaults.items():
+ self.conf_set(key, value)
+ if conffile in (self.NO_CONF_FILE, None):
+ pass
+ elif conffile in (self.DEFAULT_CONF_FILES, ''):
+ self.conf_read_file(None)
+ else:
+ self.conf_read_file(conffile)
+ if conf:
+ for key, value in conf.items():
+ self.conf_set(key, value)
+
+ def get_addrs(self):
+ """
+ Get associated client addresses with this RADOS session.
+ """
+ self.require_state("configuring", "connected")
+
+ cdef:
+ char* addrs = NULL
+
+ try:
+
+ with nogil:
+ ret = rados_getaddrs(self.cluster, &addrs)
+ if ret:
+ raise make_ex(ret, "error calling getaddrs")
+
+ return decode_cstr(addrs)
+ finally:
+ free(addrs)
+
+ def require_state(self, *args):
+ """
+ Checks if the Rados object is in a special state
+
+ :raises: :class:`RadosStateError`
+ """
+ if self.state in args:
+ return
+ raise RadosStateError("You cannot perform that operation on a \
+Rados object in state %s." % self.state)
+
+ def shutdown(self):
+ """
+ Disconnects from the cluster. Call this explicitly when a
+ Rados.connect()ed object is no longer used.
+ """
+ if self.state != "shutdown":
+ with nogil:
+ rados_shutdown(self.cluster)
+ self.state = "shutdown"
+
+ def __enter__(self):
+ self.connect()
+ return self
+
+ def __exit__(self, type_, value, traceback):
+ self.shutdown()
+ return False
+
+ def version(self) -> Version:
+ """
+ Get the version number of the ``librados`` C library.
+
+ :returns: a tuple of ``(major, minor, extra)`` components of the
+ librados version
+ """
+ cdef int major = 0
+ cdef int minor = 0
+ cdef int extra = 0
+ with nogil:
+ rados_version(&major, &minor, &extra)
+ return Version(major, minor, extra)
+
+ def conf_read_file(self, path: Optional[str] = None):
+ """
+ Configure the cluster handle using a Ceph config file.
+
+ :param path: path to the config file
+ """
+ self.require_state("configuring", "connected")
+ path_raw = cstr(path, 'path', opt=True)
+ cdef:
+ char *_path = opt_str(path_raw)
+ with nogil:
+ ret = rados_conf_read_file(self.cluster, _path)
+ if ret != 0:
+ raise make_ex(ret, "error calling conf_read_file")
+
+ def conf_parse_argv(self, args: Sequence[str]):
+ """
+ Parse known arguments from args, and remove; returned
+ args contain only those unknown to ceph
+ """
+ self.require_state("configuring", "connected")
+ if not args:
+ return
+
+ cargs = cstr_list(args, 'args')
+ cdef:
+ int _argc = len(args)
+ char **_argv = to_bytes_array(cargs)
+ char **_remargv = NULL
+
+ try:
+ _remargv = <char **>malloc(_argc * sizeof(char *))
+ with nogil:
+ ret = rados_conf_parse_argv_remainder(self.cluster, _argc,
+ <const char**>_argv,
+ <const char**>_remargv)
+ if ret:
+ raise make_ex(ret, "error calling conf_parse_argv_remainder")
+
+ # _remargv was allocated with fixed argc; collapse return
+ # list to eliminate any missing args
+ retargs = [decode_cstr(a) for a in _remargv[:_argc]
+ if a != NULL]
+ self.parsed_args = args
+ return retargs
+ finally:
+ free(_argv)
+ free(_remargv)
+
+ def conf_parse_env(self, var: Optional[str] = 'CEPH_ARGS'):
+ """
+ Parse known arguments from an environment variable, normally
+ CEPH_ARGS.
+ """
+ self.require_state("configuring", "connected")
+ if not var:
+ return
+
+ var_raw = cstr(var, 'var')
+ cdef:
+ char *_var = var_raw
+ with nogil:
+ ret = rados_conf_parse_env(self.cluster, _var)
+ if ret != 0:
+ raise make_ex(ret, "error calling conf_parse_env")
+
+ def conf_get(self, option: str) -> Optional[str]:
+ """
+ Get the value of a configuration option
+
+ :param option: which option to read
+
+ :returns: value of the option or None
+ :raises: :class:`TypeError`
+ """
+ self.require_state("configuring", "connected")
+ option_raw = cstr(option, 'option')
+ cdef:
+ char *_option = option_raw
+ size_t length = 20
+ char *ret_buf = NULL
+
+ try:
+ while True:
+ ret_buf = <char *>realloc_chk(ret_buf, length)
+ with nogil:
+ ret = rados_conf_get(self.cluster, _option, ret_buf, length)
+ if ret == 0:
+ return decode_cstr(ret_buf)
+ elif ret == -errno.ENAMETOOLONG:
+ length = length * 2
+ elif ret == -errno.ENOENT:
+ return None
+ else:
+ raise make_ex(ret, "error calling conf_get")
+ finally:
+ free(ret_buf)
+
+ def conf_set(self, option: str, val: str):
+ """
+ Set the value of a configuration option
+
+ :param option: which option to set
+ :param option: value of the option
+
+ :raises: :class:`TypeError`, :class:`ObjectNotFound`
+ """
+ self.require_state("configuring", "connected")
+ option_raw = cstr(option, 'option')
+ val_raw = cstr(val, 'val')
+ cdef:
+ char *_option = option_raw
+ char *_val = val_raw
+
+ with nogil:
+ ret = rados_conf_set(self.cluster, _option, _val)
+ if ret != 0:
+ raise make_ex(ret, "error calling conf_set")
+
+ def ping_monitor(self, mon_id: str):
+ """
+ Ping a monitor to assess liveness
+
+ May be used as a simply way to assess liveness, or to obtain
+ information about the monitor in a simple way even in the
+ absence of quorum.
+
+ :param mon_id: the ID portion of the monitor's name (i.e., mon.<ID>)
+ :returns: the string reply from the monitor
+ """
+
+ self.require_state("configuring", "connected")
+
+ mon_id_raw = cstr(mon_id, 'mon_id')
+ cdef:
+ char *_mon_id = mon_id_raw
+ size_t outstrlen = 0
+ char *outstr
+
+ with nogil:
+ ret = rados_ping_monitor(self.cluster, _mon_id, &outstr, &outstrlen)
+
+ if ret != 0:
+ raise make_ex(ret, "error calling ping_monitor")
+
+ if outstrlen:
+ my_outstr = outstr[:outstrlen]
+ rados_buffer_free(outstr)
+ return decode_cstr(my_outstr)
+
+ def connect(self, timeout: int = 0):
+ """
+ Connect to the cluster. Use shutdown() to release resources.
+
+ :param timeout: Any supplied timeout value is currently ignored.
+ """
+ self.require_state("configuring")
+ # NOTE(sileht): timeout was supported by old python API,
+ # but this is not something available in C API, so ignore
+ # for now and remove it later
+ with nogil:
+ ret = rados_connect(self.cluster)
+ if ret != 0:
+ raise make_ex(ret, "error connecting to the cluster")
+ self.state = "connected"
+
+ def get_instance_id(self) -> int:
+ """
+ Get a global id for current instance
+ """
+ self.require_state("connected")
+ with nogil:
+ ret = rados_get_instance_id(self.cluster)
+ return ret;
+
+ def get_cluster_stats(self) -> Dict[str, int]:
+ """
+ Read usage info about the cluster
+
+ This tells you total space, space used, space available, and number
+ of objects. These are not updated immediately when data is written,
+ they are eventually consistent.
+ :returns: contains the following keys:
+
+ - ``kb`` (int) - total space
+
+ - ``kb_used`` (int) - space used
+
+ - ``kb_avail`` (int) - free space available
+
+ - ``num_objects`` (int) - number of objects
+
+ """
+ cdef:
+ rados_cluster_stat_t stats
+
+ with nogil:
+ ret = rados_cluster_stat(self.cluster, &stats)
+
+ if ret < 0:
+ raise make_ex(
+ ret, "Rados.get_cluster_stats(%s): get_stats failed" % self.rados_id)
+ return {'kb': stats.kb,
+ 'kb_used': stats.kb_used,
+ 'kb_avail': stats.kb_avail,
+ 'num_objects': stats.num_objects}
+
+ def pool_exists(self, pool_name: str) -> bool:
+ """
+ Checks if a given pool exists.
+
+ :param pool_name: name of the pool to check
+
+ :raises: :class:`TypeError`, :class:`Error`
+ :returns: whether the pool exists, false otherwise.
+ """
+ self.require_state("connected")
+
+ pool_name_raw = cstr(pool_name, 'pool_name')
+ cdef:
+ char *_pool_name = pool_name_raw
+
+ with nogil:
+ ret = rados_pool_lookup(self.cluster, _pool_name)
+ if ret >= 0:
+ return True
+ elif ret == -errno.ENOENT:
+ return False
+ else:
+ raise make_ex(ret, "error looking up pool '%s'" % pool_name)
+
+ def pool_lookup(self, pool_name: str) -> int:
+ """
+ Returns a pool's ID based on its name.
+
+ :param pool_name: name of the pool to look up
+
+ :raises: :class:`TypeError`, :class:`Error`
+ :returns: pool ID, or None if it doesn't exist
+ """
+ self.require_state("connected")
+ pool_name_raw = cstr(pool_name, 'pool_name')
+ cdef:
+ char *_pool_name = pool_name_raw
+
+ with nogil:
+ ret = rados_pool_lookup(self.cluster, _pool_name)
+ if ret >= 0:
+ return int(ret)
+ elif ret == -errno.ENOENT:
+ return None
+ else:
+ raise make_ex(ret, "error looking up pool '%s'" % pool_name)
+
+ def pool_reverse_lookup(self, pool_id: int) -> Optional[str]:
+ """
+ Returns a pool's name based on its ID.
+
+ :param pool_id: ID of the pool to look up
+
+ :raises: :class:`TypeError`, :class:`Error`
+ :returns: pool name, or None if it doesn't exist
+ """
+ self.require_state("connected")
+ cdef:
+ int64_t _pool_id = pool_id
+ size_t size = 512
+ char *name = NULL
+
+ try:
+ while True:
+ name = <char *>realloc_chk(name, size)
+ with nogil:
+ ret = rados_pool_reverse_lookup(self.cluster, _pool_id, name, size)
+ if ret >= 0:
+ break
+ elif ret != -errno.ERANGE and size <= 4096:
+ size *= 2
+ elif ret == -errno.ENOENT:
+ return None
+ elif ret < 0:
+ raise make_ex(ret, "error reverse looking up pool '%s'" % pool_id)
+
+ return decode_cstr(name)
+
+ finally:
+ free(name)
+
+ def create_pool(self, pool_name: str,
+ crush_rule: Optional[int] = None,
+ auid: Optional[int] = None):
+ """
+ Create a pool:
+ - with default settings: if crush_rule=None and auid=None
+ - with a specific CRUSH rule: crush_rule given
+ - with a specific auid: auid given
+ - with a specific CRUSH rule and auid: crush_rule and auid given
+
+ :param pool_name: name of the pool to create
+ :param crush_rule: rule to use for placement in the new pool
+ :param auid: id of the owner of the new pool
+
+ :raises: :class:`TypeError`, :class:`Error`
+ """
+ self.require_state("connected")
+
+ pool_name_raw = cstr(pool_name, 'pool_name')
+ cdef:
+ char *_pool_name = pool_name_raw
+ uint8_t _crush_rule
+ uint64_t _auid
+
+ if crush_rule is None and auid is None:
+ with nogil:
+ ret = rados_pool_create(self.cluster, _pool_name)
+ elif crush_rule is not None and auid is None:
+ _crush_rule = crush_rule
+ with nogil:
+ ret = rados_pool_create_with_crush_rule(self.cluster, _pool_name, _crush_rule)
+ elif crush_rule is None and auid is not None:
+ _auid = auid
+ with nogil:
+ ret = rados_pool_create_with_auid(self.cluster, _pool_name, _auid)
+ else:
+ _crush_rule = crush_rule
+ _auid = auid
+ with nogil:
+ ret = rados_pool_create_with_all(self.cluster, _pool_name, _auid, _crush_rule)
+ if ret < 0:
+ raise make_ex(ret, "error creating pool '%s'" % pool_name)
+
+ def get_pool_base_tier(self, pool_id: int) -> int:
+ """
+ Get base pool
+
+ :returns: base pool, or pool_id if tiering is not configured for the pool
+ """
+ self.require_state("connected")
+ cdef:
+ int64_t base_tier = 0
+ int64_t _pool_id = pool_id
+
+ with nogil:
+ ret = rados_pool_get_base_tier(self.cluster, _pool_id, &base_tier)
+ if ret < 0:
+ raise make_ex(ret, "get_pool_base_tier(%d)" % pool_id)
+ return int(base_tier)
+
+ def delete_pool(self, pool_name: str):
+ """
+ Delete a pool and all data inside it.
+
+ The pool is removed from the cluster immediately,
+ but the actual data is deleted in the background.
+
+ :param pool_name: name of the pool to delete
+
+ :raises: :class:`TypeError`, :class:`Error`
+ """
+ self.require_state("connected")
+
+ pool_name_raw = cstr(pool_name, 'pool_name')
+ cdef:
+ char *_pool_name = pool_name_raw
+
+ with nogil:
+ ret = rados_pool_delete(self.cluster, _pool_name)
+ if ret < 0:
+ raise make_ex(ret, "error deleting pool '%s'" % pool_name)
+
+ def get_inconsistent_pgs(self, pool_id: int) -> List[str]:
+ """
+ List inconsistent placement groups in the given pool
+
+ :param pool_id: ID of the pool in which PGs are listed
+ :returns: inconsistent placement groups
+ """
+ self.require_state("connected")
+ cdef:
+ int64_t pool = pool_id
+ size_t size = 512
+ char *pgs = NULL
+
+ try:
+ while True:
+ pgs = <char *>realloc_chk(pgs, size);
+ with nogil:
+ ret = rados_inconsistent_pg_list(self.cluster, pool,
+ pgs, size)
+ if ret > <int>size:
+ size *= 2
+ elif ret >= 0:
+ break
+ else:
+ raise make_ex(ret, "error calling inconsistent_pg_list")
+ return [pg for pg in decode_cstr(pgs[:ret]).split('\0') if pg]
+ finally:
+ free(pgs)
+
+ def list_pools(self) -> List[str]:
+ """
+ Gets a list of pool names.
+
+ :returns: list of pool names.
+ """
+ self.require_state("connected")
+ cdef:
+ size_t size = 512
+ char *c_names = NULL
+
+ try:
+ while True:
+ c_names = <char *>realloc_chk(c_names, size)
+ with nogil:
+ ret = rados_pool_list(self.cluster, c_names, size)
+ if ret > <int>size:
+ size *= 2
+ elif ret >= 0:
+ break
+ return [name for name in decode_cstr(c_names[:ret]).split('\0')
+ if name]
+ finally:
+ free(c_names)
+
+ def get_fsid(self) -> str:
+ """
+ Get the fsid of the cluster as a hexadecimal string.
+
+ :raises: :class:`Error`
+ :returns: cluster fsid
+ """
+ self.require_state("connected")
+ cdef:
+ char *ret_buf = NULL
+ size_t buf_len = 64
+
+ try:
+ while True:
+ ret_buf = <char *>realloc_chk(ret_buf, buf_len)
+ with nogil:
+ ret = rados_cluster_fsid(self.cluster, ret_buf, buf_len)
+ if ret == -errno.ERANGE:
+ buf_len = buf_len * 2
+ elif ret < 0:
+ raise make_ex(ret, "error getting cluster fsid")
+ else:
+ break
+ return decode_cstr(ret_buf)
+ finally:
+ free(ret_buf)
+
+ def open_ioctx(self, ioctx_name: str) -> Ioctx:
+ """
+ Create an io context
+
+ The io context allows you to perform operations within a particular
+ pool.
+
+ :param ioctx_name: name of the pool
+
+ :raises: :class:`TypeError`, :class:`Error`
+ :returns: Rados Ioctx object
+ """
+ self.require_state("connected")
+ ioctx_name_raw = cstr(ioctx_name, 'ioctx_name')
+ cdef:
+ rados_ioctx_t ioctx
+ char *_ioctx_name = ioctx_name_raw
+ with nogil:
+ ret = rados_ioctx_create(self.cluster, _ioctx_name, &ioctx)
+ if ret < 0:
+ raise make_ex(ret, "error opening pool '%s'" % ioctx_name)
+ io = Ioctx(self, ioctx_name)
+ io.io = ioctx
+ return io
+
+ def open_ioctx2(self, pool_id: int) -> Ioctx:
+ """
+ Create an io context
+
+ The io context allows you to perform operations within a particular
+ pool.
+
+ :param pool_id: ID of the pool
+
+ :raises: :class:`TypeError`, :class:`Error`
+ :returns: Rados Ioctx object
+ """
+ self.require_state("connected")
+ cdef:
+ rados_ioctx_t ioctx
+ int64_t _pool_id = pool_id
+ with nogil:
+ ret = rados_ioctx_create2(self.cluster, _pool_id, &ioctx)
+ if ret < 0:
+ raise make_ex(ret, "error opening pool id '%s'" % pool_id)
+ io = Ioctx(self, str(pool_id))
+ io.io = ioctx
+ return io
+
+ def mon_command(self,
+ cmd: str,
+ inbuf: bytes,
+ timeout: int = 0,
+ target: Optional[Union[str, int]] = None) -> Tuple[int, bytes, str]:
+ """
+ Send a command to the mon.
+
+ mon_command[_target](cmd, inbuf, outbuf, outbuflen, outs, outslen)
+
+ :param cmd: JSON formatted string.
+ :param inbuf: optional string.
+ :param timeout: This parameter is ignored.
+ :param target: name or rank of a specific mon. Optional
+ :return: (int ret, string outbuf, string outs)
+
+ Example:
+
+ >>> import json
+ >>> c = Rados(conffile='/etc/ceph/ceph.conf')
+ >>> c.connect()
+ >>> cmd = json.dumps({"prefix": "osd safe-to-destroy", "ids": ["2"], "format": "json"})
+ >>> c.mon_command(cmd, b'')
+ """
+ # NOTE(sileht): timeout is ignored because C API doesn't provide
+ # timeout argument, but we keep it for backward compat with old python binding
+ self.require_state("connected")
+ cmds = [cstr(cmd, 'cmd')]
+
+ if isinstance(target, int):
+ # NOTE(sileht): looks weird but test_monmap_dump pass int
+ target = str(target)
+
+ target = cstr(target, 'target', opt=True)
+
+ cdef:
+ char *_target = opt_str(target)
+ char **_cmd = to_bytes_array(cmds)
+ size_t _cmdlen = len(cmds)
+
+ char *_inbuf = inbuf
+ size_t _inbuf_len = len(inbuf)
+
+ char *_outbuf
+ size_t _outbuf_len
+ char *_outs
+ size_t _outs_len
+
+ try:
+ if target:
+ with nogil:
+ ret = rados_mon_command_target(self.cluster, _target,
+ <const char **>_cmd, _cmdlen,
+ <const char*>_inbuf, _inbuf_len,
+ &_outbuf, &_outbuf_len,
+ &_outs, &_outs_len)
+ else:
+ with nogil:
+ ret = rados_mon_command(self.cluster,
+ <const char **>_cmd, _cmdlen,
+ <const char*>_inbuf, _inbuf_len,
+ &_outbuf, &_outbuf_len,
+ &_outs, &_outs_len)
+
+ my_outs = decode_cstr(_outs[:_outs_len])
+ my_outbuf = _outbuf[:_outbuf_len]
+ if _outs_len:
+ rados_buffer_free(_outs)
+ if _outbuf_len:
+ rados_buffer_free(_outbuf)
+ return (ret, my_outbuf, my_outs)
+ finally:
+ free(_cmd)
+
+ def osd_command(self,
+ osdid: int,
+ cmd: str,
+ inbuf: bytes,
+ timeout: int = 0) -> Tuple[int, bytes, str]:
+ """
+ osd_command(osdid, cmd, inbuf, outbuf, outbuflen, outs, outslen)
+
+ :return: (int ret, string outbuf, string outs)
+ """
+ # NOTE(sileht): timeout is ignored because C API doesn't provide
+ # timeout argument, but we keep it for backward compat with old python binding
+ self.require_state("connected")
+
+ cmds = [cstr(cmd, 'cmd')]
+
+ cdef:
+ int _osdid = osdid
+ char **_cmd = to_bytes_array(cmds)
+ size_t _cmdlen = len(cmds)
+
+ char *_inbuf = inbuf
+ size_t _inbuf_len = len(inbuf)
+
+ char *_outbuf
+ size_t _outbuf_len
+ char *_outs
+ size_t _outs_len
+
+ try:
+ with nogil:
+ ret = rados_osd_command(self.cluster, _osdid,
+ <const char **>_cmd, _cmdlen,
+ <const char*>_inbuf, _inbuf_len,
+ &_outbuf, &_outbuf_len,
+ &_outs, &_outs_len)
+
+ my_outs = decode_cstr(_outs[:_outs_len])
+ my_outbuf = _outbuf[:_outbuf_len]
+ if _outs_len:
+ rados_buffer_free(_outs)
+ if _outbuf_len:
+ rados_buffer_free(_outbuf)
+ return (ret, my_outbuf, my_outs)
+ finally:
+ free(_cmd)
+
+ def mgr_command(self,
+ cmd: str,
+ inbuf: bytes,
+ timeout: int = 0,
+ target: Optional[str] = None) -> Tuple[int, str, bytes]:
+ """
+ :return: (int ret, string outbuf, string outs)
+ """
+ # NOTE(sileht): timeout is ignored because C API doesn't provide
+ # timeout argument, but we keep it for backward compat with old python binding
+ self.require_state("connected")
+
+ cmds = [cstr(cmd, 'cmd')]
+ target = cstr(target, 'target', opt=True)
+
+ cdef:
+ char *_target = opt_str(target)
+
+ char **_cmd = to_bytes_array(cmds)
+ size_t _cmdlen = len(cmds)
+
+ char *_inbuf = inbuf
+ size_t _inbuf_len = len(inbuf)
+
+ char *_outbuf
+ size_t _outbuf_len
+ char *_outs
+ size_t _outs_len
+
+ try:
+ if target is not None:
+ with nogil:
+ ret = rados_mgr_command_target(self.cluster,
+ <const char*>_target,
+ <const char **>_cmd, _cmdlen,
+ <const char*>_inbuf, _inbuf_len,
+ &_outbuf, &_outbuf_len,
+ &_outs, &_outs_len)
+ else:
+ with nogil:
+ ret = rados_mgr_command(self.cluster,
+ <const char **>_cmd, _cmdlen,
+ <const char*>_inbuf, _inbuf_len,
+ &_outbuf, &_outbuf_len,
+ &_outs, &_outs_len)
+
+ my_outs = decode_cstr(_outs[:_outs_len])
+ my_outbuf = _outbuf[:_outbuf_len]
+ if _outs_len:
+ rados_buffer_free(_outs)
+ if _outbuf_len:
+ rados_buffer_free(_outbuf)
+ return (ret, my_outbuf, my_outs)
+ finally:
+ free(_cmd)
+
+ def pg_command(self,
+ pgid: str,
+ cmd: str,
+ inbuf: bytes,
+ timeout: int = 0) -> Tuple[int, bytes, str]:
+ """
+ pg_command(pgid, cmd, inbuf, outbuf, outbuflen, outs, outslen)
+
+ :return: (int ret, string outbuf, string outs)
+ """
+ # NOTE(sileht): timeout is ignored because C API doesn't provide
+ # timeout argument, but we keep it for backward compat with old python binding
+ self.require_state("connected")
+
+ pgid_raw = cstr(pgid, 'pgid')
+ cmds = [cstr(cmd, 'cmd')]
+
+ cdef:
+ char *_pgid = pgid_raw
+ char **_cmd = to_bytes_array(cmds)
+ size_t _cmdlen = len(cmds)
+
+ char *_inbuf = inbuf
+ size_t _inbuf_len = len(inbuf)
+
+ char *_outbuf
+ size_t _outbuf_len
+ char *_outs
+ size_t _outs_len
+
+ try:
+ with nogil:
+ ret = rados_pg_command(self.cluster, _pgid,
+ <const char **>_cmd, _cmdlen,
+ <const char *>_inbuf, _inbuf_len,
+ &_outbuf, &_outbuf_len,
+ &_outs, &_outs_len)
+
+ my_outs = decode_cstr(_outs[:_outs_len])
+ my_outbuf = _outbuf[:_outbuf_len]
+ if _outs_len:
+ rados_buffer_free(_outs)
+ if _outbuf_len:
+ rados_buffer_free(_outbuf)
+ return (ret, my_outbuf, my_outs)
+ finally:
+ free(_cmd)
+
+ def wait_for_latest_osdmap(self) -> int:
+ self.require_state("connected")
+ with nogil:
+ ret = rados_wait_for_latest_osdmap(self.cluster)
+ return ret
+
+ def blocklist_add(self, client_address: str, expire_seconds: int = 0):
+ """
+ Blocklist a client from the OSDs
+
+ :param client_address: client address
+ :param expire_seconds: number of seconds to blocklist
+
+ :raises: :class:`Error`
+ """
+ self.require_state("connected")
+ client_address_raw = cstr(client_address, 'client_address')
+ cdef:
+ uint32_t _expire_seconds = expire_seconds
+ char *_client_address = client_address_raw
+
+ with nogil:
+ ret = rados_blocklist_add(self.cluster, _client_address, _expire_seconds)
+ if ret < 0:
+ raise make_ex(ret, "error blocklisting client '%s'" % client_address)
+
+ def monitor_log(self, level: str,
+ callback: Optional[Callable[[object, str, str, str, int, int, int, str, str], None]] = None,
+ arg: Optional[object] = None):
+ if level not in MONITOR_LEVELS:
+ raise LogicError("invalid monitor level " + level)
+ if callback is not None and not callable(callback):
+ raise LogicError("callback must be a callable function or None")
+
+ level_raw = cstr(level, 'level')
+ cdef char *_level = level_raw
+
+ if callback is None:
+ with nogil:
+ r = rados_monitor_log(self.cluster, <const char*>_level, NULL, NULL)
+ self.monitor_callback = None
+ self.monitor_callback2 = None
+ return
+
+ cb = (callback, arg)
+ cdef PyObject* _arg = <PyObject*>cb
+ with nogil:
+ r = rados_monitor_log(self.cluster, <const char*>_level,
+ <rados_log_callback_t>&__monitor_callback, _arg)
+
+ if r:
+ raise make_ex(r, 'error calling rados_monitor_log')
+ # NOTE(sileht): Prevents the callback method from being garbage collected
+ self.monitor_callback = cb
+ self.monitor_callback2 = None
+
+ def monitor_log2(self, level: str,
+ callback: Optional[Callable[[object, str, str, str, str, int, int, int, str, str], None]] = None,
+ arg: Optional[object] = None):
+ if level not in MONITOR_LEVELS:
+ raise LogicError("invalid monitor level " + level)
+ if callback is not None and not callable(callback):
+ raise LogicError("callback must be a callable function or None")
+
+ level_raw = cstr(level, 'level')
+ cdef char *_level = level_raw
+
+ if callback is None:
+ with nogil:
+ r = rados_monitor_log2(self.cluster, <const char*>_level, NULL, NULL)
+ self.monitor_callback = None
+ self.monitor_callback2 = None
+ return
+
+ cb = (callback, arg)
+ cdef PyObject* _arg = <PyObject*>cb
+ with nogil:
+ r = rados_monitor_log2(self.cluster, <const char*>_level,
+ <rados_log_callback2_t>&__monitor_callback2, _arg)
+
+ if r:
+ raise make_ex(r, 'error calling rados_monitor_log')
+ # NOTE(sileht): Prevents the callback method from being garbage collected
+ self.monitor_callback = None
+ self.monitor_callback2 = cb
+
+ def service_daemon_register(self, service: str, daemon: str, metadata: Dict[str, str]):
+ """
+ :param str service: service name (e.g. "rgw")
+ :param str daemon: daemon name (e.g. "gwfoo")
+ :param dict metadata: static metadata about the register daemon
+ (e.g., the version of Ceph, the kernel version.)
+ """
+ service_raw = cstr(service, 'service')
+ daemon_raw = cstr(daemon, 'daemon')
+ metadata_dict = flatten_dict(metadata, 'metadata')
+ cdef:
+ char *_service = service_raw
+ char *_daemon = daemon_raw
+ char *_metadata = metadata_dict
+
+ with nogil:
+ ret = rados_service_register(self.cluster, _service, _daemon, _metadata)
+ if ret != 0:
+ raise make_ex(ret, "error calling service_register()")
+
+ def service_daemon_update(self, status: Dict[str, str]):
+ status_dict = flatten_dict(status, 'status')
+ cdef:
+ char *_status = status_dict
+
+ with nogil:
+ ret = rados_service_update_status(self.cluster, _status)
+ if ret != 0:
+ raise make_ex(ret, "error calling service_daemon_update()")
+
+
+cdef class OmapIterator(object):
+ """Omap iterator"""
+
+ cdef public Ioctx ioctx
+ cdef public object omap_key_type
+ cdef rados_omap_iter_t ctx
+
+ def __cinit__(self, Ioctx ioctx, omap_key_type):
+ self.ioctx = ioctx
+ self.omap_key_type = omap_key_type
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ """
+ Get the next key-value pair in the object
+ :returns: next rados.OmapItem
+ """
+ cdef:
+ char *key_ = NULL
+ char *val_ = NULL
+ size_t len_
+
+ with nogil:
+ ret = rados_omap_get_next(self.ctx, &key_, &val_, &len_)
+
+ if ret != 0:
+ raise make_ex(ret, "error iterating over the omap")
+ if key_ == NULL:
+ raise StopIteration()
+ key = self.omap_key_type(key_)
+ val = None
+ if val_ != NULL:
+ val = val_[:len_]
+ return (key, val)
+
+ def __dealloc__(self):
+ with nogil:
+ rados_omap_get_end(self.ctx)
+
+
+cdef class ObjectIterator(object):
+ """rados.Ioctx Object iterator"""
+
+ cdef rados_list_ctx_t ctx
+
+ cdef public object ioctx
+
+ def __cinit__(self, Ioctx ioctx):
+ self.ioctx = ioctx
+
+ with nogil:
+ ret = rados_nobjects_list_open(ioctx.io, &self.ctx)
+ if ret < 0:
+ raise make_ex(ret, "error iterating over the objects in ioctx '%s'"
+ % self.ioctx.name)
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ """
+ Get the next object name and locator in the pool
+
+ :raises: StopIteration
+ :returns: next rados.Ioctx Object
+ """
+ cdef:
+ const char *key_ = NULL
+ const char *locator_ = NULL
+ const char *nspace_ = NULL
+ size_t key_size_ = 0
+ size_t locator_size_ = 0
+ size_t nspace_size_ = 0
+
+ with nogil:
+ ret = rados_nobjects_list_next2(self.ctx, &key_, &locator_, &nspace_,
+ &key_size_, &locator_size_, &nspace_size_)
+
+ if ret < 0:
+ raise StopIteration()
+
+ key = decode_cstr(key_[:key_size_])
+ locator = decode_cstr(locator_[:locator_size_]) if locator_ != NULL else None
+ nspace = decode_cstr(nspace_[:nspace_size_]) if nspace_ != NULL else None
+ return Object(self.ioctx, key, locator, nspace)
+
+ def __dealloc__(self):
+ with nogil:
+ rados_nobjects_list_close(self.ctx)
+
+
+cdef class XattrIterator(object):
+ """Extended attribute iterator"""
+
+ cdef rados_xattrs_iter_t it
+ cdef char* _oid
+
+ cdef public Ioctx ioctx
+ cdef public object oid
+
+ def __cinit__(self, Ioctx ioctx, oid):
+ self.ioctx = ioctx
+ self.oid = cstr(oid, 'oid')
+ self._oid = self.oid
+
+ with nogil:
+ ret = rados_getxattrs(ioctx.io, self._oid, &self.it)
+ if ret != 0:
+ raise make_ex(ret, "Failed to get rados xattrs for object %r" % oid)
+
+ def __iter__(self):
+ return self
+
+ def __next__(self):
+ """
+ Get the next xattr on the object
+
+ :raises: StopIteration
+ :returns: pair - of name and value of the next Xattr
+ """
+ cdef:
+ const char *name_ = NULL
+ const char *val_ = NULL
+ size_t len_ = 0
+
+ with nogil:
+ ret = rados_getxattrs_next(self.it, &name_, &val_, &len_)
+ if ret != 0:
+ raise make_ex(ret, "error iterating over the extended attributes \
+in '%s'" % self.oid)
+ if name_ == NULL:
+ raise StopIteration()
+ name = decode_cstr(name_)
+ val = val_[:len_]
+ return (name, val)
+
+ def __dealloc__(self):
+ with nogil:
+ rados_getxattrs_end(self.it)
+
+
+cdef class SnapIterator(object):
+ """Snapshot iterator"""
+
+ cdef public Ioctx ioctx
+
+ cdef rados_snap_t *snaps
+ cdef int max_snap
+ cdef int cur_snap
+
+ def __cinit__(self, Ioctx ioctx):
+ self.ioctx = ioctx
+ # We don't know how big a buffer we need until we've called the
+ # function. So use the exponential doubling strategy.
+ cdef int num_snaps = 10
+ while True:
+ self.snaps = <rados_snap_t*>realloc_chk(self.snaps,
+ num_snaps *
+ sizeof(rados_snap_t))
+
+ with nogil:
+ ret = rados_ioctx_snap_list(ioctx.io, self.snaps, num_snaps)
+ if ret >= 0:
+ self.max_snap = ret
+ break
+ elif ret != -errno.ERANGE:
+ raise make_ex(ret, "error calling rados_snap_list for \
+ioctx '%s'" % self.ioctx.name)
+ num_snaps = num_snaps * 2
+ self.cur_snap = 0
+
+ def __iter__(self) -> 'SnapIterator':
+ return self
+
+ def __next__(self) -> 'Snap':
+ """
+ Get the next Snapshot
+
+ :raises: :class:`Error`, StopIteration
+ :returns: next snapshot
+ """
+ if self.cur_snap >= self.max_snap:
+ raise StopIteration
+
+ cdef:
+ rados_snap_t snap_id = self.snaps[self.cur_snap]
+ int name_len = 10
+ char *name = NULL
+
+ try:
+ while True:
+ name = <char *>realloc_chk(name, name_len)
+ with nogil:
+ ret = rados_ioctx_snap_get_name(self.ioctx.io, snap_id, name, name_len)
+ if ret == 0:
+ break
+ elif ret != -errno.ERANGE:
+ raise make_ex(ret, "rados_snap_get_name error")
+ else:
+ name_len = name_len * 2
+
+ snap = Snap(self.ioctx, decode_cstr(name[:name_len]).rstrip('\0'), snap_id)
+ self.cur_snap = self.cur_snap + 1
+ return snap
+ finally:
+ free(name)
+
+
+cdef class Snap(object):
+ """Snapshot object"""
+ cdef public Ioctx ioctx
+ cdef public object name
+
+ # NOTE(sileht): old API was storing the ctypes object
+ # instead of the value ....
+ cdef public rados_snap_t snap_id
+
+ def __cinit__(self, Ioctx ioctx, object name, rados_snap_t snap_id):
+ self.ioctx = ioctx
+ self.name = name
+ self.snap_id = snap_id
+
+ def __str__(self):
+ return "rados.Snap(ioctx=%s,name=%s,snap_id=%d)" \
+ % (str(self.ioctx), self.name, self.snap_id)
+
+ def get_timestamp(self) -> float:
+ """
+ Find when a snapshot in the current pool occurred
+
+ :raises: :class:`Error`
+ :returns: the data and time the snapshot was created
+ """
+ cdef time_t snap_time
+
+ with nogil:
+ ret = rados_ioctx_snap_get_stamp(self.ioctx.io, self.snap_id, &snap_time)
+ if ret != 0:
+ raise make_ex(ret, "rados_ioctx_snap_get_stamp error")
+ return datetime.fromtimestamp(snap_time)
+
+# https://github.com/cython/cython/issues/1370
+unicode = str
+
+cdef class Completion(object):
+ """completion object"""
+
+ cdef public:
+ Ioctx ioctx
+ object oncomplete
+ object onsafe
+
+ cdef:
+ rados_callback_t complete_cb
+ rados_callback_t safe_cb
+ rados_completion_t rados_comp
+ PyObject* buf
+
+ def __cinit__(self, Ioctx ioctx, object oncomplete, object onsafe):
+ self.oncomplete = oncomplete
+ self.onsafe = onsafe
+ self.ioctx = ioctx
+
+ def is_safe(self) -> bool:
+ """
+ Is an asynchronous operation safe?
+
+ This does not imply that the safe callback has finished.
+
+ :returns: True if the operation is safe
+ """
+ return self.is_complete()
+
+ def is_complete(self) -> bool:
+ """
+ Has an asynchronous operation completed?
+
+ This does not imply that the safe callback has finished.
+
+ :returns: True if the operation is completed
+ """
+ with nogil:
+ ret = rados_aio_is_complete(self.rados_comp)
+ return ret == 1
+
+ def wait_for_safe(self):
+ """
+ Wait for an asynchronous operation to be marked safe
+
+ wait_for_safe() is an alias of wait_for_complete() since Luminous
+ """
+ self.wait_for_complete()
+
+ def wait_for_complete(self):
+ """
+ Wait for an asynchronous operation to complete
+
+ This does not imply that the complete callback has finished.
+ """
+ with nogil:
+ rados_aio_wait_for_complete(self.rados_comp)
+
+ def wait_for_safe_and_cb(self):
+ """
+ Wait for an asynchronous operation to be marked safe and for
+ the safe callback to have returned
+ """
+ return self.wait_for_complete_and_cb()
+
+ def wait_for_complete_and_cb(self):
+ """
+ Wait for an asynchronous operation to complete and for the
+ complete callback to have returned
+
+ :returns: whether the operation is completed
+ """
+ with nogil:
+ ret = rados_aio_wait_for_complete_and_cb(self.rados_comp)
+ return ret
+
+ def get_return_value(self) -> int:
+ """
+ Get the return value of an asychronous operation
+
+ The return value is set when the operation is complete or safe,
+ whichever comes first.
+
+ :returns: return value of the operation
+ """
+ with nogil:
+ ret = rados_aio_get_return_value(self.rados_comp)
+ return ret
+
+ def __dealloc__(self):
+ """
+ Release a completion
+
+ Call this when you no longer need the completion. It may not be
+ freed immediately if the operation is not acked and committed.
+ """
+ ref.Py_XDECREF(self.buf)
+ self.buf = NULL
+ if self.rados_comp != NULL:
+ with nogil:
+ rados_aio_release(self.rados_comp)
+ self.rados_comp = NULL
+
+ def _complete(self):
+ self.oncomplete(self)
+ if self.onsafe:
+ self.onsafe(self)
+ self._cleanup()
+
+ def _cleanup(self):
+ with self.ioctx.lock:
+ if self.oncomplete:
+ self.ioctx.complete_completions.remove(self)
+ if self.onsafe:
+ self.ioctx.safe_completions.remove(self)
+
+
+class OpCtx(object):
+ def __enter__(self):
+ return self.create()
+
+ def __exit__(self, type, msg, traceback):
+ self.release()
+
+
+cdef class WriteOp(object):
+ cdef rados_write_op_t write_op
+
+ def create(self):
+ with nogil:
+ self.write_op = rados_create_write_op()
+ return self
+
+ def release(self):
+ with nogil:
+ rados_release_write_op(self.write_op)
+
+ def new(self, exclusive: Optional[int] = None):
+ """
+ Create the object.
+ """
+
+ cdef:
+ int _exclusive = exclusive
+
+ with nogil:
+ rados_write_op_create(self.write_op, _exclusive, NULL)
+
+
+ def remove(self):
+ """
+ Remove object.
+ """
+ with nogil:
+ rados_write_op_remove(self.write_op)
+
+ def set_flags(self, flags: int = LIBRADOS_OPERATION_NOFLAG):
+ """
+ Set flags for the last operation added to this write_op.
+ :para flags: flags to apply to the last operation
+ """
+
+ cdef:
+ int _flags = flags
+
+ with nogil:
+ rados_write_op_set_flags(self.write_op, _flags)
+
+ def set_xattr(self, xattr_name: str, xattr_value: bytes):
+ """
+ Set an extended attribute on an object.
+ :param xattr_name: name of the xattr
+ :param xattr_value: buffer to set xattr to
+ """
+ xattr_name_raw = cstr(xattr_name, 'xattr_name')
+ cdef:
+ char *_xattr_name = xattr_name_raw
+ char *_xattr_value = xattr_value
+ size_t _xattr_value_len = len(xattr_value)
+ with nogil:
+ rados_write_op_setxattr(self.write_op, _xattr_name, _xattr_value, _xattr_value_len)
+
+ def rm_xattr(self, xattr_name: str):
+ """
+ Removes an extended attribute on from an object.
+ :param xattr_name: name of the xattr to remove
+ """
+ xattr_name_raw = cstr(xattr_name, 'xattr_name')
+ cdef:
+ char *_xattr_name = xattr_name_raw
+ with nogil:
+ rados_write_op_rmxattr(self.write_op, _xattr_name)
+
+ def append(self, to_write: bytes):
+ """
+ Append data to an object synchronously
+ :param to_write: data to write
+ """
+
+ cdef:
+ char *_to_write = to_write
+ size_t length = len(to_write)
+
+ with nogil:
+ rados_write_op_append(self.write_op, _to_write, length)
+
+ def write_full(self, to_write: bytes):
+ """
+ Write whole object, atomically replacing it.
+ :param to_write: data to write
+ """
+
+ cdef:
+ char *_to_write = to_write
+ size_t length = len(to_write)
+
+ with nogil:
+ rados_write_op_write_full(self.write_op, _to_write, length)
+
+ def write(self, to_write: bytes, offset: int = 0):
+ """
+ Write to offset.
+ :param to_write: data to write
+ :param offset: byte offset in the object to begin writing at
+ """
+
+ cdef:
+ char *_to_write = to_write
+ size_t length = len(to_write)
+ uint64_t _offset = offset
+
+ with nogil:
+ rados_write_op_write(self.write_op, _to_write, length, _offset)
+
+ def assert_version(self, version: int):
+ """
+ Check if object's version is the expected one.
+ :param version: expected version of the object
+ :param type: int
+ """
+ cdef:
+ uint64_t _version = version
+
+ with nogil:
+ rados_write_op_assert_version(self.write_op, _version)
+
+ def zero(self, offset: int, length: int):
+ """
+ Zero part of an object.
+ :param offset: byte offset in the object to begin writing at
+ :param offset: number of zero to write
+ """
+
+ cdef:
+ size_t _length = length
+ uint64_t _offset = offset
+
+ with nogil:
+ rados_write_op_zero(self.write_op, _length, _offset)
+
+ def truncate(self, offset: int):
+ """
+ Truncate an object.
+ :param offset: byte offset in the object to begin truncating at
+ """
+
+ cdef:
+ uint64_t _offset = offset
+
+ with nogil:
+ rados_write_op_truncate(self.write_op, _offset)
+
+ def execute(self, cls: str, method: str, data: bytes):
+ """
+ Execute an OSD class method on an object
+
+ :param cls: name of the object class
+ :param method: name of the method
+ :param data: input data
+ """
+
+ cls_raw = cstr(cls, 'cls')
+ method_raw = cstr(method, 'method')
+ cdef:
+ char *_cls = cls_raw
+ char *_method = method_raw
+ char *_data = data
+ size_t _data_len = len(data)
+
+ with nogil:
+ rados_write_op_exec(self.write_op, _cls, _method, _data, _data_len, NULL)
+
+ def writesame(self, to_write: bytes, write_len: int, offset: int = 0):
+ """
+ Write the same buffer multiple times
+ :param to_write: data to write
+ :param write_len: total number of bytes to write
+ :param offset: byte offset in the object to begin writing at
+ """
+ cdef:
+ char *_to_write = to_write
+ size_t _data_len = len(to_write)
+ size_t _write_len = write_len
+ uint64_t _offset = offset
+ with nogil:
+ rados_write_op_writesame(self.write_op, _to_write, _data_len, _write_len, _offset)
+
+ def cmpext(self, cmp_buf: bytes, offset: int = 0):
+ """
+ Ensure that given object range (extent) satisfies comparison
+ :param cmp_buf: buffer containing bytes to be compared with object contents
+ :param offset: object byte offset at which to start the comparison
+ """
+ cdef:
+ char *_cmp_buf = cmp_buf
+ size_t _cmp_buf_len = len(cmp_buf)
+ uint64_t _offset = offset
+ with nogil:
+ rados_write_op_cmpext(self.write_op, _cmp_buf, _cmp_buf_len, _offset, NULL)
+
+ def omap_cmp(self, key: OMAP_KEY_TYPE, val: OMAP_KEY_TYPE, cmp_op: int = LIBRADOS_CMPXATTR_OP_EQ):
+ """
+ Ensure that an omap key value satisfies comparison
+ :param key: omap key whose associated value is evaluated for comparison
+ :param val: value to compare with
+ :param cmp_op: comparison operator, one of LIBRADOS_CMPXATTR_OP_EQ (1),
+ LIBRADOS_CMPXATTR_OP_GT (3), or LIBRADOS_CMPXATTR_OP_LT (5).
+ """
+ key_raw = cstr(key, 'key')
+ val_raw = cstr(val, 'val')
+ cdef:
+ char *_key = key_raw
+ char *_val = val_raw
+ size_t _val_len = len(val)
+ uint8_t _comparison_operator = cmp_op
+ with nogil:
+ rados_write_op_omap_cmp(self.write_op, _key, _comparison_operator, _val, _val_len, NULL)
+
+class WriteOpCtx(WriteOp, OpCtx):
+ """write operation context manager"""
+
+
+cdef class ReadOp(object):
+ cdef rados_read_op_t read_op
+
+ def create(self):
+ with nogil:
+ self.read_op = rados_create_read_op()
+ return self
+
+ def release(self):
+ with nogil:
+ rados_release_read_op(self.read_op)
+
+ def cmpext(self, cmp_buf: bytes, offset: int = 0):
+ """
+ Ensure that given object range (extent) satisfies comparison
+ :param cmp_buf: buffer containing bytes to be compared with object contents
+ :param offset: object byte offset at which to start the comparison
+ """
+ cdef:
+ char *_cmp_buf = cmp_buf
+ size_t _cmp_buf_len = len(cmp_buf)
+ uint64_t _offset = offset
+ with nogil:
+ rados_read_op_cmpext(self.read_op, _cmp_buf, _cmp_buf_len, _offset, NULL)
+
+ def set_flags(self, flags: int = LIBRADOS_OPERATION_NOFLAG):
+ """
+ Set flags for the last operation added to this read_op.
+ :para flags: flags to apply to the last operation
+ """
+
+ cdef:
+ int _flags = flags
+
+ with nogil:
+ rados_read_op_set_flags(self.read_op, _flags)
+
+
+class ReadOpCtx(ReadOp, OpCtx):
+ """read operation context manager"""
+
+
+cdef void __watch_callback(void *_arg, int64_t _notify_id, uint64_t _cookie,
+ uint64_t _notifier_id, void *_data,
+ size_t _data_len) with gil:
+ """
+ Watch callback
+ """
+ cdef object watch = <object>_arg
+ data = None
+ if _data != NULL:
+ data = (<char *>_data)[:_data_len]
+ watch._callback(_notify_id, _notifier_id, _cookie, data)
+
+cdef void __watch_error_callback(void *_arg, uint64_t _cookie,
+ int _error) with gil:
+ """
+ Watch error callback
+ """
+ cdef object watch = <object>_arg
+ watch._error_callback(_cookie, _error)
+
+
+cdef class Watch(object):
+ """watch object"""
+
+ cdef:
+ object id
+ Ioctx ioctx
+ object oid
+ object callback
+ object error_callback
+
+ def __cinit__(self, Ioctx ioctx, object oid, object callback,
+ object error_callback, object timeout):
+ self.id = 0
+ self.ioctx = ioctx.dup()
+ self.oid = cstr(oid, 'oid')
+ self.callback = callback
+ self.error_callback = error_callback
+
+ if timeout is None:
+ timeout = 0
+
+ cdef:
+ char *_oid = self.oid
+ uint64_t _cookie;
+ uint32_t _timeout = timeout;
+ void *_args = <PyObject*>self
+
+ with nogil:
+ ret = rados_watch3(self.ioctx.io, _oid, &_cookie,
+ <rados_watchcb2_t>&__watch_callback,
+ <rados_watcherrcb_t>&__watch_error_callback,
+ _timeout, _args)
+ if ret < 0:
+ raise make_ex(ret, "watch error")
+
+ self.id = int(_cookie);
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, type_, value, traceback):
+ self.close()
+ return False
+
+ def __dealloc__(self):
+ if self.id == 0:
+ return
+ self.ioctx.rados.require_state("connected")
+ self.close()
+
+ def _callback(self, notify_id, notifier_id, watch_id, data):
+ replay = self.callback(notify_id, notifier_id, watch_id, data)
+
+ cdef:
+ rados_ioctx_t _io = <rados_ioctx_t>self.ioctx.io
+ char *_obj = self.oid
+ int64_t _notify_id = notify_id
+ uint64_t _cookie = watch_id
+ char *_replay = NULL
+ int _replay_len = 0
+
+ if replay is not None:
+ replay = cstr(replay, 'replay')
+ _replay = replay
+ _replaylen = len(replay)
+
+ with nogil:
+ rados_notify_ack(_io, _obj, _notify_id, _cookie, _replay,
+ _replaylen)
+
+ def _error_callback(self, watch_id, error):
+ if self.error_callback is None:
+ return
+ self.error_callback(watch_id, error)
+
+ def get_id(self) -> int:
+ return self.id
+
+ def check(self):
+ """
+ Check on watch validity.
+
+ :raises: :class:`Error`
+ :returns: timedelta since last confirmed valid
+ """
+ self.ioctx.require_ioctx_open()
+
+ cdef:
+ uint64_t _cookie = self.id
+
+ with nogil:
+ ret = rados_watch_check(self.ioctx.io, _cookie)
+ if ret < 0:
+ raise make_ex(ret, "check error")
+
+ return timedelta(milliseconds=ret)
+
+ def close(self):
+ """
+ Unregister an interest in an object.
+
+ :raises: :class:`Error`
+ """
+ if self.id == 0:
+ return
+
+ self.ioctx.require_ioctx_open()
+
+ cdef:
+ uint64_t _cookie = self.id
+
+ with nogil:
+ ret = rados_unwatch2(self.ioctx.io, _cookie)
+ if ret < 0 and ret != -errno.ENOENT:
+ raise make_ex(ret, "unwatch error")
+ self.id = 0
+
+ with nogil:
+ cluster = rados_ioctx_get_cluster(self.ioctx.io)
+ ret = rados_watch_flush(cluster);
+ if ret < 0:
+ raise make_ex(ret, "watch_flush error")
+
+ self.ioctx.close()
+
+
+cdef int __aio_complete_cb(rados_completion_t completion, void *args) with gil:
+ """
+ Callback to oncomplete() for asynchronous operations
+ """
+ cdef object cb = <object>args
+ cb._complete()
+ return 0
+
+cdef class Ioctx(object):
+ """rados.Ioctx object"""
+ # NOTE(sileht): attributes declared in .pyd
+
+ def __init__(self, rados, name):
+ self.rados = rados
+ self.name = name
+ self.state = "open"
+
+ self.locator_key = ""
+ self.nspace = ""
+ self.lock = threading.Lock()
+ self.safe_completions = []
+ self.complete_completions = []
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, type_, value, traceback):
+ self.close()
+ return False
+
+ def __dealloc__(self):
+ self.close()
+
+ def __track_completion(self, completion_obj):
+ if completion_obj.oncomplete:
+ with self.lock:
+ self.complete_completions.append(completion_obj)
+ if completion_obj.onsafe:
+ with self.lock:
+ self.safe_completions.append(completion_obj)
+
+ def __get_completion(self,
+ oncomplete: Callable[[Completion], None],
+ onsafe: Callable[[Completion], None]):
+ """
+ Constructs a completion to use with asynchronous operations
+
+ :param oncomplete: what to do when the write is safe and complete in memory
+ on all replicas
+ :param onsafe: what to do when the write is safe and complete on storage
+ on all replicas
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ completion_obj = Completion(self, oncomplete, onsafe)
+
+ cdef:
+ rados_callback_t complete_cb = NULL
+ rados_completion_t completion
+ PyObject* p_completion_obj= <PyObject*>completion_obj
+
+ if oncomplete:
+ complete_cb = <rados_callback_t>&__aio_complete_cb
+
+ with nogil:
+ ret = rados_aio_create_completion2(p_completion_obj, complete_cb,
+ &completion)
+ if ret < 0:
+ raise make_ex(ret, "error getting a completion")
+
+ completion_obj.rados_comp = completion
+ return completion_obj
+
+ def dup(self):
+ """
+ Duplicate IoCtx
+ """
+
+ ioctx = self.rados.open_ioctx2(self.get_pool_id())
+ ioctx.set_namespace(self.get_namespace())
+ return ioctx
+
+ def aio_stat(self,
+ object_name: str,
+ oncomplete: Callable[[Completion, Optional[int], Optional[time.struct_time]], None]) -> Completion:
+ """
+ Asynchronously get object stats (size/mtime)
+
+ oncomplete will be called with the returned size and mtime
+ as well as the completion:
+
+ oncomplete(completion, size, mtime)
+
+ :param object_name: the name of the object to get stats from
+ :param oncomplete: what to do when the stat is complete
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char *_object_name = object_name_raw
+ uint64_t psize
+ time_t pmtime
+
+ def oncomplete_(completion_v):
+ cdef Completion _completion_v = completion_v
+ return_value = _completion_v.get_return_value()
+ if return_value >= 0:
+ return oncomplete(_completion_v, psize, time.localtime(pmtime))
+ else:
+ return oncomplete(_completion_v, None, None)
+
+ completion = self.__get_completion(oncomplete_, None)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_stat(self.io, _object_name, completion.rados_comp,
+ &psize, &pmtime)
+
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error stating %s" % object_name)
+ return completion
+
+ def aio_write(self, object_name: str, to_write: bytes, offset: int = 0,
+ oncomplete: Optional[Callable[[Completion], None]] = None,
+ onsafe: Optional[Callable[[Completion], None]] = None) -> Completion:
+ """
+ Write data to an object asynchronously
+
+ Queues the write and returns.
+
+ :param object_name: name of the object
+ :param to_write: data to write
+ :param offset: byte offset in the object to begin writing at
+ :param oncomplete: what to do when the write is safe and complete in memory
+ on all replicas
+ :param onsafe: what to do when the write is safe and complete on storage
+ on all replicas
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ char* _to_write = to_write
+ size_t size = len(to_write)
+ uint64_t _offset = offset
+
+ completion = self.__get_completion(oncomplete, onsafe)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_write(self.io, _object_name, completion.rados_comp,
+ _to_write, size, _offset)
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error writing object %s" % object_name)
+ return completion
+
+ def aio_write_full(self, object_name: str, to_write: bytes,
+ oncomplete: Optional[Callable] = None,
+ onsafe: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously write an entire object
+
+ The object is filled with the provided data. If the object exists,
+ it is atomically truncated and then written.
+ Queues the write and returns.
+
+ :param object_name: name of the object
+ :param to_write: data to write
+ :param oncomplete: what to do when the write is safe and complete in memory
+ on all replicas
+ :param onsafe: what to do when the write is safe and complete on storage
+ on all replicas
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ char* _to_write = to_write
+ size_t size = len(to_write)
+
+ completion = self.__get_completion(oncomplete, onsafe)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_write_full(self.io, _object_name,
+ completion.rados_comp,
+ _to_write, size)
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error writing object %s" % object_name)
+ return completion
+
+ def aio_writesame(self, object_name: str, to_write: bytes,
+ write_len: int, offset: int = 0,
+ oncomplete: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously write the same buffer multiple times
+
+ :param object_name: name of the object
+ :param to_write: data to write
+ :param write_len: total number of bytes to write
+ :param offset: byte offset in the object to begin writing at
+ :param oncomplete: what to do when the writesame is safe and
+ complete in memory on all replicas
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ char* _to_write = to_write
+ size_t _data_len = len(to_write)
+ size_t _write_len = write_len
+ uint64_t _offset = offset
+
+ completion = self.__get_completion(oncomplete, None)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_writesame(self.io, _object_name, completion.rados_comp,
+ _to_write, _data_len, _write_len, _offset)
+
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error writing object %s" % object_name)
+ return completion
+
+ def aio_append(self, object_name: str, to_append: bytes,
+ oncomplete: Optional[Callable] = None,
+ onsafe: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously append data to an object
+
+ Queues the write and returns.
+
+ :param object_name: name of the object
+ :param to_append: data to append
+ :param offset: byte offset in the object to begin writing at
+ :param oncomplete: what to do when the write is safe and complete in memory
+ on all replicas
+ :param onsafe: what to do when the write is safe and complete on storage
+ on all replicas
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ char* _to_append = to_append
+ size_t size = len(to_append)
+
+ completion = self.__get_completion(oncomplete, onsafe)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_append(self.io, _object_name,
+ completion.rados_comp,
+ _to_append, size)
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error appending object %s" % object_name)
+ return completion
+
+ def aio_flush(self):
+ """
+ Block until all pending writes in an io context are safe
+
+ :raises: :class:`Error`
+ """
+ with nogil:
+ ret = rados_aio_flush(self.io)
+ if ret < 0:
+ raise make_ex(ret, "error flushing")
+
+ def aio_cmpext(self, object_name: str, cmp_buf: bytes, offset: int = 0,
+ oncomplete: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously compare an on-disk object range with a buffer
+ :param object_name: the name of the object
+ :param cmp_buf: buffer containing bytes to be compared with object contents
+ :param offset: object byte offset at which to start the comparison
+ :param oncomplete: what to do when the write is safe and complete in memory
+ on all replicas
+
+ :raises: :class:`TypeError`
+ returns: 0 - on success, negative error code on failure,
+ (-MAX_ERRNO - mismatch_off) on mismatch
+ """
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ char* _cmp_buf = cmp_buf
+ size_t _cmp_buf_len = len(cmp_buf)
+ uint64_t _offset = offset
+
+ completion = self.__get_completion(oncomplete, None)
+ self.__track_completion(completion)
+
+ with nogil:
+ ret = rados_aio_cmpext(self.io, _object_name, completion.rados_comp,
+ _cmp_buf, _cmp_buf_len, _offset)
+
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "failed to compare %s" % object_name)
+ return completion
+
+ def aio_rmxattr(self, object_name: str, xattr_name: str,
+ oncomplete: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously delete an extended attribute from an object
+
+ :param object_name: the name of the object to remove xattr from
+ :param xattr_name: which extended attribute to remove
+ :param oncomplete: what to do when the rmxattr completes
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+ object_name_raw = cstr(object_name, 'object_name')
+ xattr_name_raw = cstr(xattr_name , 'xattr_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ char* _xattr_name = xattr_name_raw
+
+ completion = self.__get_completion(oncomplete, None)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_rmxattr(self.io, _object_name,
+ completion.rados_comp, _xattr_name)
+
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "Failed to remove xattr %r" % xattr_name)
+ return completion
+
+ def aio_read(self, object_name: str, length: int, offset: int,
+ oncomplete: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously read data from an object
+
+ oncomplete will be called with the returned read value as
+ well as the completion:
+
+ oncomplete(completion, data_read)
+
+ :param object_name: name of the object to read from
+ :param length: the number of bytes to read
+ :param offset: byte offset in the object to begin reading from
+ :param oncomplete: what to do when the read is complete
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ uint64_t _offset = offset
+
+ char *ref_buf
+ size_t _length = length
+
+ 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_, None)
+ completion.buf = PyBytes_FromStringAndSize(NULL, length)
+ ret_buf = PyBytes_AsString(completion.buf)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_read(self.io, _object_name, completion.rados_comp,
+ ret_buf, _length, _offset)
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error reading %s" % object_name)
+ return completion
+
+ def aio_execute(self, object_name: str, cls: str, method: str,
+ data: bytes, length: int = 8192,
+ oncomplete: Optional[Callable[[Completion, bytes], None]] = None,
+ onsafe: Optional[Callable[[Completion, bytes], None]] = None) -> Completion:
+ """
+ Asynchronously execute an OSD class method on an object.
+
+ oncomplete and onsafe will be called with the data returned from
+ the plugin as well as the completion:
+
+ oncomplete(completion, data)
+ onsafe(completion, data)
+
+ :param object_name: name of the object
+ :param cls: name of the object class
+ :param method: name of the method
+ :param data: input data
+ :param length: size of output buffer in bytes (default=8192)
+ :param oncomplete: what to do when the execution is complete
+ :param onsafe: what to do when the execution is safe and complete
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ object_name_raw = cstr(object_name, 'object_name')
+ cls_raw = cstr(cls, 'cls')
+ method_raw = cstr(method, 'method')
+ cdef:
+ Completion completion
+ char *_object_name = object_name_raw
+ char *_cls = cls_raw
+ char *_method = method_raw
+ char *_data = data
+ size_t _data_len = len(data)
+
+ char *ref_buf
+ size_t _length = length
+
+ 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)
+
+ def onsafe_(completion_v):
+ cdef Completion _completion_v = completion_v
+ return_value = _completion_v.get_return_value()
+ return onsafe(_completion_v, <object>_completion_v.buf if return_value >= 0 else None)
+
+ completion = self.__get_completion(oncomplete_ if oncomplete else None, onsafe_ if onsafe else None)
+ completion.buf = PyBytes_FromStringAndSize(NULL, length)
+ ret_buf = PyBytes_AsString(completion.buf)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_exec(self.io, _object_name, completion.rados_comp,
+ _cls, _method, _data, _data_len, ret_buf, _length)
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error executing %s::%s on %s" % (cls, method, object_name))
+ return completion
+
+ def aio_setxattr(self, object_name: str, xattr_name: str, xattr_value: bytes,
+ oncomplete: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously set an extended attribute on an object
+
+ :param object_name: the name of the object to set xattr to
+ :param xattr_name: which extended attribute to set
+ :param xattr_value: the value of the extended attribute
+ :param oncomplete: what to do when the setxttr completes
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+ object_name_raw = cstr(object_name, 'object_name')
+ xattr_name_raw = cstr(xattr_name , 'xattr_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+ char* _xattr_name = xattr_name_raw
+ char* _xattr_value = xattr_value
+ size_t xattr_value_len = len(xattr_value)
+
+ completion = self.__get_completion(oncomplete, None)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_setxattr(self.io, _object_name,
+ completion.rados_comp,
+ _xattr_name, _xattr_value, xattr_value_len)
+
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "Failed to set xattr %r" % xattr_name)
+ return completion
+
+ def aio_remove(self, object_name: str,
+ oncomplete: Optional[Callable] = None,
+ onsafe: Optional[Callable] = None) -> Completion:
+ """
+ Asynchronously remove an object
+
+ :param object_name: name of the object to remove
+ :param oncomplete: what to do when the remove is safe and complete in memory
+ on all replicas
+ :param onsafe: what to do when the remove is safe and complete on storage
+ on all replicas
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+ object_name_raw = cstr(object_name, 'object_name')
+
+ cdef:
+ Completion completion
+ char* _object_name = object_name_raw
+
+ completion = self.__get_completion(oncomplete, onsafe)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_remove(self.io, _object_name,
+ completion.rados_comp)
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "error removing %s" % object_name)
+ return completion
+
+ def require_ioctx_open(self):
+ """
+ Checks if the rados.Ioctx object state is 'open'
+
+ :raises: IoctxStateError
+ """
+ if self.state != "open":
+ raise IoctxStateError("The pool is %s" % self.state)
+
+ def set_locator_key(self, loc_key: str):
+ """
+ Set the key for mapping objects to pgs within an io context.
+
+ The key is used instead of the object name to determine which
+ placement groups an object is put in. This affects all subsequent
+ operations of the io context - until a different locator key is
+ set, all objects in this io context will be placed in the same pg.
+
+ :param loc_key: the key to use as the object locator, or NULL to discard
+ any previously set key
+
+ :raises: :class:`TypeError`
+ """
+ self.require_ioctx_open()
+ cloc_key = cstr(loc_key, 'loc_key')
+ cdef char *_loc_key = cloc_key
+ with nogil:
+ rados_ioctx_locator_set_key(self.io, _loc_key)
+ self.locator_key = loc_key
+
+ def get_locator_key(self) -> str:
+ """
+ Get the locator_key of context
+
+ :returns: locator_key
+ """
+ return self.locator_key
+
+ def set_read(self, snap_id: int):
+ """
+ Set the snapshot for reading objects.
+
+ To stop to read from snapshot, use set_read(LIBRADOS_SNAP_HEAD)
+
+ :param snap_id: the snapshot Id
+
+ :raises: :class:`TypeError`
+ """
+ self.require_ioctx_open()
+ cdef rados_snap_t _snap_id = snap_id
+ with nogil:
+ rados_ioctx_snap_set_read(self.io, _snap_id)
+
+ def set_namespace(self, nspace: str):
+ """
+ Set the namespace for objects within an io context.
+
+ The namespace in addition to the object name fully identifies
+ an object. This affects all subsequent operations of the io context
+ - until a different namespace is set, all objects in this io context
+ will be placed in the same namespace.
+
+ :param nspace: the namespace to use, or None/"" for the default namespace
+
+ :raises: :class:`TypeError`
+ """
+ self.require_ioctx_open()
+ if nspace is None:
+ nspace = ""
+ cnspace = cstr(nspace, 'nspace')
+ cdef char *_nspace = cnspace
+ with nogil:
+ rados_ioctx_set_namespace(self.io, _nspace)
+ self.nspace = nspace
+
+ def get_namespace(self) -> str:
+ """
+ Get the namespace of context
+
+ :returns: namespace
+ """
+ return self.nspace
+
+ def close(self):
+ """
+ Close a rados.Ioctx object.
+
+ This just tells librados that you no longer need to use the io context.
+ It may not be freed immediately if there are pending asynchronous
+ requests on it, but you should not use an io context again after
+ calling this function on it.
+ """
+ if self.state == "open":
+ self.require_ioctx_open()
+ with nogil:
+ rados_ioctx_destroy(self.io)
+ self.state = "closed"
+
+
+ def write(self, key: str, data: bytes, offset: int = 0):
+ """
+ Write data to an object synchronously
+
+ :param key: name of the object
+ :param data: data to write
+ :param offset: byte offset in the object to begin writing at
+
+ :raises: :class:`TypeError`
+ :raises: :class:`LogicError`
+ :returns: int - 0 on success
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ char *_data = data
+ size_t length = len(data)
+ uint64_t _offset = offset
+
+ with nogil:
+ ret = rados_write(self.io, _key, _data, length, _offset)
+ if ret == 0:
+ return ret
+ elif ret < 0:
+ raise make_ex(ret, "Ioctx.write(%s): failed to write %s"
+ % (self.name, key))
+ else:
+ raise LogicError("Ioctx.write(%s): rados_write \
+returned %d, but should return zero on success." % (self.name, ret))
+
+ def write_full(self, key: str, data: bytes):
+ """
+ Write an entire object synchronously.
+
+ The object is filled with the provided data. If the object exists,
+ it is atomically truncated and then written.
+
+ :param key: name of the object
+ :param data: data to write
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: int - 0 on success
+ """
+ self.require_ioctx_open()
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ char *_data = data
+ size_t length = len(data)
+
+ with nogil:
+ ret = rados_write_full(self.io, _key, _data, length)
+ if ret == 0:
+ return ret
+ elif ret < 0:
+ raise make_ex(ret, "Ioctx.write_full(%s): failed to write %s"
+ % (self.name, key))
+ else:
+ raise LogicError("Ioctx.write_full(%s): rados_write_full \
+returned %d, but should return zero on success." % (self.name, ret))
+
+ def writesame(self, key: str, data: bytes, write_len: int, offset: int = 0):
+ """
+ Write the same buffer multiple times
+ :param key: name of the object
+ :param data: data to write
+ :param write_len: total number of bytes to write
+ :param offset: byte offset in the object to begin writing at
+
+ :raises: :class:`TypeError`
+ :raises: :class:`LogicError`
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ char *_data = data
+ size_t _data_len = len(data)
+ size_t _write_len = write_len
+ uint64_t _offset = offset
+
+ with nogil:
+ ret = rados_writesame(self.io, _key, _data, _data_len, _write_len, _offset)
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.writesame(%s): failed to write %s"
+ % (self.name, key))
+ assert(ret == 0)
+
+ def append(self, key: str, data: bytes):
+ """
+ Append data to an object synchronously
+
+ :param key: name of the object
+ :param data: data to write
+
+ :raises: :class:`TypeError`
+ :raises: :class:`LogicError`
+ :returns: int - 0 on success
+ """
+ self.require_ioctx_open()
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ char *_data = data
+ size_t length = len(data)
+
+ with nogil:
+ ret = rados_append(self.io, _key, _data, length)
+ if ret == 0:
+ return ret
+ elif ret < 0:
+ raise make_ex(ret, "Ioctx.append(%s): failed to append %s"
+ % (self.name, key))
+ else:
+ raise LogicError("Ioctx.append(%s): rados_append \
+returned %d, but should return zero on success." % (self.name, ret))
+
+ def read(self, key: str, length: int = 8192, offset: int = 0) -> bytes:
+ """
+ Read data from an object synchronously
+
+ :param key: name of the object
+ :param length: the number of bytes to read (default=8192)
+ :param offset: byte offset in the object to begin reading at
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: data read from object
+ """
+ self.require_ioctx_open()
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ char *ret_buf
+ uint64_t _offset = offset
+ size_t _length = length
+ PyObject* ret_s = NULL
+
+ ret_s = PyBytes_FromStringAndSize(NULL, length)
+ try:
+ ret_buf = PyBytes_AsString(ret_s)
+ with nogil:
+ ret = rados_read(self.io, _key, ret_buf, _length, _offset)
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.read(%s): failed to read %s" % (self.name, key))
+
+ if ret != 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 execute(self, key: str, cls: str, method: str, data: bytes, length: int = 8192) -> Tuple[int, object]:
+ """
+ Execute an OSD class method on an object.
+
+ :param key: name of the object
+ :param cls: name of the object class
+ :param method: name of the method
+ :param data: input data
+ :param length: size of output buffer in bytes (default=8192)
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: (ret, method output)
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ cls_raw = cstr(cls, 'cls')
+ method_raw = cstr(method, 'method')
+ cdef:
+ char *_key = key_raw
+ char *_cls = cls_raw
+ char *_method = method_raw
+ char *_data = data
+ size_t _data_len = len(data)
+
+ char *ref_buf
+ size_t _length = length
+ PyObject* ret_s = NULL
+
+ ret_s = PyBytes_FromStringAndSize(NULL, length)
+ try:
+ ret_buf = PyBytes_AsString(ret_s)
+ with nogil:
+ ret = rados_exec(self.io, _key, _cls, _method, _data,
+ _data_len, ret_buf, _length)
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.read(%s): failed to read %s" % (self.name, key))
+
+ if ret != length:
+ _PyBytes_Resize(&ret_s, ret)
+
+ return ret, <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 get_stats(self) -> Dict[str, int]:
+ """
+ Get pool usage statistics
+
+ :returns: dict contains the following keys:
+
+ - ``num_bytes`` (int) - size of pool in bytes
+
+ - ``num_kb`` (int) - size of pool in kbytes
+
+ - ``num_objects`` (int) - number of objects in the pool
+
+ - ``num_object_clones`` (int) - number of object clones
+
+ - ``num_object_copies`` (int) - number of object copies
+
+ - ``num_objects_missing_on_primary`` (int) - number of objects
+ missing on primary
+
+ - ``num_objects_unfound`` (int) - number of unfound objects
+
+ - ``num_objects_degraded`` (int) - number of degraded objects
+
+ - ``num_rd`` (int) - bytes read
+
+ - ``num_rd_kb`` (int) - kbytes read
+
+ - ``num_wr`` (int) - bytes written
+
+ - ``num_wr_kb`` (int) - kbytes written
+ """
+ self.require_ioctx_open()
+ cdef rados_pool_stat_t stats
+ with nogil:
+ ret = rados_ioctx_pool_stat(self.io, &stats)
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.get_stats(%s): get_stats failed" % self.name)
+ return {'num_bytes': stats.num_bytes,
+ 'num_kb': stats.num_kb,
+ 'num_objects': stats.num_objects,
+ 'num_object_clones': stats.num_object_clones,
+ 'num_object_copies': stats.num_object_copies,
+ "num_objects_missing_on_primary": stats.num_objects_missing_on_primary,
+ "num_objects_unfound": stats.num_objects_unfound,
+ "num_objects_degraded": stats.num_objects_degraded,
+ "num_rd": stats.num_rd,
+ "num_rd_kb": stats.num_rd_kb,
+ "num_wr": stats.num_wr,
+ "num_wr_kb": stats.num_wr_kb}
+
+ def remove_object(self, key: str) -> bool:
+ """
+ Delete an object
+
+ This does not delete any snapshots of the object.
+
+ :param key: the name of the object to delete
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: True on success
+ """
+ self.require_ioctx_open()
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+
+ with nogil:
+ ret = rados_remove(self.io, _key)
+ if ret < 0:
+ raise make_ex(ret, "Failed to remove '%s'" % key)
+ return True
+
+ def trunc(self, key: str, size: int) -> int:
+ """
+ Resize an object
+
+ If this enlarges the object, the new area is logically filled with
+ zeroes. If this shrinks the object, the excess data is removed.
+
+ :param key: the name of the object to resize
+ :param size: the new size of the object in bytes
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: 0 on success, otherwise raises error
+ """
+
+ self.require_ioctx_open()
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ uint64_t _size = size
+
+ with nogil:
+ ret = rados_trunc(self.io, _key, _size)
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.trunc(%s): failed to truncate %s" % (self.name, key))
+ return ret
+
+ def cmpext(self, key: str, cmp_buf: bytes, offset: int = 0) -> int:
+ '''
+ Compare an on-disk object range with a buffer
+ :param key: the name of the object
+ :param cmp_buf: buffer containing bytes to be compared with object contents
+ :param offset: object byte offset at which to start the comparison
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: 0 - on success, negative error code on failure,
+ (-MAX_ERRNO - mismatch_off) on mismatch
+ '''
+ self.require_ioctx_open()
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ char *_cmp_buf = cmp_buf
+ size_t _cmp_buf_len = len(cmp_buf)
+ uint64_t _offset = offset
+ with nogil:
+ ret = rados_cmpext(self.io, _key, _cmp_buf, _cmp_buf_len, _offset)
+ assert ret < -MAX_ERRNO or ret == 0, "Ioctx.cmpext(%s): failed to compare %s" % (self.name, key)
+ return ret
+
+ def stat(self, key: str) -> Tuple[int, time.struct_time]:
+ """
+ Get object stats (size/mtime)
+
+ :param key: the name of the object to get stats from
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: (size,timestamp)
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_key = key_raw
+ uint64_t psize
+ time_t pmtime
+
+ with nogil:
+ ret = rados_stat(self.io, _key, &psize, &pmtime)
+ if ret < 0:
+ raise make_ex(ret, "Failed to stat %r" % key)
+ return psize, time.localtime(pmtime)
+
+ def get_xattr(self, key: str, xattr_name: str) -> bytes:
+ """
+ Get the value of an extended attribute on an object.
+
+ :param key: the name of the object to get xattr from
+ :param xattr_name: which extended attribute to read
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: value of the xattr
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ xattr_name_raw = cstr(xattr_name, 'xattr_name')
+ cdef:
+ char *_key = key_raw
+ char *_xattr_name = xattr_name_raw
+ size_t ret_length = 4096
+ char *ret_buf = NULL
+
+ try:
+ while ret_length < 4096 * 1024 * 1024:
+ ret_buf = <char *>realloc_chk(ret_buf, ret_length)
+ with nogil:
+ ret = rados_getxattr(self.io, _key, _xattr_name, ret_buf, ret_length)
+ if ret == -errno.ERANGE:
+ ret_length *= 2
+ elif ret < 0:
+ raise make_ex(ret, "Failed to get xattr %r" % xattr_name)
+ else:
+ break
+ return ret_buf[:ret]
+ finally:
+ free(ret_buf)
+
+ def get_xattrs(self, oid: str) -> XattrIterator:
+ """
+ Start iterating over xattrs on an object.
+
+ :param oid: the name of the object to get xattrs from
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: XattrIterator
+ """
+ self.require_ioctx_open()
+ return XattrIterator(self, oid)
+
+ def set_xattr(self, key: str, xattr_name: str, xattr_value: bytes) -> bool:
+ """
+ Set an extended attribute on an object.
+
+ :param key: the name of the object to set xattr to
+ :param xattr_name: which extended attribute to set
+ :param xattr_value: the value of the extended attribute
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: True on success, otherwise raise an error
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ xattr_name_raw = cstr(xattr_name, 'xattr_name')
+ cdef:
+ char *_key = key_raw
+ char *_xattr_name = xattr_name_raw
+ char *_xattr_value = xattr_value
+ size_t _xattr_value_len = len(xattr_value)
+
+ with nogil:
+ ret = rados_setxattr(self.io, _key, _xattr_name,
+ _xattr_value, _xattr_value_len)
+ if ret < 0:
+ raise make_ex(ret, "Failed to set xattr %r" % xattr_name)
+ return True
+
+ def rm_xattr(self, key: str, xattr_name: str) -> bool:
+ """
+ Removes an extended attribute on from an object.
+
+ :param key: the name of the object to remove xattr from
+ :param xattr_name: which extended attribute to remove
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: True on success, otherwise raise an error
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ xattr_name_raw = cstr(xattr_name, 'xattr_name')
+ cdef:
+ char *_key = key_raw
+ char *_xattr_name = xattr_name_raw
+
+ with nogil:
+ ret = rados_rmxattr(self.io, _key, _xattr_name)
+ if ret < 0:
+ raise make_ex(ret, "Failed to delete key %r xattr %r" %
+ (key, xattr_name))
+ return True
+
+ def notify(self, obj: str, msg: str = '', timeout_ms: int = 5000) -> bool:
+ """
+ Send a rados notification to an object.
+
+ :param obj: the name of the object to notify
+ :param msg: optional message to send in the notification
+ :param timeout_ms: notify timeout (in ms)
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: True on success, otherwise raise an error
+ """
+ self.require_ioctx_open()
+
+ msglen = len(msg)
+ obj_raw = cstr(obj, 'obj')
+ msg_raw = cstr(msg, 'msg')
+ cdef:
+ char *_obj = obj_raw
+ char *_msg = msg_raw
+ int _msglen = msglen
+ uint64_t _timeout_ms = timeout_ms
+
+ with nogil:
+ ret = rados_notify2(self.io, _obj, _msg, _msglen, _timeout_ms,
+ NULL, NULL)
+ if ret < 0:
+ raise make_ex(ret, "Failed to notify %r" % (obj))
+ return True
+
+ def aio_notify(self, obj: str,
+ oncomplete: Callable[[Completion, int, Optional[List], Optional[List]], None],
+ msg: str = '', timeout_ms: int = 5000) -> Completion:
+ """
+ Asynchronously send a rados notification to an object
+ """
+ self.require_ioctx_open()
+
+ msglen = len(msg)
+ obj_raw = cstr(obj, 'obj')
+ msg_raw = cstr(msg, 'msg')
+
+ cdef:
+ Completion completion
+ char *_obj = obj_raw
+ char *_msg = msg_raw
+ int _msglen = msglen
+ uint64_t _timeout_ms = timeout_ms
+ char *reply
+ size_t replylen = 0
+
+ def oncomplete_(completion_v):
+ cdef:
+ Completion _completion_v = completion_v
+ notify_ack_t *acks = NULL
+ notify_timeout_t *timeouts = NULL
+ size_t nr_acks
+ size_t nr_timeouts
+ return_value = _completion_v.get_return_value()
+ if return_value == 0:
+ return_value = rados_decode_notify_response(reply, replylen, &acks, &nr_acks, &timeouts, &nr_timeouts)
+ rados_buffer_free(reply)
+ if return_value == 0:
+ ack_list = [(ack.notifier_id, ack.cookie, '' if not ack.payload_len \
+ else ack.payload[:ack.payload_len]) for ack in acks[:nr_acks]]
+ timeout_list = [(timeout.notifier_id, timeout.cookie) for timeout in timeouts[:nr_timeouts]]
+ rados_free_notify_response(acks, nr_acks, timeouts)
+ return oncomplete(_completion_v, 0, ack_list, timeout_list)
+ else:
+ return oncomplete(_completion_v, return_value, None, None)
+
+ completion = self.__get_completion(oncomplete_, None)
+ self.__track_completion(completion)
+ with nogil:
+ ret = rados_aio_notify(self.io, _obj, completion.rados_comp,
+ _msg, _msglen, _timeout_ms, &reply, &replylen)
+ if ret < 0:
+ completion._cleanup()
+ raise make_ex(ret, "aio_notify error: %s" % obj)
+ return completion
+
+ def watch(self, obj: str,
+ callback: Callable[[int, str, int, bytes], None],
+ error_callback: Optional[Callable[[int], None]] = None,
+ timeout: Optional[int] = None) -> Watch:
+ """
+ Register an interest in an object.
+
+ :param obj: the name of the object to notify
+ :param callback: what to do when a notify is received on this object
+ :param error_callback: what to do when the watch session encounters an error
+ :param timeout: how many seconds the connection will keep after disconnection
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: watch_id - internal id assigned to this watch
+ """
+ self.require_ioctx_open()
+
+ return Watch(self, obj, callback, error_callback, timeout)
+
+ def list_objects(self) -> ObjectIterator:
+ """
+ Get ObjectIterator on rados.Ioctx object.
+
+ :returns: ObjectIterator
+ """
+ self.require_ioctx_open()
+ return ObjectIterator(self)
+
+ def list_snaps(self) -> SnapIterator:
+ """
+ Get SnapIterator on rados.Ioctx object.
+
+ :returns: SnapIterator
+ """
+ self.require_ioctx_open()
+ return SnapIterator(self)
+
+ def get_pool_id(self) -> int:
+ """
+ Get pool id
+
+ :returns: int - pool id
+ """
+ with nogil:
+ ret = rados_ioctx_get_id(self.io)
+ return ret;
+
+ def get_pool_name(self) -> str:
+ """
+ Get pool name
+
+ :returns: pool name
+ """
+ cdef:
+ int name_len = 10
+ char *name = NULL
+
+ try:
+ while True:
+ name = <char *>realloc_chk(name, name_len)
+ with nogil:
+ ret = rados_ioctx_get_pool_name(self.io, name, name_len)
+ if ret > 0:
+ break
+ elif ret != -errno.ERANGE:
+ raise make_ex(ret, "get pool name error")
+ else:
+ name_len = name_len * 2
+
+ return decode_cstr(name)
+ finally:
+ free(name)
+
+
+ def create_snap(self, snap_name: str):
+ """
+ Create a pool-wide snapshot
+
+ :param snap_name: the name of the snapshot
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+ snap_name_raw = cstr(snap_name, 'snap_name')
+ cdef char *_snap_name = snap_name_raw
+
+ with nogil:
+ ret = rados_ioctx_snap_create(self.io, _snap_name)
+ if ret != 0:
+ raise make_ex(ret, "Failed to create snap %s" % snap_name)
+
+ def remove_snap(self, snap_name: str):
+ """
+ Removes a pool-wide snapshot
+
+ :param snap_name: the name of the snapshot
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+ snap_name_raw = cstr(snap_name, 'snap_name')
+ cdef char *_snap_name = snap_name_raw
+
+ with nogil:
+ ret = rados_ioctx_snap_remove(self.io, _snap_name)
+ if ret != 0:
+ raise make_ex(ret, "Failed to remove snap %s" % snap_name)
+
+ def lookup_snap(self, snap_name: str) -> Snap:
+ """
+ Get the id of a pool snapshot
+
+ :param snap_name: the name of the snapshot to lookop
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ :returns: Snap - on success
+ """
+ self.require_ioctx_open()
+ csnap_name = cstr(snap_name, 'snap_name')
+ cdef:
+ char *_snap_name = csnap_name
+ rados_snap_t snap_id
+
+ with nogil:
+ ret = rados_ioctx_snap_lookup(self.io, _snap_name, &snap_id)
+ if ret != 0:
+ raise make_ex(ret, "Failed to lookup snap %s" % snap_name)
+ return Snap(self, snap_name, int(snap_id))
+
+ def snap_rollback(self, oid: str, snap_name: str):
+ """
+ Rollback an object to a snapshot
+
+ :param oid: the name of the object
+ :param snap_name: the name of the snapshot
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+ oid_raw = cstr(oid, 'oid')
+ snap_name_raw = cstr(snap_name, 'snap_name')
+ cdef:
+ char *_oid = oid_raw
+ char *_snap_name = snap_name_raw
+
+ with nogil:
+ ret = rados_ioctx_snap_rollback(self.io, _oid, _snap_name)
+ if ret != 0:
+ raise make_ex(ret, "Failed to rollback %s" % oid)
+
+ def create_self_managed_snap(self):
+ """
+ Creates a self-managed snapshot
+
+ :returns: snap id on success
+
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+ cdef:
+ rados_snap_t _snap_id
+ with nogil:
+ ret = rados_ioctx_selfmanaged_snap_create(self.io, &_snap_id)
+ if ret != 0:
+ raise make_ex(ret, "Failed to create self-managed snapshot")
+ return int(_snap_id)
+
+ def remove_self_managed_snap(self, snap_id: int):
+ """
+ Removes a self-managed snapshot
+
+ :param snap_id: the name of the snapshot
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+ cdef:
+ rados_snap_t _snap_id = snap_id
+ with nogil:
+ ret = rados_ioctx_selfmanaged_snap_remove(self.io, _snap_id)
+ if ret != 0:
+ raise make_ex(ret, "Failed to remove self-managed snapshot")
+
+ def set_self_managed_snap_write(self, snaps: Sequence[Union[int, str]]):
+ """
+ Updates the write context to the specified self-managed
+ snapshot ids.
+
+ :param snaps: all associated self-managed snapshot ids
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+ sorted_snaps = []
+ snap_seq = 0
+ if snaps:
+ sorted_snaps = sorted([int(x) for x in snaps], reverse=True)
+ snap_seq = sorted_snaps[0]
+
+ cdef:
+ rados_snap_t _snap_seq = snap_seq
+ rados_snap_t *_snaps = NULL
+ int _num_snaps = len(sorted_snaps)
+ try:
+ _snaps = <rados_snap_t *>malloc(_num_snaps * sizeof(rados_snap_t))
+ for i in range(len(sorted_snaps)):
+ _snaps[i] = sorted_snaps[i]
+ with nogil:
+ ret = rados_ioctx_selfmanaged_snap_set_write_ctx(self.io,
+ _snap_seq,
+ _snaps,
+ _num_snaps)
+ if ret != 0:
+ raise make_ex(ret, "Failed to update snapshot write context")
+ finally:
+ free(_snaps)
+
+ def rollback_self_managed_snap(self, oid: str, snap_id: int):
+ """
+ Rolls an specific object back to a self-managed snapshot revision
+
+ :param oid: the name of the object
+ :param snap_id: the name of the snapshot
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+ oid_raw = cstr(oid, 'oid')
+ cdef:
+ char *_oid = oid_raw
+ rados_snap_t _snap_id = snap_id
+ with nogil:
+ ret = rados_ioctx_selfmanaged_snap_rollback(self.io, _oid, _snap_id)
+ if ret != 0:
+ raise make_ex(ret, "Failed to rollback %s" % oid)
+
+ def get_last_version(self) -> int:
+ """
+ Return the version of the last object read or written to.
+
+ This exposes the internal version number of the last object read or
+ written via this io context
+
+ :returns: version of the last object used
+ """
+ self.require_ioctx_open()
+ with nogil:
+ ret = rados_get_last_version(self.io)
+ return int(ret)
+
+ def create_write_op(self) -> WriteOp:
+ """
+ create write operation object.
+ need call release_write_op after use
+ """
+ return WriteOp().create()
+
+ def create_read_op(self) -> ReadOp:
+ """
+ create read operation object.
+ need call release_read_op after use
+ """
+ return ReadOp().create()
+
+ def release_write_op(self, write_op):
+ """
+ release memory alloc by create_write_op
+ """
+ write_op.release()
+
+ def release_read_op(self, read_op: ReadOp):
+ """
+ release memory alloc by create_read_op
+ :para read_op: read_op object
+ """
+ read_op.release()
+
+ def set_omap(self, write_op: WriteOp, keys: Sequence[OMAP_KEY_TYPE], values: Sequence[bytes]):
+ """
+ set keys values to write_op
+ :para write_op: write_operation object
+ :para keys: a tuple of keys
+ :para values: a tuple of values
+ """
+
+ if len(keys) != len(values):
+ raise Error("Rados(): keys and values must have the same number of items")
+
+ keys = cstr_list(keys, 'keys')
+ values = cstr_list(values, 'values')
+ lens = [len(v) for v in values]
+ cdef:
+ WriteOp _write_op = write_op
+ size_t key_num = len(keys)
+ char **_keys = to_bytes_array(keys)
+ char **_values = to_bytes_array(values)
+ size_t *_lens = to_csize_t_array(lens)
+
+ try:
+ with nogil:
+ rados_write_op_omap_set(_write_op.write_op,
+ <const char**>_keys,
+ <const char**>_values,
+ <const size_t*>_lens, key_num)
+ finally:
+ free(_keys)
+ free(_values)
+ free(_lens)
+
+ def operate_write_op(self,
+ write_op: WriteOp,
+ oid: str,
+ mtime: int = 0,
+ flags: int = LIBRADOS_OPERATION_NOFLAG):
+ """
+ execute the real write operation
+ :para write_op: write operation object
+ :para oid: object name
+ :para mtime: the time to set the mtime to, 0 for the current time
+ :para flags: flags to apply to the entire operation
+ """
+
+ oid_raw = cstr(oid, 'oid')
+ cdef:
+ WriteOp _write_op = write_op
+ char *_oid = oid_raw
+ time_t _mtime = mtime
+ int _flags = flags
+
+ with nogil:
+ ret = rados_write_op_operate(_write_op.write_op, self.io, _oid, &_mtime, _flags)
+ if ret != 0:
+ raise make_ex(ret, "Failed to operate write op for oid %s" % oid)
+
+ def operate_aio_write_op(self, write_op: WriteOp, oid: str,
+ oncomplete: Optional[Callable[[Completion], None]] = None,
+ onsafe: Optional[Callable[[Completion], None]] = None,
+ mtime: int = 0,
+ flags: int = LIBRADOS_OPERATION_NOFLAG) -> Completion:
+ """
+ execute the real write operation asynchronously
+ :para write_op: write operation object
+ :para oid: object name
+ :param oncomplete: what to do when the remove is safe and complete in memory
+ on all replicas
+ :param onsafe: what to do when the remove is safe and complete on storage
+ on all replicas
+ :para mtime: the time to set the mtime to, 0 for the current time
+ :para flags: flags to apply to the entire operation
+
+ :raises: :class:`Error`
+ :returns: completion object
+ """
+
+ oid_raw = cstr(oid, 'oid')
+ cdef:
+ WriteOp _write_op = write_op
+ char *_oid = oid_raw
+ Completion completion
+ time_t _mtime = mtime
+ int _flags = flags
+
+ completion = self.__get_completion(oncomplete, onsafe)
+ self.__track_completion(completion)
+
+ with nogil:
+ ret = rados_aio_write_op_operate(_write_op.write_op, self.io, completion.rados_comp, _oid,
+ &_mtime, _flags)
+ if ret != 0:
+ completion._cleanup()
+ raise make_ex(ret, "Failed to operate aio write op for oid %s" % oid)
+ return completion
+
+ def operate_read_op(self, read_op: ReadOp, oid: str, flag: int = LIBRADOS_OPERATION_NOFLAG):
+ """
+ execute the real read operation
+ :para read_op: read operation object
+ :para oid: object name
+ :para flag: flags to apply to the entire operation
+ """
+ oid_raw = cstr(oid, 'oid')
+ cdef:
+ ReadOp _read_op = read_op
+ char *_oid = oid_raw
+ int _flag = flag
+
+ with nogil:
+ ret = rados_read_op_operate(_read_op.read_op, self.io, _oid, _flag)
+ if ret != 0:
+ raise make_ex(ret, "Failed to operate read op for oid %s" % oid)
+
+ def operate_aio_read_op(self, read_op: ReadOp, oid: str,
+ oncomplete: Optional[Callable[[Completion], None]] = None,
+ onsafe: Optional[Callable[[Completion], None]] = None,
+ flag: int = LIBRADOS_OPERATION_NOFLAG) -> Completion:
+ """
+ execute the real read operation
+ :para read_op: read operation object
+ :para oid: object name
+ :param oncomplete: what to do when the remove is safe and complete in memory
+ on all replicas
+ :param onsafe: what to do when the remove is safe and complete on storage
+ on all replicas
+ :para flag: flags to apply to the entire operation
+ """
+ oid_raw = cstr(oid, 'oid')
+ cdef:
+ ReadOp _read_op = read_op
+ char *_oid = oid_raw
+ Completion completion
+ int _flag = flag
+
+ completion = self.__get_completion(oncomplete, onsafe)
+ self.__track_completion(completion)
+
+ with nogil:
+ ret = rados_aio_read_op_operate(_read_op.read_op, self.io, completion.rados_comp, _oid, _flag)
+ if ret != 0:
+ completion._cleanup()
+ raise make_ex(ret, "Failed to operate aio read op for oid %s" % oid)
+ return completion
+
+ def get_omap_vals(self,
+ read_op: ReadOp,
+ start_after: OMAP_KEY_TYPE,
+ filter_prefix: OMAP_KEY_TYPE,
+ max_return: int,
+ omap_key_type = bytes.decode) -> Tuple[OmapIterator, int]:
+ """
+ get the omap values
+ :para read_op: read operation object
+ :para start_after: list keys starting after start_after
+ :para filter_prefix: list only keys beginning with filter_prefix
+ :para max_return: list no more than max_return key/value pairs
+ :returns: an iterator over the requested omap values, return value from this action
+ """
+
+ start_after_raw = cstr(start_after, 'start_after') if start_after else None
+ filter_prefix_raw = cstr(filter_prefix, 'filter_prefix') if filter_prefix else None
+ cdef:
+ char *_start_after = opt_str(start_after_raw)
+ char *_filter_prefix = opt_str(filter_prefix_raw)
+ ReadOp _read_op = read_op
+ rados_omap_iter_t iter_addr = NULL
+ int _max_return = max_return
+
+ with nogil:
+ rados_read_op_omap_get_vals2(_read_op.read_op, _start_after, _filter_prefix,
+ _max_return, &iter_addr, NULL, NULL)
+ it = OmapIterator(self, omap_key_type)
+ it.ctx = iter_addr
+ return it, 0 # 0 is meaningless; there for backward-compat
+
+ def get_omap_keys(self,
+ read_op: ReadOp,
+ start_after: OMAP_KEY_TYPE,
+ max_return: int,
+ omap_key_type = bytes.decode) -> Tuple[OmapIterator, int]:
+ """
+ get the omap keys
+ :para read_op: read operation object
+ :para start_after: list keys starting after start_after
+ :para max_return: list no more than max_return key/value pairs
+ :returns: an iterator over the requested omap values, return value from this action
+ """
+ start_after = cstr(start_after, 'start_after') if start_after else None
+ cdef:
+ char *_start_after = opt_str(start_after)
+ ReadOp _read_op = read_op
+ rados_omap_iter_t iter_addr = NULL
+ int _max_return = max_return
+
+ with nogil:
+ rados_read_op_omap_get_keys2(_read_op.read_op, _start_after,
+ _max_return, &iter_addr, NULL, NULL)
+ it = OmapIterator(self, omap_key_type)
+ it.ctx = iter_addr
+ return it, 0 # 0 is meaningless; there for backward-compat
+
+ def get_omap_vals_by_keys(self,
+ read_op: ReadOp,
+ keys: Sequence[OMAP_KEY_TYPE],
+ omap_key_type = bytes.decode) -> Tuple[OmapIterator, int]:
+ """
+ get the omap values by keys
+ :para read_op: read operation object
+ :para keys: input key tuple
+ :returns: an iterator over the requested omap values, return value from this action
+ """
+ keys = cstr_list(keys, 'keys')
+ cdef:
+ ReadOp _read_op = read_op
+ rados_omap_iter_t iter_addr
+ char **_keys = to_bytes_array(keys)
+ size_t key_num = len(keys)
+
+ try:
+ with nogil:
+ rados_read_op_omap_get_vals_by_keys(_read_op.read_op,
+ <const char**>_keys,
+ key_num, &iter_addr, NULL)
+ it = OmapIterator(self, omap_key_type)
+ it.ctx = iter_addr
+ return it, 0 # 0 is meaningless; there for backward-compat
+ finally:
+ free(_keys)
+
+ def remove_omap_keys(self, write_op: WriteOp, keys: Sequence[OMAP_KEY_TYPE]):
+ """
+ remove omap keys specifiled
+ :para write_op: write operation object
+ :para keys: input key tuple
+ """
+
+ keys = cstr_list(keys, 'keys')
+ cdef:
+ WriteOp _write_op = write_op
+ size_t key_num = len(keys)
+ char **_keys = to_bytes_array(keys)
+
+ try:
+ with nogil:
+ rados_write_op_omap_rm_keys(_write_op.write_op, <const char**>_keys, key_num)
+ finally:
+ free(_keys)
+
+ def clear_omap(self, write_op: WriteOp):
+ """
+ Remove all key/value pairs from an object
+ :para write_op: write operation object
+ """
+
+ cdef:
+ WriteOp _write_op = write_op
+
+ with nogil:
+ rados_write_op_omap_clear(_write_op.write_op)
+
+ def remove_omap_range2(self, write_op: WriteOp, key_begin: OMAP_KEY_TYPE, key_end: OMAP_KEY_TYPE):
+ """
+ Remove key/value pairs from an object whose keys are in the range
+ [key_begin, key_end)
+ :param write_op: write operation object
+ :param key_begin: the lower bound of the key range to remove
+ :param key_end: the upper bound of the key range to remove
+ """
+ key_begin_raw = cstr(key_begin, 'key_begin')
+ key_end_raw = cstr(key_end, 'key_end')
+ cdef:
+ WriteOp _write_op = write_op
+ char* _key_begin = key_begin_raw
+ size_t key_begin_len = len(key_begin)
+ char* _key_end = key_end_raw
+ size_t key_end_len = len(key_end)
+ with nogil:
+ rados_write_op_omap_rm_range2(_write_op.write_op, _key_begin, key_begin_len,
+ _key_end, key_end_len)
+
+ def lock_exclusive(self, key: str, name: str, cookie: str, desc: str = "",
+ duration: Optional[int] = None,
+ flags: int = 0):
+
+ """
+ Take an exclusive lock on an object
+
+ :param key: name of the object
+ :param name: name of the lock
+ :param cookie: cookie of the lock
+ :param desc: description of the lock
+ :param duration: duration of the lock in seconds
+ :param flags: flags
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ name_raw = cstr(name, 'name')
+ cookie_raw = cstr(cookie, 'cookie')
+ desc_raw = cstr(desc, 'desc')
+
+ cdef:
+ char* _key = key_raw
+ char* _name = name_raw
+ char* _cookie = cookie_raw
+ char* _desc = desc_raw
+ uint8_t _flags = flags
+ timeval _duration
+
+ if duration is None:
+ with nogil:
+ ret = rados_lock_exclusive(self.io, _key, _name, _cookie, _desc,
+ NULL, _flags)
+ else:
+ _duration.tv_sec = duration
+ with nogil:
+ ret = rados_lock_exclusive(self.io, _key, _name, _cookie, _desc,
+ &_duration, _flags)
+
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.rados_lock_exclusive(%s): failed to set lock %s on %s" % (self.name, name, key))
+
+ def lock_shared(self, key: str, name: str, cookie: str, tag: str, desc: str = "",
+ duration: Optional[int] = None,
+ flags: int = 0):
+
+ """
+ Take a shared lock on an object
+
+ :param key: name of the object
+ :param name: name of the lock
+ :param cookie: cookie of the lock
+ :param tag: tag of the lock
+ :param desc: description of the lock
+ :param duration: duration of the lock in seconds
+ :param flags: flags
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ tag_raw = cstr(tag, 'tag')
+ name_raw = cstr(name, 'name')
+ cookie_raw = cstr(cookie, 'cookie')
+ desc_raw = cstr(desc, 'desc')
+
+ cdef:
+ char* _key = key_raw
+ char* _tag = tag_raw
+ char* _name = name_raw
+ char* _cookie = cookie_raw
+ char* _desc = desc_raw
+ uint8_t _flags = flags
+ timeval _duration
+
+ if duration is None:
+ with nogil:
+ ret = rados_lock_shared(self.io, _key, _name, _cookie, _tag, _desc,
+ NULL, _flags)
+ else:
+ _duration.tv_sec = duration
+ with nogil:
+ ret = rados_lock_shared(self.io, _key, _name, _cookie, _tag, _desc,
+ &_duration, _flags)
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.rados_lock_exclusive(%s): failed to set lock %s on %s" % (self.name, name, key))
+
+ def unlock(self, key: str, name: str, cookie: str):
+
+ """
+ Release a shared or exclusive lock on an object
+
+ :param key: name of the object
+ :param name: name of the lock
+ :param cookie: cookie of the lock
+
+ :raises: :class:`TypeError`
+ :raises: :class:`Error`
+ """
+ self.require_ioctx_open()
+
+ key_raw = cstr(key, 'key')
+ name_raw = cstr(name, 'name')
+ cookie_raw = cstr(cookie, 'cookie')
+
+ cdef:
+ char* _key = key_raw
+ char* _name = name_raw
+ char* _cookie = cookie_raw
+
+ with nogil:
+ ret = rados_unlock(self.io, _key, _name, _cookie)
+ if ret < 0:
+ raise make_ex(ret, "Ioctx.rados_lock_exclusive(%s): failed to set lock %s on %s" % (self.name, name, key))
+
+ def set_osdmap_full_try(self):
+ """
+ Set global osdmap_full_try label to true
+ """
+ with nogil:
+ rados_set_pool_full_try(self.io)
+
+ def unset_osdmap_full_try(self):
+ """
+ Unset
+ """
+ with nogil:
+ rados_unset_pool_full_try(self.io)
+
+ def application_enable(self, app_name: str, force: bool = False):
+ """
+ Enable an application on an OSD pool
+
+ :param app_name: application name
+ :type app_name: str
+ :param force: False if only a single app should exist per pool
+ :type expire_seconds: boool
+
+ :raises: :class:`Error`
+ """
+ app_name_raw = cstr(app_name, 'app_name')
+ cdef:
+ char *_app_name = app_name_raw
+ int _force = (1 if force else 0)
+
+ with nogil:
+ ret = rados_application_enable(self.io, _app_name, _force)
+ if ret < 0:
+ raise make_ex(ret, "error enabling application")
+
+ def application_list(self) -> List[str]:
+ """
+ Returns a list of enabled applications
+
+ :returns: list of app name string
+ """
+ cdef:
+ size_t length = 128
+ char *apps = NULL
+
+ try:
+ while True:
+ apps = <char *>realloc_chk(apps, length)
+ with nogil:
+ ret = rados_application_list(self.io, apps, &length)
+ if ret == 0:
+ return [decode_cstr(app) for app in
+ apps[:length].split(b'\0') if app]
+ elif ret == -errno.ENOENT:
+ return None
+ elif ret == -errno.ERANGE:
+ pass
+ else:
+ raise make_ex(ret, "error listing applications")
+ finally:
+ free(apps)
+
+ def application_metadata_get(self, app_name: str, key: str) -> str:
+ """
+ Gets application metadata on an OSD pool for the given key
+
+ :param app_name: application name
+ :type app_name: str
+ :param key: metadata key
+ :type key: str
+ :returns: str - metadata value
+
+ :raises: :class:`Error`
+ """
+
+ app_name_raw = cstr(app_name, 'app_name')
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_app_name = app_name_raw
+ char *_key = key_raw
+ size_t size = 129
+ char *value = NULL
+ int ret
+ try:
+ while True:
+ value = <char *>realloc_chk(value, size)
+ with nogil:
+ ret = rados_application_metadata_get(self.io, _app_name,
+ _key, value, &size)
+ if ret != -errno.ERANGE:
+ break
+ if ret == -errno.ENOENT:
+ raise KeyError('no metadata %s for application %s' % (key, _app_name))
+ elif ret != 0:
+ raise make_ex(ret, 'error getting metadata %s for application %s' %
+ (key, _app_name))
+ return decode_cstr(value)
+ finally:
+ free(value)
+
+ def application_metadata_set(self, app_name: str, key: str, value: str):
+ """
+ Sets application metadata on an OSD pool
+
+ :param app_name: application name
+ :type app_name: str
+ :param key: metadata key
+ :type key: str
+ :param value: metadata value
+ :type value: str
+
+ :raises: :class:`Error`
+ """
+ app_name_raw = cstr(app_name, 'app_name')
+ key_raw = cstr(key, 'key')
+ value_raw = cstr(value, 'value')
+ cdef:
+ char *_app_name = app_name_raw
+ char *_key = key_raw
+ char *_value = value_raw
+
+ with nogil:
+ ret = rados_application_metadata_set(self.io, _app_name, _key,
+ _value)
+ if ret < 0:
+ raise make_ex(ret, "error setting application metadata")
+
+ def application_metadata_remove(self, app_name: str, key: str):
+ """
+ Remove application metadata from an OSD pool
+
+ :param app_name: application name
+ :type app_name: str
+ :param key: metadata key
+ :type key: str
+
+ :raises: :class:`Error`
+ """
+ app_name_raw = cstr(app_name, 'app_name')
+ key_raw = cstr(key, 'key')
+ cdef:
+ char *_app_name = app_name_raw
+ char *_key = key_raw
+
+ with nogil:
+ ret = rados_application_metadata_remove(self.io, _app_name, _key)
+ if ret < 0:
+ raise make_ex(ret, "error removing application metadata")
+
+ def application_metadata_list(self, app_name: str) -> List[Tuple[str, str]]:
+ """
+ Returns a list of enabled applications
+
+ :param app_name: application name
+ :type app_name: str
+ :returns: list of key/value tuples
+ """
+ app_name_raw = cstr(app_name, 'app_name')
+ cdef:
+ char *_app_name = app_name_raw
+ size_t key_length = 128
+ size_t val_length = 128
+ char *c_keys = NULL
+ char *c_vals = NULL
+
+ try:
+ while True:
+ c_keys = <char *>realloc_chk(c_keys, key_length)
+ c_vals = <char *>realloc_chk(c_vals, val_length)
+ with nogil:
+ ret = rados_application_metadata_list(self.io, _app_name,
+ c_keys, &key_length,
+ c_vals, &val_length)
+ if ret == 0:
+ keys = [decode_cstr(key) for key in
+ c_keys[:key_length].split(b'\0')]
+ vals = [decode_cstr(val) for val in
+ c_vals[:val_length].split(b'\0')]
+ return list(zip(keys, vals))[:-1]
+ elif ret == -errno.ERANGE:
+ pass
+ else:
+ raise make_ex(ret, "error listing application metadata")
+ finally:
+ free(c_keys)
+ free(c_vals)
+
+ def alignment(self) -> int:
+ """
+ Returns pool alignment
+
+ :returns:
+ Number of alignment bytes required by the current pool, or None if
+ alignment is not required.
+ """
+ cdef:
+ int requires = 0
+ uint64_t _alignment
+
+ with nogil:
+ ret = rados_ioctx_pool_requires_alignment2(self.io, &requires)
+ if ret != 0:
+ raise make_ex(ret, "error checking alignment")
+
+ alignment = None
+ if requires:
+ with nogil:
+ ret = rados_ioctx_pool_required_alignment2(self.io, &_alignment)
+ if ret != 0:
+ raise make_ex(ret, "error querying alignment")
+ alignment = _alignment
+ return alignment
+
+
+def set_object_locator(func):
+ def retfunc(self, *args, **kwargs):
+ if self.locator_key is not None:
+ old_locator = self.ioctx.get_locator_key()
+ self.ioctx.set_locator_key(self.locator_key)
+ retval = func(self, *args, **kwargs)
+ self.ioctx.set_locator_key(old_locator)
+ return retval
+ else:
+ return func(self, *args, **kwargs)
+ return retfunc
+
+
+def set_object_namespace(func):
+ def retfunc(self, *args, **kwargs):
+ if self.nspace is None:
+ raise LogicError("Namespace not set properly in context")
+ old_nspace = self.ioctx.get_namespace()
+ self.ioctx.set_namespace(self.nspace)
+ retval = func(self, *args, **kwargs)
+ self.ioctx.set_namespace(old_nspace)
+ return retval
+ return retfunc
+
+
+class Object(object):
+ """Rados object wrapper, makes the object look like a file"""
+ def __init__(self, ioctx, key, locator_key=None, nspace=None):
+ self.key = key
+ self.ioctx = ioctx
+ self.offset = 0
+ self.state = "exists"
+ self.locator_key = locator_key
+ self.nspace = "" if nspace is None else nspace
+
+ def __str__(self):
+ return "rados.Object(ioctx=%s,key=%s,nspace=%s,locator=%s)" % \
+ (str(self.ioctx), self.key, "--default--"
+ if self.nspace is "" else self.nspace, self.locator_key)
+
+ def require_object_exists(self):
+ if self.state != "exists":
+ raise ObjectStateError("The object is %s" % self.state)
+
+ @set_object_locator
+ @set_object_namespace
+ def read(self, length=1024 * 1024):
+ self.require_object_exists()
+ ret = self.ioctx.read(self.key, length, self.offset)
+ self.offset += len(ret)
+ return ret
+
+ @set_object_locator
+ @set_object_namespace
+ def write(self, string_to_write):
+ self.require_object_exists()
+ ret = self.ioctx.write(self.key, string_to_write, self.offset)
+ if ret == 0:
+ self.offset += len(string_to_write)
+ return ret
+
+ @set_object_locator
+ @set_object_namespace
+ def remove(self):
+ self.require_object_exists()
+ self.ioctx.remove_object(self.key)
+ self.state = "removed"
+
+ @set_object_locator
+ @set_object_namespace
+ def stat(self) -> Tuple[int, time.struct_time]:
+ self.require_object_exists()
+ return self.ioctx.stat(self.key)
+
+ def seek(self, position: int):
+ self.require_object_exists()
+ self.offset = position
+
+ @set_object_locator
+ @set_object_namespace
+ def get_xattr(self, xattr_name: str) -> bytes:
+ self.require_object_exists()
+ return self.ioctx.get_xattr(self.key, xattr_name)
+
+ @set_object_locator
+ @set_object_namespace
+ def get_xattrs(self) -> XattrIterator:
+ self.require_object_exists()
+ return self.ioctx.get_xattrs(self.key)
+
+ @set_object_locator
+ @set_object_namespace
+ def set_xattr(self, xattr_name: str, xattr_value: bytes) -> bool:
+ self.require_object_exists()
+ return self.ioctx.set_xattr(self.key, xattr_name, xattr_value)
+
+ @set_object_locator
+ @set_object_namespace
+ def rm_xattr(self, xattr_name: str) -> bool:
+ self.require_object_exists()
+ return self.ioctx.rm_xattr(self.key, xattr_name)
+
+MONITOR_LEVELS = [
+ "debug",
+ "info",
+ "warn", "warning",
+ "err", "error",
+ "sec",
+ ]
+
+
+class MonitorLog(object):
+ # NOTE(sileht): Keep this class for backward compat
+ # method moved to Rados.monitor_log()
+ """
+ For watching cluster log messages. Instantiate an object and keep
+ it around while callback is periodically called. Construct with
+ 'level' to monitor 'level' messages (one of MONITOR_LEVELS).
+ arg will be passed to the callback.
+
+ callback will be called with:
+ arg (given to __init__)
+ line (the full line, including timestamp, who, level, msg)
+ who (which entity issued the log message)
+ timestamp_sec (sec of a struct timespec)
+ timestamp_nsec (sec of a struct timespec)
+ seq (sequence number)
+ level (string representing the level of the log message)
+ msg (the message itself)
+ callback's return value is ignored
+ """
+ def __init__(self, cluster, level, callback, arg):
+ self.level = level
+ self.callback = callback
+ self.arg = arg
+ self.cluster = cluster
+ self.cluster.monitor_log(level, callback, arg)
+
diff --git a/src/pybind/rados/setup.py b/src/pybind/rados/setup.py
new file mode 100755
index 000000000..62b54d26b
--- /dev/null
+++ b/src/pybind/rados/setup.py
@@ -0,0 +1,206 @@
+import pkgutil
+if not pkgutil.find_loader('setuptools'):
+ from distutils.core import setup
+ from distutils.extension import Extension
+else:
+ from setuptools import setup
+ from setuptools.extension import Extension
+import distutils.sysconfig
+from distutils.errors import CompileError, LinkError
+from distutils.ccompiler import new_compiler
+from itertools import filterfalse, takewhile
+
+import os
+import shutil
+import sys
+import tempfile
+import textwrap
+
+
+def filter_unsupported_flags(compiler, flags):
+ args = takewhile(lambda argv: not argv.startswith('-'), [compiler] + flags)
+ if any('clang' in arg for arg in args):
+ return list(filterfalse(lambda f:
+ f in ('-mcet',
+ '-fstack-clash-protection',
+ '-fno-var-tracking-assignments',
+ '-Wno-deprecated-register',
+ '-Wno-gnu-designator') or
+ f.startswith('-fcf-protection'),
+ flags))
+ else:
+ return flags
+
+
+def monkey_with_compiler(customize):
+ def patched(compiler):
+ customize(compiler)
+ if compiler.compiler_type != 'unix':
+ return
+ compiler.compiler[1:] = \
+ filter_unsupported_flags(compiler.compiler[0],
+ compiler.compiler[1:])
+ compiler.compiler_so[1:] = \
+ filter_unsupported_flags(compiler.compiler_so[0],
+ compiler.compiler_so[1:])
+ return patched
+
+
+distutils.sysconfig.customize_compiler = \
+ monkey_with_compiler(distutils.sysconfig.customize_compiler)
+
+# PEP 440 versioning of the Rados package on PyPI
+# Bump this version, after every changeset
+__version__ = '2.0.0'
+
+
+def get_python_flags(libs):
+ py_libs = sum((libs.split() for libs in
+ distutils.sysconfig.get_config_vars('LIBS', 'SYSLIBS')), [])
+ ldflags = list(filterfalse(lambda lib: lib.startswith('-l'), py_libs))
+ py_libs = [lib.replace('-l', '') for lib in
+ filter(lambda lib: lib.startswith('-l'), py_libs)]
+ compiler = new_compiler()
+ distutils.sysconfig.customize_compiler(compiler)
+ return dict(
+ include_dirs=[distutils.sysconfig.get_python_inc()],
+ library_dirs=distutils.sysconfig.get_config_vars('LIBDIR', 'LIBPL'),
+ libraries=libs + py_libs,
+ extra_compile_args=filter_unsupported_flags(
+ compiler.compiler[0],
+ compiler.compiler[1:] + distutils.sysconfig.get_config_var('CFLAGS').split()),
+ extra_link_args=(distutils.sysconfig.get_config_var('LDFLAGS').split() +
+ ldflags))
+
+
+def check_sanity():
+ """
+ Test if development headers and library for rados is available by compiling a dummy C program.
+ """
+ CEPH_SRC_DIR = os.path.join(
+ os.path.dirname(os.path.abspath(__file__)),
+ '..',
+ '..'
+ )
+
+ tmp_dir = tempfile.mkdtemp(dir=os.environ.get('TMPDIR', os.path.dirname(__file__)))
+ tmp_file = os.path.join(tmp_dir, 'rados_dummy.c')
+
+ with open(tmp_file, 'w') as fp:
+ dummy_prog = textwrap.dedent("""
+ #include <rados/librados.h>
+
+ int main(void) {
+ rados_t cluster;
+ rados_create(&cluster, NULL);
+ return 0;
+ }
+ """)
+ fp.write(dummy_prog)
+
+ compiler = new_compiler()
+ distutils.sysconfig.customize_compiler(compiler)
+
+ if 'CEPH_LIBDIR' in os.environ:
+ # The setup.py has been invoked by a top-level Ceph make.
+ # Set the appropriate CFLAGS and LDFLAGS
+ compiler.set_include_dirs([os.path.join(CEPH_SRC_DIR, 'include')])
+ compiler.set_library_dirs([os.environ.get('CEPH_LIBDIR')])
+
+ try:
+ link_objects = compiler.compile(
+ sources=[tmp_file],
+ output_dir=tmp_dir
+ )
+ compiler.link_executable(
+ objects=link_objects,
+ output_progname=os.path.join(tmp_dir, 'rados_dummy'),
+ libraries=['rados'],
+ output_dir=tmp_dir,
+ )
+
+ except CompileError:
+ print('\nCompile Error: RADOS development headers not found', file=sys.stderr)
+ return False
+ except LinkError:
+ print('\nLink Error: RADOS library not found', file=sys.stderr)
+ return False
+ else:
+ return True
+ finally:
+ shutil.rmtree(tmp_dir)
+
+
+if 'BUILD_DOC' in os.environ or 'READTHEDOCS' in os.environ:
+ ext_args = {}
+ cython_constants = dict(BUILD_DOC=True)
+elif check_sanity():
+ ext_args = get_python_flags(['rados'])
+ cython_constants = dict(BUILD_DOC=False)
+else:
+ sys.exit(1)
+
+cmdclass = {}
+try:
+ from Cython.Build import cythonize
+ from Cython.Distutils import build_ext
+
+ cmdclass = {'build_ext': build_ext}
+except ImportError:
+ print("WARNING: Cython is not installed.")
+
+ if not os.path.isfile('rados.c'):
+ print('ERROR: Cannot find Cythonized file rados.c', file=sys.stderr)
+ sys.exit(1)
+ else:
+ def cythonize(x, **kwargs):
+ return x
+
+ source = "rados.c"
+else:
+ source = "rados.pyx"
+
+# Disable cythonification if we're not really building anything
+if (len(sys.argv) >= 2 and
+ any(i in sys.argv[1:] for i in ('--help', 'clean', 'egg_info', '--version')
+ )):
+ def cythonize(x, **kwargs):
+ return x
+
+setup(
+ name='rados',
+ version=__version__,
+ description="Python bindings for the Ceph librados library",
+ long_description=(
+ "This package contains Python bindings for interacting with Ceph's "
+ "RADOS library. RADOS is a reliable, autonomic distributed object "
+ "storage cluster developed as part of the Ceph distributed storage "
+ "system. This is a shared library allowing applications to access "
+ "the distributed object store using a simple file-like interface."
+ ),
+ url='https://github.com/ceph/ceph/tree/master/src/pybind/rados',
+ license='LGPLv2+',
+ platforms='Linux',
+ ext_modules=cythonize(
+ [
+ Extension(
+ "rados",
+ [source],
+ **ext_args
+ )
+ ],
+ # use "3str" when Cython 3.0 is available
+ compiler_directives={'language_level': sys.version_info.major},
+ compile_time_env=cython_constants,
+ build_dir=os.environ.get("CYTHON_BUILD_DIR", None),
+ ),
+ classifiers=[
+ 'Intended Audience :: Developers',
+ 'Intended Audience :: System Administrators',
+ 'License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)',
+ 'Operating System :: POSIX :: Linux',
+ 'Programming Language :: Cython',
+ 'Programming Language :: Python :: 3'
+ ],
+ cmdclass=cmdclass,
+)
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 09:01:38 +0000