Struct FakeDevice 

pub struct FakeDevice { /* private fields */ }

A Device backed by a memory buffer.

Implementations

impl FakeDevice

pub fn new(block_count: u64, block_size: u32) -> Self

pub fn set_observer(&mut self, observer: Box<dyn Observer>)

pub fn set_op_callback( &mut self, cb: impl Fn(Op) -> Result<(), Error> + Send + Sync + 'static, )

Sets a callback that will run at the beginning of read, write, and flush which will forward any errors, and proceed on Ok().

pub fn from_image(reader: impl Read, block_size: u32) -> Result<Self, Error>

Creates a fake block device from an image (which can be anything that implements std::io::Read). The size of the device is determined by how much data is read.

Trait Implementations

impl Device for FakeDevice

fn poison(&self) -> Result<(), Error>

Sets the poisoned state for the device. A poisoned device will panic the thread that performs Drop on it.

fn allocate_buffer(&self, size: usize) -> BufferFuture<'_>

Allocates a transfer buffer of at least |size| bytes for doing I/O with the device. The actual size of the buffer will be rounded up to a block-aligned size. Blocks until enough capacity is available in the buffer.

fn block_size(&self) -> u32

Returns the block size of the device. Buffers are aligned to block-aligned chunks.

fn block_count(&self) -> u64

Returns the number of blocks of the device.

fn read_with_opts<'life0, 'life1, 'async_trait>( &'life0 self, offset: u64, buffer: MutableBufferRef<'life1>, _read_opts: ReadOptions, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fills |buffer| with blocks read from |offset|.

fn write_with_opts<'life0, 'life1, 'async_trait>( &'life0 self, offset: u64, buffer: BufferRef<'life1>, _write_opts: WriteOptions, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Writes the contents of |buffer| to the device at |offset|.

fn trim<'life0, 'async_trait>( &'life0 self, range: Range<u64>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Trims the given device |range|.

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Closes the block device. It is an error to continue using the device after this, but close itself is idempotent.

fn flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Flush the device.

fn barrier(&self)

Attach a barrier to the next write made to the device.

fn reopen(&self, read_only: bool)

Reopens the device, making it usable again. (Only implemented for testing devices.)

fn is_read_only(&self) -> bool

Returns whether the device is read-only.

fn supports_trim(&self) -> bool

Returns whether the device supports trim.

fn snapshot(&self) -> Result<DeviceHolder, Error>

Returns a snapshot of the device.

fn discard_random_since_last_flush(&self) -> Result<(), Error>

Discards random blocks since the last flush.

fn size(&self) -> u64

Returns the size in bytes of the device.

fn read<'life0, 'life1, 'async_trait>( &'life0 self, offset: u64, buffer: MutableBufferRef<'life1>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fills |buffer| with blocks read from |offset|.

fn write<'life0, 'life1, 'async_trait>( &'life0 self, offset: u64, buffer: BufferRef<'life1>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Writes the contents of |buffer| to the device at |offset|.

impl Drop for FakeDevice

fn drop(&mut self)

Executes the destructor for this type.