- LIBRADOS_VERSION
auto LIBRADOS_VERSION(T0 maj, T1 min, T2 extra)
Undocumented in source. Be warned that the author may not have intended to support it.
- rados_aio_append
int rados_aio_append(rados_ioctx_t io, const(char)* oid, rados_completion_t completion, const(char)* buf, size_t len)
Asychronously append data to an object
- rados_aio_cancel
int rados_aio_cancel(rados_ioctx_t io, rados_completion_t completion)
- rados_aio_create_completion
int rados_aio_create_completion(void* cb_arg, rados_callback_t cb_complete, rados_callback_t cb_safe, rados_completion_t* pc)
Constructs a completion to use with asynchronous operations
- rados_aio_flush
int rados_aio_flush(rados_ioctx_t io)
Block until all pending writes in an io context are safe
- rados_aio_flush_async
int rados_aio_flush_async(rados_ioctx_t io, rados_completion_t completion)
Schedule a callback for when all currently pending
aio writes are safe. This is a non-blocking version of
rados_aio_flush().
- rados_aio_get_return_value
int rados_aio_get_return_value(rados_completion_t c)
Get the return value of an asychronous operation
- rados_aio_get_version
ulong rados_aio_get_version(rados_completion_t c)
Get the internal object version of the target of an asychronous operation
- rados_aio_is_complete
int rados_aio_is_complete(rados_completion_t c)
Has an asynchronous operation completed?
- rados_aio_is_complete_and_cb
int rados_aio_is_complete_and_cb(rados_completion_t c)
Has an asynchronous operation and callback completed
- rados_aio_is_safe
int rados_aio_is_safe(rados_completion_t c)
Is an asynchronous operation safe?
- rados_aio_is_safe_and_cb
int rados_aio_is_safe_and_cb(rados_completion_t c)
Is an asynchronous operation safe and has the callback completed
- rados_aio_notify
int rados_aio_notify(rados_ioctx_t io, const(char)* o, rados_completion_t completion, const(char)* buf, int buf_len, ulong timeout_ms, char** reply_buffer, size_t* reply_buffer_len)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_aio_read
int rados_aio_read(rados_ioctx_t io, const(char)* oid, rados_completion_t completion, char* buf, size_t len, ulong off)
Asychronously read data from an object
- rados_aio_read_op_operate
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)
Perform a read operation asynchronously
@param read_op operation to perform
@param io the ioctx that the object is in
@param completion what to do when operation has been attempted
@param oid the object id
@param flags flags to apply to the entire operation (LIBRADOS_OPERATION_*)
- rados_aio_release
void rados_aio_release(rados_completion_t c)
- rados_aio_remove
int rados_aio_remove(rados_ioctx_t io, const(char)* oid, rados_completion_t completion)
Asychronously remove an object
- rados_aio_stat
int rados_aio_stat(rados_ioctx_t io, const(char)* o, rados_completion_t completion, ulong* psize, time_t* pmtime)
Asynchronously get object stats (size/mtime)
- rados_aio_unwatch
int rados_aio_unwatch(rados_ioctx_t io, ulong cookie, rados_completion_t completion)
Asynchronous unregister an interest in an object
- rados_aio_wait_for_complete
int rados_aio_wait_for_complete(rados_completion_t c)
Block until an operation completes
- rados_aio_wait_for_complete_and_cb
int rados_aio_wait_for_complete_and_cb(rados_completion_t c)
Block until an operation completes and callback completes
- rados_aio_wait_for_safe
int rados_aio_wait_for_safe(rados_completion_t c)
Block until an operation is safe
- rados_aio_wait_for_safe_and_cb
int rados_aio_wait_for_safe_and_cb(rados_completion_t c)
Block until an operation is safe and callback has completed
- rados_aio_watch
int rados_aio_watch(rados_ioctx_t io, const(char)* o, rados_completion_t completion, ulong* handle, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, void* arg)
Asynchronous register an interest in an object
- rados_aio_watch_flush
int rados_aio_watch_flush(rados_t cluster, rados_completion_t completion)
Flush watch/notify callbacks
- rados_aio_write
int rados_aio_write(rados_ioctx_t io, const(char)* oid, rados_completion_t completion, const(char)* buf, size_t len, ulong off)
Write data to an object asynchronously
- rados_aio_write_full
int rados_aio_write_full(rados_ioctx_t io, const(char)* oid, rados_completion_t completion, const(char)* buf, size_t len)
Asychronously write an entire object
- rados_aio_write_op_operate
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)
Perform a write operation asynchronously
@param write_op operation to perform
@param io the ioctx that the object is in
@param completion what to do when operation has been attempted
@param oid the object id
@param mtime the time to set the mtime to, NULL for the current time
@param flags flags to apply to the entire operation (LIBRADOS_OPERATION_*)
- rados_aio_writesame
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, ulong off)
Asychronously write the same buffer multiple times
- rados_append
int rados_append(rados_ioctx_t io, const(char)* oid, const(char)* buf, size_t len)
Append *len* bytes from *buf* into the *oid* object. The value of
*len* must be <= UINT_MAX/2.
- rados_blacklist_add
int rados_blacklist_add(rados_t cluster, char* client_address, uint expire_seconds)
Blacklists the specified client from the OSDs
- rados_break_lock
int rados_break_lock(rados_ioctx_t io, const(char)* o, const(char)* name, const(char)* client, const(char)* cookie)
Releases a shared or exclusive lock on an object, which was taken by the
specified client.
- rados_buffer_free
void rados_buffer_free(char* buf)
free a rados-allocated buffer
- rados_cache_pin
int rados_cache_pin(rados_ioctx_t io, const(char)* o)
Pin an object in the cache tier
- rados_cache_unpin
int rados_cache_unpin(rados_ioctx_t io, const(char)* o)
Unpin an object in the cache tier
- rados_cct
rados_config_t rados_cct(rados_t cluster)
Get a configuration handle for a rados cluster handle
- rados_clone_range
int rados_clone_range(rados_ioctx_t io, const(char)* dst, ulong dst_off, const(char)* src, ulong src_off, size_t len)
Efficiently copy a portion of one object to another
- rados_cluster_fsid
int rados_cluster_fsid(rados_t cluster, char* buf, size_t len)
Get the fsid of the cluster as a hexadecimal string.
- rados_cluster_stat
int rados_cluster_stat(rados_t cluster, rados_cluster_stat_t* result)
Read usage info about the cluster
- rados_conf_get
int rados_conf_get(rados_t cluster, const(char)* option, char* buf, size_t len)
Get the value of a configuration option
- rados_conf_parse_argv
int rados_conf_parse_argv(rados_t cluster, int argc, const(char*)* argv)
Configure the cluster handle with command line arguments
- rados_conf_parse_argv_remainder
int rados_conf_parse_argv_remainder(rados_t cluster, int argc, const(char*)* argv, const(char*)* remargv)
Configure the cluster handle with command line arguments, returning
any remainders. Same rados_conf_parse_argv, except for extra
remargv argument to hold returns unrecognized arguments.
- rados_conf_parse_env
int rados_conf_parse_env(rados_t cluster, const(char)* var)
Configure the cluster handle based on an environment variable
- rados_conf_read_file
int rados_conf_read_file(rados_t cluster, const(char)* path)
Configure the cluster handle using a Ceph config file
- rados_conf_set
int rados_conf_set(rados_t cluster, const(char)* option, const(char)* value)
Set a configuration option
- rados_connect
int rados_connect(rados_t cluster)
- rados_create
int rados_create(rados_t* cluster, char* id)
Create a handle for communicating with a RADOS cluster.
- rados_create2
int rados_create2(rados_t* pcluster, char* clustername, char* name, ulong flags)
Extended version of rados_create.
- rados_create_read_op
rados_read_op_t rados_create_read_op()
Create a new rados_read_op_t write operation. This will store all
actions to be performed atomically. You must call
rados_release_read_op when you are finished with it (after it
completes, or you decide not to send it in the first place).
- rados_create_with_context
int rados_create_with_context(rados_t* cluster, rados_config_t cct)
Initialize a cluster handle from an existing configuration.
- rados_create_write_op
rados_write_op_t rados_create_write_op()
Create a new rados_write_op_t write operation. This will store all actions
to be performed atomically. You must call rados_release_write_op when you are
finished with it.
- rados_exec
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)
Execute an OSD class method on an object
- rados_get_instance_id
ulong rados_get_instance_id(rados_t cluster)
Get a global id for current instance
- rados_get_last_version
ulong rados_get_last_version(rados_ioctx_t io)
Return the version of the last object read or written to.
- rados_getxattr
int rados_getxattr(rados_ioctx_t io, const(char)* o, const(char)* name, char* buf, size_t len)
Get the value of an extended attribute on an object.
- rados_getxattrs
int rados_getxattrs(rados_ioctx_t io, const(char)* oid, rados_xattrs_iter_t* iter)
Start iterating over xattrs on an object.
- rados_getxattrs_end
void rados_getxattrs_end(rados_xattrs_iter_t iter)
Close the xattr iterator.
- rados_getxattrs_next
int rados_getxattrs_next(rados_xattrs_iter_t iter, const(char*)* name, const(char*)* val, size_t* len)
Get the next xattr on the object
- rados_inconsistent_pg_list
int rados_inconsistent_pg_list(rados_t cluster, long pool, char* buf, size_t len)
List inconsistent placement groups of the given pool
- rados_ioctx_cct
rados_config_t rados_ioctx_cct(rados_ioctx_t io)
Get configuration hadnle for a pool handle
- rados_ioctx_create
int rados_ioctx_create(rados_t cluster, const(char)* pool_name, rados_ioctx_t* ioctx)
- rados_ioctx_create2
int rados_ioctx_create2(rados_t cluster, long pool_id, rados_ioctx_t* ioctx)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_ioctx_destroy
void rados_ioctx_destroy(rados_ioctx_t io)
The opposite of rados_ioctx_create
- rados_ioctx_get_cluster
rados_t rados_ioctx_get_cluster(rados_ioctx_t io)
Get the cluster handle used by this rados_ioctx_t
Note that this is a weak reference, and should not
be destroyed via rados_shutdown().
- rados_ioctx_get_id
long rados_ioctx_get_id(rados_ioctx_t io)
Get the pool id of the io context
- rados_ioctx_get_pool_name
int rados_ioctx_get_pool_name(rados_ioctx_t io, char* buf, uint maxlen)
Get the pool name of the io context
- rados_ioctx_locator_set_key
void rados_ioctx_locator_set_key(rados_ioctx_t io, const(char)* key)
Set the key for mapping objects to pgs within an io context.
- rados_ioctx_pool_get_auid
int rados_ioctx_pool_get_auid(rados_ioctx_t io, ulong* auid)
- rados_ioctx_pool_required_alignment
ulong rados_ioctx_pool_required_alignment(rados_ioctx_t io)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_ioctx_pool_required_alignment2
int rados_ioctx_pool_required_alignment2(rados_ioctx_t io, ulong* alignment)
Get the alignment flavor of a pool
- rados_ioctx_pool_requires_alignment
int rados_ioctx_pool_requires_alignment(rados_ioctx_t io)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_ioctx_pool_requires_alignment2
int rados_ioctx_pool_requires_alignment2(rados_ioctx_t io, int* requires)
Test whether the specified pool requires alignment or not.
- rados_ioctx_pool_set_auid
int rados_ioctx_pool_set_auid(rados_ioctx_t io, ulong auid)
Attempt to change an io context's associated auid "owner"
- rados_ioctx_pool_stat
int rados_ioctx_pool_stat(rados_ioctx_t io, rados_pool_stat_t* stats)
Get pool usage statistics
- rados_ioctx_selfmanaged_snap_create
int rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io, rados_snap_t* snapid)
Allocate an ID for a self-managed snapshot
- rados_ioctx_selfmanaged_snap_remove
int rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io, rados_snap_t snapid)
Remove a self-managed snapshot
- rados_ioctx_selfmanaged_snap_rollback
int rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io, const(char)* oid, rados_snap_t snapid)
Rollback an object to a self-managed snapshot
- rados_ioctx_selfmanaged_snap_set_write_ctx
int rados_ioctx_selfmanaged_snap_set_write_ctx(rados_ioctx_t io, rados_snap_t seq, rados_snap_t* snaps, int num_snaps)
Set the snapshot context for use when writing to objects
- rados_ioctx_set_namespace
void rados_ioctx_set_namespace(rados_ioctx_t io, const(char)* nspace)
Set the namespace for objects within an io context
- rados_ioctx_snap_create
int rados_ioctx_snap_create(rados_ioctx_t io, const(char)* snapname)
Create a pool-wide snapshot
- rados_ioctx_snap_get_name
int rados_ioctx_snap_get_name(rados_ioctx_t io, rados_snap_t id, char* name, int maxlen)
Get the name of a pool snapshot
- rados_ioctx_snap_get_stamp
int rados_ioctx_snap_get_stamp(rados_ioctx_t io, rados_snap_t id, time_t* t)
Find when a pool snapshot occurred
- rados_ioctx_snap_list
int rados_ioctx_snap_list(rados_ioctx_t io, rados_snap_t* snaps, int maxlen)
List all the ids of pool snapshots
- rados_ioctx_snap_lookup
int rados_ioctx_snap_lookup(rados_ioctx_t io, const(char)* name, rados_snap_t* id)
Get the id of a pool snapshot
- rados_ioctx_snap_remove
int rados_ioctx_snap_remove(rados_ioctx_t io, const(char)* snapname)
- rados_ioctx_snap_rollback
int rados_ioctx_snap_rollback(rados_ioctx_t io, const(char)* oid, const(char)* snapname)
Rollback an object to a pool snapshot
- rados_ioctx_snap_set_read
void rados_ioctx_snap_set_read(rados_ioctx_t io, rados_snap_t snap)
Set the snapshot from which reads are performed.
- rados_list_lockers
ssize_t rados_list_lockers(rados_ioctx_t io, const(char)* o, const(char)* name, int* exclusive, char* tag, size_t* tag_len, char* clients, size_t* clients_len, char* cookies, size_t* cookies_len, char* addrs, size_t* addrs_len)
List clients that have locked the named object lock and information about
the lock.
- rados_lock_exclusive
int rados_lock_exclusive(rados_ioctx_t io, const(char)* oid, const(char)* name, const(char)* cookie, const(char)* desc, timeval* duration, ubyte flags)
Take an exclusive lock on an object.
- rados_lock_shared
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, ubyte flags)
Take a shared lock on an object.
- rados_mon_command
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)
- rados_mon_command_target
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)
Send monitor command to a specific monitor.
- rados_monitor_log
int rados_monitor_log(rados_t cluster, const(char)* level, rados_log_callback_t cb, void* arg)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_nobjects_list_close
void rados_nobjects_list_close(rados_list_ctx_t ctx)
Close the object listing handle.
- rados_nobjects_list_get_pg_hash_position
uint rados_nobjects_list_get_pg_hash_position(rados_list_ctx_t ctx)
Return hash position of iterator, rounded to the current PG
- rados_nobjects_list_next
int rados_nobjects_list_next(rados_list_ctx_t ctx, const(char*)* entry, const(char*)* key, const(char*)* nspace)
Get the next object name and locator in the pool
- rados_nobjects_list_open
int rados_nobjects_list_open(rados_ioctx_t io, rados_list_ctx_t* ctx)
Start listing objects in a pool
- rados_nobjects_list_seek
uint rados_nobjects_list_seek(rados_list_ctx_t ctx, uint pos)
Reposition object iterator to a different hash position
- rados_notify
int rados_notify(rados_ioctx_t io, const(char)* o, ulong ver, const(char)* buf, int buf_len)
Sychronously notify watchers of an object
- rados_notify2
int rados_notify2(rados_ioctx_t io, const(char)* o, const(char)* buf, int buf_len, ulong timeout_ms, char** reply_buffer, size_t* reply_buffer_len)
Sychronously notify watchers of an object
- rados_notify_ack
int rados_notify_ack(rados_ioctx_t io, const(char)* o, ulong notify_id, ulong cookie, const(char)* buf, int buf_len)
Acknolwedge receipt of a notify
- rados_object_list
int rados_object_list(rados_ioctx_t io, rados_object_list_cursor start, rados_object_list_cursor finish, size_t result_size, const(char)* filter_buf, size_t filter_buf_len, rados_object_list_item* results, rados_object_list_cursor* next)
@return the number of items set in the result array
- rados_object_list_begin
rados_object_list_cursor rados_object_list_begin(rados_ioctx_t io)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_object_list_cursor_cmp
int rados_object_list_cursor_cmp(rados_ioctx_t io, rados_object_list_cursor lhs, rados_object_list_cursor rhs)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_object_list_cursor_free
void rados_object_list_cursor_free(rados_ioctx_t io, rados_object_list_cursor cur)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_object_list_end
rados_object_list_cursor rados_object_list_end(rados_ioctx_t io)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_object_list_free
void rados_object_list_free(size_t result_size, rados_object_list_item* results)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_object_list_is_end
int rados_object_list_is_end(rados_ioctx_t io, rados_object_list_cursor cur)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_object_list_slice
void rados_object_list_slice(rados_ioctx_t io, rados_object_list_cursor start, rados_object_list_cursor finish, size_t n, size_t m, rados_object_list_cursor* split_start, rados_object_list_cursor* split_finish)
Obtain cursors delineating a subset of a range. Use this
when you want to split up the work of iterating over the
global namespace. Expected use case is when you are iterating
in parallel, with m workers, and each worker taking an id n.
- rados_objects_list_close
void rados_objects_list_close(rados_list_ctx_t ctx)
@warning Deprecated: Use rados_nobjects_list_close() instead
- rados_objects_list_get_pg_hash_position
uint rados_objects_list_get_pg_hash_position(rados_list_ctx_t ctx)
@warning Deprecated: Use rados_nobjects_list_get_pg_hash_position() instead
- rados_objects_list_next
int rados_objects_list_next(rados_list_ctx_t ctx, const(char*)* entry, const(char*)* key)
@warning Deprecated: Use rados_nobjects_list_next() instead
- rados_objects_list_open
int rados_objects_list_open(rados_ioctx_t io, rados_list_ctx_t* ctx)
@warning Deprecated: Use rados_nobjects_list_open() instead
- rados_objects_list_seek
uint rados_objects_list_seek(rados_list_ctx_t ctx, uint pos)
@warning Deprecated: Use rados_nobjects_list_seek() instead
- rados_omap_get_end
void rados_omap_get_end(rados_omap_iter_t iter)
- rados_omap_get_next
int rados_omap_get_next(rados_omap_iter_t iter, char** key, char** val, size_t* len)
Get the next omap key/value pair on the object
- rados_osd_command
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)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_pg_command
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)
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
- rados_ping_monitor
int rados_ping_monitor(rados_t cluster, const(char)* mon_id, char** outstr, size_t* outstrlen)
Ping the monitor with ID mon_id, storing the resulting reply in
buf (if specified) with a maximum size of len.
- rados_pool_create
int rados_pool_create(rados_t cluster, const(char)* pool_name)
Create a pool with default settings
- rados_pool_create_with_all
int rados_pool_create_with_all(rados_t cluster, const(char)* pool_name, ulong auid, ubyte crush_rule_num)
Create a pool with a specific CRUSH rule and auid
- rados_pool_create_with_auid
int rados_pool_create_with_auid(rados_t cluster, const(char)* pool_name, ulong auid)
Create a pool owned by a specific auid
- rados_pool_create_with_crush_rule
int rados_pool_create_with_crush_rule(rados_t cluster, const(char)* pool_name, ubyte crush_rule_num)
Create a pool with a specific CRUSH rule
- rados_pool_delete
int rados_pool_delete(rados_t cluster, const(char)* pool_name)
Delete a pool and all data inside it
- rados_pool_get_base_tier
int rados_pool_get_base_tier(rados_t cluster, long pool, long* base_tier)
Returns the pool that is the base tier for this pool.
- rados_pool_list
int rados_pool_list(rados_t cluster, char* buf, size_t len)
- rados_pool_lookup
long rados_pool_lookup(rados_t cluster, const(char)* pool_name)
- rados_pool_reverse_lookup
int rados_pool_reverse_lookup(rados_t cluster, long id, char* buf, size_t maxlen)
- rados_read
int rados_read(rados_ioctx_t io, const(char)* oid, char* buf, size_t len, ulong off)
- rados_read_op_assert_exists
void rados_read_op_assert_exists(rados_read_op_t read_op)
Ensure that the object exists before reading
@param read_op operation to add this action to
- rados_read_op_assert_version
void rados_read_op_assert_version(rados_read_op_t read_op, ulong ver)
Ensure that the object exists and that its internal version
number is equal to "ver" before reading. "ver" should be a
version number previously obtained with rados_get_last_version().
- If the object's version is greater than the asserted version
then rados_read_op_operate will return -ERANGE instead of
executing the op.
- If the object's version is less than the asserted version
then rados_read_op_operate will return -EOVERFLOW instead
of executing the op.
@param read_op operation to add this action to
@param ver object version number
- rados_read_op_cmpxattr
void rados_read_op_cmpxattr(rados_read_op_t read_op, const(char)* name, ubyte comparison_operator, const(char)* value, size_t value_len)
Ensure that the an xattr satisfies a comparison
If the comparison is not satisfied, the return code of the
operation will be -ECANCELED
@param read_op operation to add this action to
@param name name of the xattr to look up
@param comparison_operator currently undocumented, look for
LIBRADOS_CMPXATTR_OP_EQ in librados.h
@param value buffer to compare actual xattr value to
@param value_len length of buffer to compare actual xattr value to
- rados_read_op_exec
void rados_read_op_exec(rados_read_op_t read_op, const(char)* cls, const(char)* method, const(char)* in_buf, size_t in_len, char** out_buf, size_t* out_len, int* prval)
Execute an OSD class method on an object
See rados_exec() for general description.
- rados_read_op_exec_user_buf
void rados_read_op_exec_user_buf(rados_read_op_t read_op, const(char)* cls, const(char)* method, const(char)* in_buf, size_t in_len, char* out_buf, size_t out_len, size_t* used_len, int* prval)
Execute an OSD class method on an object
See rados_exec() for general description.
- rados_read_op_getxattrs
void rados_read_op_getxattrs(rados_read_op_t read_op, rados_xattrs_iter_t* iter, int* prval)
Start iterating over xattrs on an object.
- rados_read_op_omap_cmp
void rados_read_op_omap_cmp(rados_read_op_t read_op, const(char)* key, ubyte comparison_operator, const(char)* val, size_t val_len, int* prval)
Ensure that the an omap value satisfies a comparison,
with the supplied value on the right hand side (i.e.
for OP_LT, the comparison is actual_value < value.
- rados_read_op_omap_get_keys
void rados_read_op_omap_get_keys(rados_read_op_t read_op, const(char)* start_after, ulong max_return, rados_omap_iter_t* iter, int* prval)
Start iterating over keys on an object.
- rados_read_op_omap_get_vals
void rados_read_op_omap_get_vals(rados_read_op_t read_op, const(char)* start_after, const(char)* filter_prefix, ulong max_return, rados_omap_iter_t* iter, int* prval)
Start iterating over key/value pairs on an object.
- rados_read_op_omap_get_vals_by_keys
void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op, const(char*)* keys, size_t keys_len, rados_omap_iter_t* iter, int* prval)
Start iterating over specific key/value pairs
- rados_read_op_operate
int rados_read_op_operate(rados_read_op_t read_op, rados_ioctx_t io, const(char)* oid, int flags)
Perform a read operation synchronously
@param read_op operation to perform
@param io the ioctx that the object is in
@param oid the object id
@param flags flags to apply to the entire operation (LIBRADOS_OPERATION_*)
- rados_read_op_read
void rados_read_op_read(rados_read_op_t read_op, ulong offset, size_t len, char* buffer, size_t* bytes_read, int* prval)
Read bytes from offset into buffer.
- rados_read_op_set_flags
void rados_read_op_set_flags(rados_read_op_t read_op, int flags)
Set flags for the last operation added to this read_op.
At least one op must have been added to the read_op.
@param flags see librados.h constants beginning with LIBRADOS_OP_FLAG
- rados_read_op_stat
void rados_read_op_stat(rados_read_op_t read_op, ulong* psize, time_t* pmtime, int* prval)
Get object size and mtime
@param read_op operation to add this action to
@param psize where to store object size
@param pmtime where to store modification time
@param prval where to store the return value of this action
- rados_release_read_op
void rados_release_read_op(rados_read_op_t read_op)
Free a rados_read_op_t, must be called when you're done with it.
@param read_op operation to deallocate, created with rados_create_read_op
- rados_release_write_op
void rados_release_write_op(rados_write_op_t write_op)
Free a rados_write_op_t, must be called when you're done with it.
@param write_op operation to deallocate, created with rados_create_write_op
- rados_remove
int rados_remove(rados_ioctx_t io, const(char)* oid)
- rados_rmxattr
int rados_rmxattr(rados_ioctx_t io, const(char)* o, const(char)* name)
Delete an extended attribute from an object.
- rados_rollback
int rados_rollback(rados_ioctx_t io, const(char)* oid, const(char)* snapname)
@warning Deprecated: Use rados_ioctx_snap_rollback() instead
- rados_set_alloc_hint
int rados_set_alloc_hint(rados_ioctx_t io, const(char)* o, ulong expected_object_size, ulong expected_write_size)
Set allocation hint for an object
- rados_set_alloc_hint2
int rados_set_alloc_hint2(rados_ioctx_t io, const(char)* o, ulong expected_object_size, ulong expected_write_size, uint flags)
Set allocation hint for an object
- rados_setxattr
int rados_setxattr(rados_ioctx_t io, const(char)* o, const(char)* name, const(char)* buf, size_t len)
Set an extended attribute on an object.
- rados_shutdown
void rados_shutdown(rados_t cluster)
Disconnects from the cluster.
- rados_stat
int rados_stat(rados_ioctx_t io, const(char)* o, ulong* psize, time_t* pmtime)
Get object stats (size/mtime)
- rados_tmap_get
int rados_tmap_get(rados_ioctx_t io, const(char)* o, char* buf, size_t buflen)
Fetch complete tmap (trivial map) object
- rados_tmap_put
int rados_tmap_put(rados_ioctx_t io, const(char)* o, const(char)* buf, size_t buflen)
Store complete tmap (trivial map) object
- rados_tmap_update
int rados_tmap_update(rados_ioctx_t io, const(char)* o, const(char)* cmdbuf, size_t cmdbuflen)
Update tmap (trivial map)
- rados_trunc
int rados_trunc(rados_ioctx_t io, const(char)* oid, ulong size)
- rados_unlock
int rados_unlock(rados_ioctx_t io, const(char)* o, const(char)* name, const(char)* cookie)
Release a shared or exclusive lock on an object.
- rados_unwatch
int rados_unwatch(rados_ioctx_t io, const(char)* o, ulong cookie)
Unregister an interest in an object
- rados_unwatch2
int rados_unwatch2(rados_ioctx_t io, ulong cookie)
Unregister an interest in an object
- rados_version
void rados_version(int* major, int* minor, int* extra)
Get the version of librados.
- rados_wait_for_latest_osdmap
int rados_wait_for_latest_osdmap(rados_t cluster)
Get/wait for the most recent osdmap
- rados_watch
int rados_watch(rados_ioctx_t io, const(char)* o, ulong ver, ulong* cookie, rados_watchcb_t watchcb, void* arg)
Register an interest in an object
- rados_watch2
int rados_watch2(rados_ioctx_t io, const(char)* o, ulong* cookie, rados_watchcb2_t watchcb, rados_watcherrcb_t watcherrcb, void* arg)
Register an interest in an object
- rados_watch_check
int rados_watch_check(rados_ioctx_t io, ulong cookie)
Check on the status of a watch
- rados_watch_flush
int rados_watch_flush(rados_t cluster)
Flush watch/notify callbacks
- rados_write
int rados_write(rados_ioctx_t io, const(char)* oid, const(char)* buf, size_t len, ulong off)
Write *len* bytes from *buf* into the *oid* object, starting at
offset *off*. The value of *len* must be <= UINT_MAX/2.
- rados_write_full
int rados_write_full(rados_ioctx_t io, const(char)* oid, const(char)* buf, size_t len)
Write *len* bytes from *buf* into the *oid* object. The value of
*len* must be <= UINT_MAX/2.
- rados_write_op_append
void rados_write_op_append(rados_write_op_t write_op, const(char)* buffer, size_t len)
Append to end of object.
@param write_op operation to add this action to
@param buffer bytes to write
@param len length of buffer
- rados_write_op_assert_exists
void rados_write_op_assert_exists(rados_write_op_t write_op)
Ensure that the object exists before writing
@param write_op operation to add this action to
- rados_write_op_assert_version
void rados_write_op_assert_version(rados_write_op_t write_op, ulong ver)
Ensure that the object exists and that its internal version
number is equal to "ver" before writing. "ver" should be a
version number previously obtained with rados_get_last_version().
- If the object's version is greater than the asserted version
then rados_write_op_operate will return -ERANGE instead of
executing the op.
- If the object's version is less than the asserted version
then rados_write_op_operate will return -EOVERFLOW instead
of executing the op.
@param write_op operation to add this action to
@param ver object version number
- rados_write_op_cmpxattr
void rados_write_op_cmpxattr(rados_write_op_t write_op, const(char)* name, ubyte comparison_operator, const(char)* value, size_t value_len)
Ensure that given xattr satisfies comparison.
If the comparison is not satisfied, the return code of the
operation will be -ECANCELED
@param write_op operation to add this action to
@param name name of the xattr to look up
@param comparison_operator currently undocumented, look for
LIBRADOS_CMPXATTR_OP_EQ in librados.h
@param value buffer to compare actual xattr value to
@param value_len length of buffer to compare actual xattr value to
- rados_write_op_create
void rados_write_op_create(rados_write_op_t write_op, int exclusive, const(char)* category)
Create the object
@param write_op operation to add this action to
@param exclusive set to either LIBRADOS_CREATE_EXCLUSIVE or
LIBRADOS_CREATE_IDEMPOTENT
will error if the object already exists.
@param category category string (DEPRECATED, HAS NO EFFECT)
- rados_write_op_exec
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)
Execute an OSD class method on an object
See rados_exec() for general description.
- rados_write_op_omap_clear
void rados_write_op_omap_clear(rados_write_op_t write_op)
Remove all key/value pairs from an object
- rados_write_op_omap_cmp
void rados_write_op_omap_cmp(rados_write_op_t write_op, const(char)* key, ubyte comparison_operator, const(char)* val, size_t val_len, int* prval)
Ensure that the an omap value satisfies a comparison,
with the supplied value on the right hand side (i.e.
for OP_LT, the comparison is actual_value < value.
- rados_write_op_omap_rm_keys
void rados_write_op_omap_rm_keys(rados_write_op_t write_op, const(char*)* keys, size_t keys_len)
Remove key/value pairs from an object
- rados_write_op_omap_set
void rados_write_op_omap_set(rados_write_op_t write_op, const(char*)* keys, const(char*)* vals, const(size_t)* lens, size_t num)
Set key/value pairs on an object
- rados_write_op_operate
int rados_write_op_operate(rados_write_op_t write_op, rados_ioctx_t io, const(char)* oid, time_t* mtime, int flags)
Perform a write operation synchronously
@param write_op operation to perform
@param io the ioctx that the object is in
@param oid the object id
@param mtime the time to set the mtime to, NULL for the current time
@param flags flags to apply to the entire operation (LIBRADOS_OPERATION_*)
- rados_write_op_operate2
int rados_write_op_operate2(rados_write_op_t write_op, rados_ioctx_t io, const(char)* oid, timespec* mtime, int flags)
Perform a write operation synchronously
@param write_op operation to perform
@param io the ioctx that the object is in
@param oid the object id
@param mtime the time to set the mtime to, NULL for the current time
@param flags flags to apply to the entire operation (LIBRADOS_OPERATION_*)
- rados_write_op_remove
void rados_write_op_remove(rados_write_op_t write_op)
Remove object
@param write_op operation to add this action to
- rados_write_op_rmxattr
void rados_write_op_rmxattr(rados_write_op_t write_op, const(char)* name)
Remove an xattr
@param write_op operation to add this action to
@param name name of the xattr to remove
- rados_write_op_set_alloc_hint
void rados_write_op_set_alloc_hint(rados_write_op_t write_op, ulong expected_object_size, ulong expected_write_size)
Set allocation hint for an object
- rados_write_op_set_alloc_hint2
void rados_write_op_set_alloc_hint2(rados_write_op_t write_op, ulong expected_object_size, ulong expected_write_size, uint flags)
Set allocation hint for an object
- rados_write_op_set_flags
void rados_write_op_set_flags(rados_write_op_t write_op, int flags)
Set flags for the last operation added to this write_op.
At least one op must have been added to the write_op.
@param flags see librados.h constants beginning with LIBRADOS_OP_FLAG
- rados_write_op_setxattr
void rados_write_op_setxattr(rados_write_op_t write_op, const(char)* name, const(char)* value, size_t value_len)
Set an xattr
@param write_op operation to add this action to
@param name name of the xattr
@param value buffer to set xattr to
@param value_len length of buffer to set xattr to
- rados_write_op_truncate
void rados_write_op_truncate(rados_write_op_t write_op, ulong offset)
Truncate an object
@param write_op operation to add this action to
@param offset Offset to truncate to
- rados_write_op_write
void rados_write_op_write(rados_write_op_t write_op, const(char)* buffer, size_t len, ulong offset)
Write to offset
@param write_op operation to add this action to
@param offset offset to write to
@param buffer bytes to write
@param len length of buffer
- rados_write_op_write_full
void rados_write_op_write_full(rados_write_op_t write_op, const(char)* buffer, size_t len)
Write whole object, atomically replacing it.
@param write_op operation to add this action to
@param buffer bytes to write
@param len length of buffer
- rados_write_op_writesame
void rados_write_op_writesame(rados_write_op_t write_op, const(char)* buffer, size_t data_len, size_t write_len, ulong offset)
Write the same buffer multiple times
@param write_op operation to add this action to
@param buffer bytes to write
@param data_len length of buffer
@param write_len total number of bytes to write, as a multiple of @data_len
@param offset offset to write to
- rados_write_op_zero
void rados_write_op_zero(rados_write_op_t write_op, ulong offset, ulong len)
Zero part of an object
@param write_op operation to add this action to
@param offset Offset to zero
@param len length to zero
- rados_writesame
int rados_writesame(rados_ioctx_t io, const(char)* oid, const(char)* buf, size_t data_len, size_t write_len, ulong off)
Write the same *data_len* bytes from *buf* multiple times into the
*oid* object. *write_len* bytes are written in total, which must be
a multiple of *data_len*. The value of *write_len* and *data_len*
must be <= UINT_MAX/2.