Struct IoCtx

pub struct IoCtx {
    pub ioctx: rados_ioctx_t,
}

Owns a ioctx handle

Fields

ioctx: rados_ioctx_t

Implementations

impl IoCtx

pub fn inner(&self) -> &rados_ioctx_t

pub fn destroy_rados_ioctx(&mut self)

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. This does not guarantee any asynchronous writes have completed. You must call rados_aio_flush() on the io context before destroying it to do that.

pub fn rados_stat_pool(&self) -> RadosResult<Struct_rados_pool_stat_t>

Note: Ceph uses kibibytes: https://en.wikipedia.org/wiki/Kibibyte

pub fn rados_pool_set_auid(&self, auid: u64) -> RadosResult<()>

pub fn rados_pool_get_auid(&self) -> RadosResult<u64>

pub fn rados_pool_requires_alignment(&self) -> RadosResult<bool>

Test whether the specified pool requires alignment or not.

pub fn rados_pool_required_alignment(&self) -> RadosResult<u64>

Get the alignment flavor of a pool

pub fn rados_object_get_id(&self) -> RadosResult<i64>

Get the pool id of the io context

pub fn rados_get_pool_name(&self) -> RadosResult<String>

Get the pool name of the io context

pub fn rados_locator_set_key(&self, key: &str) -> RadosResult<()>

Set the key for mapping objects to pgs within an io context.

pub fn rados_set_namespace(&self, namespace: &str) -> RadosResult<()>

Set the namespace for objects within an io context The namespace specification further refines a pool into different domains. The mapping of objects to pgs is also based on this value.

pub fn rados_list_pool_objects(&self) -> RadosResult<rados_list_ctx_t>

Start listing objects in a pool

pub fn rados_snap_create(&self, snap_name: &str) -> RadosResult<()>

Create a pool-wide snapshot

pub fn rados_snap_remove(&self, snap_name: &str) -> RadosResult<()>

Delete a pool snapshot

pub fn rados_snap_rollback( &self, object_name: &str, snap_name: &str, ) -> RadosResult<()>

Rollback an object to a pool snapshot The contents of the object will be the same as when the snapshot was taken.

pub fn rados_snap_set_read(&self, snap_id: u64) -> RadosResult<()>

Set the snapshot from which reads are performed. Subsequent reads will return data as it was at the time of that snapshot.

pub fn rados_selfmanaged_snap_create(&self) -> RadosResult<u64>

Allocate an ID for a self-managed snapshot Get a unique ID to put in the snaphot context to create a snapshot. A clone of an object is not created until a write with the new snapshot context is completed.

pub fn rados_selfmanaged_snap_remove(&self, snap_id: u64) -> RadosResult<()>

Remove a self-managed snapshot This increases the snapshot sequence number, which will cause snapshots to be removed lazily.

pub fn rados_selfmanaged_snap_rollback( &self, object_name: &str, snap_id: u64, ) -> RadosResult<()>

Rollback an object to a self-managed snapshot The contents of the object will be the same as when the snapshot was taken.

pub fn rados_snap_lookup(&self, snap_name: &str) -> RadosResult<u64>

Set the snapshot context for use when writing to objects This is stored in the io context, and applies to all future writes. List all the ids of pool snapshots Get the id of a pool snapshot

pub fn rados_snap_get_name(&self, snap_id: u64) -> RadosResult<String>

Get the name of a pool snapshot

pub fn rados_snap_get_stamp(&self, snap_id: u64) -> RadosResult<time_t>

Find when a pool snapshot occurred

pub fn rados_get_object_last_version(&self) -> RadosResult<u64>

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

pub fn rados_object_write( &self, object_name: &str, buffer: &[u8], offset: u64, ) -> RadosResult<()>

Write len bytes from buf into the oid object, starting at offset off. The value of len must be <= UINT_MAX/2.

pub fn rados_object_write_full( &self, object_name: &str, buffer: &[u8], ) -> RadosResult<()>

The object is filled with the provided data. If the object exists, it is atomically truncated and then written.

pub async fn rados_async_object_write( &self, object_name: &str, buffer: &[u8], offset: u64, ) -> RadosResult<u32>

pub async fn rados_async_object_append( self: &Arc<Self>, object_name: &str, buffer: &[u8], ) -> RadosResult<u32>

Async variant of rados_object_append

pub async fn rados_async_object_write_full( &self, object_name: &str, buffer: &[u8], ) -> RadosResult<u32>

Async variant of rados_object_write_full

pub async fn rados_async_object_remove( &self, object_name: &str, ) -> RadosResult<()>

Async variant of rados_object_remove

pub async fn rados_async_object_read( &self, object_name: &str, fill_buffer: &mut Vec<u8>, read_offset: u64, ) -> RadosResult<u32>

Async variant of rados_object_read

pub fn rados_async_object_read_stream( &self, object_name: &str, buffer_size: Option<usize>, concurrency: Option<usize>, size_hint: Option<u64>, ) -> ReadStream<'_>

Streaming read of a RADOS object. The ReadStream object implements futures::Stream for use with Stream-aware code like hyper’s Body::wrap_stream.

Useful for reading large objects incrementally, or anywhere you are using an interface that expects a stream (such as proxying objects via an HTTP server).

Efficiency: If size_hint is not specified, and this function is used on a small object, it will issue spurious read-ahead operations beyond the object’s size. If you have an object that you know is small, prefer to use a single rados_async_object_read instead of this streaming variant.

• buffer_size - How much data should be read per rados read operation. This is also how much data is emitted in each Item from the stream.
• concurrency - How many RADOS operations should be run in parallel for this stream, or None to use a default.
• size_hint - If you have prior knowledge of the object’s size in bytes, pass it here to enable the stream to issue fewer read-ahead operations than it would by default. This is just a hint, and does not bound the data returned – if the object is smaller or larger than size_hint then the actual object size will be reflected in the stream’s output.

pub fn rados_async_object_write_stream( &self, object_name: &str, concurrency: Option<usize>, ) -> WriteSink<'_>

Streaming write of a RADOS object. The WriteSink object implements futures::Sink. Combine it with other stream-aware code, or bring the SinkExt trait into scope to get methods like send, send_all.

Efficiency: this class does not coalesce writes, so each Item you send into it,

• concurrency - How many RADOS operations should be run in parallel for this stream, or None to use a default.

pub async fn rados_async_object_stat( &self, object_name: &str, ) -> RadosResult<(u64, SystemTime)>

Get object stats (size,SystemTime)

pub fn rados_async_object_list(&self) -> RadosResult<ListStream>

pub async fn rados_async_object_getxattr( &self, object_name: &str, attr_name: &str, fill_buffer: &mut [u8], ) -> RadosResult<u32>

Async variant of rados_object_getxattr

pub async fn rados_async_object_setxattr( &self, object_name: &str, attr_name: &str, attr_value: &[u8], ) -> RadosResult<u32>

Async variant of rados_object_setxattr

pub async fn rados_async_object_rmxattr( &self, object_name: &str, attr_name: &str, ) -> RadosResult<u32>

Async variant of rados_object_rmxattr

pub fn rados_object_clone_range( &self, dst_object_name: &str, dst_offset: u64, src_object_name: &str, src_offset: u64, length: usize, ) -> RadosResult<()>

Efficiently copy a portion of one object to another If the underlying filesystem on the OSD supports it, this will be a copy-on-write clone. The src and dest objects must be in the same pg. To ensure this, the io context should have a locator key set (see rados_ioctx_locator_set_key()).

pub fn rados_object_append( &self, object_name: &str, buffer: &[u8], ) -> RadosResult<()>

Append len bytes from buf into the oid object.

pub fn rados_object_read( &self, object_name: &str, fill_buffer: &mut Vec<u8>, read_offset: u64, ) -> RadosResult<i32>

Read data from an object. This fills the slice given and returns the amount of bytes read The io context determines the snapshot to read from, if any was set by rados_ioctx_snap_set_read(). Default read size is 64K unless you call Vec::with_capacity with a larger size.

pub fn rados_object_remove(&self, object_name: &str) -> RadosResult<()>

Delete an object Note: This does not delete any snapshots of the object.

pub fn rados_object_trunc( &self, object_name: &str, new_size: u64, ) -> RadosResult<()>

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.

pub fn rados_object_getxattr( &self, object_name: &str, attr_name: &str, fill_buffer: &mut [u8], ) -> RadosResult<i32>

Get the value of an extended attribute on an object.

pub fn rados_object_setxattr( &self, object_name: &str, attr_name: &str, attr_value: &mut [u8], ) -> RadosResult<()>

Set an extended attribute on an object.

pub fn rados_object_rmxattr( &self, object_name: &str, attr_name: &str, ) -> RadosResult<()>

Delete an extended attribute from an object.

pub fn rados_get_xattr_iterator( &self, object_name: &str, ) -> RadosResult<rados_xattrs_iter_t>

Get the rados_xattrs_iter_t reference to iterate over xattrs on an object Used in conjuction with XAttr::new() to iterate.

pub fn rados_object_stat( &self, object_name: &str, ) -> RadosResult<(u64, SystemTime)>

Get object stats (size,SystemTime)

pub fn rados_object_tmap_update( &self, object_name: &str, update: TmapOperation, ) -> RadosResult<()>

Update tmap (trivial map)

pub fn rados_object_tmap_get( &self, object_name: &str, ) -> RadosResult<Vec<TmapOperation>>

Fetch complete tmap (trivial map) object

pub fn rados_object_exec( &self, object_name: &str, class_name: &str, method_name: &str, input_buffer: &[u8], output_buffer: &mut [u8], ) -> RadosResult<()>

Execute an OSD class method on an object The OSD has a plugin mechanism for performing complicated operations on an object atomically. These plugins are called classes. This function allows librados users to call the custom methods. The input and output formats are defined by the class. Classes in ceph.git can be found in src/cls subdirectories

pub fn rados_object_notify( &self, object_name: &str, data: &[u8], ) -> RadosResult<()>

Sychronously notify watchers of an object This blocks until all watchers of the object have received and reacted to the notify, or a timeout is reached.

pub fn rados_object_notify_ack( &self, object_name: &str, notify_id: u64, cookie: u64, buffer: Option<&[u8]>, ) -> RadosResult<()>

Acknolwedge receipt of a notify

pub fn rados_object_set_alloc_hint( &self, object_name: &str, expected_object_size: u64, expected_write_size: u64, ) -> RadosResult<()>

Set allocation hint for an object This is an advisory operation, it will always succeed (as if it was submitted with a LIBRADOS_OP_FLAG_FAILOK flag set) and is not guaranteed to do anything on the backend.

pub fn rados_perform_read_operations( &self, read_op: ReadOperation, ) -> RadosResult<()>

pub fn rados_commit_write_operations( &self, write_op: &mut WriteOperation, ) -> RadosResult<()>

pub fn rados_object_lock_exclusive( &self, object_name: &str, lock_name: &str, cookie_name: &str, description: &str, duration_time: &mut timeval, lock_flags: u8, ) -> RadosResult<()>

Take an exclusive lock on an object.

pub fn rados_object_lock_shared( &self, object_name: &str, lock_name: &str, cookie_name: &str, description: &str, tag_name: &str, duration_time: &mut timeval, lock_flags: u8, ) -> RadosResult<()>

Take a shared lock on an object.

pub fn rados_object_unlock( &self, object_name: &str, lock_name: &str, cookie_name: &str, ) -> RadosResult<()>

Release a shared or exclusive lock on an object.

pub fn rados_object_break_lock( &self, object_name: &str, lock_name: &str, client_name: &str, cookie_name: &str, ) -> RadosResult<()>

List clients that have locked the named object lock and information about the lock. The number of bytes required in each buffer is put in the corresponding size out parameter. If any of the provided buffers are too short, -ERANGE is returned after these sizes are filled in. Releases a shared or exclusive lock on an object, which was taken by the specified client.

Trait Implementations

impl Drop for IoCtx

fn drop(&mut self)

Executes the destructor for this type.

impl Send for IoCtx

impl Sync for IoCtx