Struct InMemoryCloudHome 

pub struct InMemoryCloudHome { /* private fields */ }

In-memory CloudHome backed by a HashMap. Clone shares one backing store, so clones act as separate devices reading and writing the same cloud bucket, and a test can keep its own handle for direct at-rest assertions while each device owns a Box<dyn CloudHome> clone.

Beyond the happy path it carries fault-injection knobs (arm_write_failures, fail_next_range_reads, remove) so a host test can drive upload-failure, read-retry, and missing-blob paths without a bespoke CloudHome impl. The arming state is shared across clones, like the backing store.

Implementations

impl InMemoryCloudHome

pub fn new() -> Self

pub fn with_provider_binding(self, binding: ResolvedProviderBinding) -> Self

pub fn sort_listings(&self)

Return list results in sorted key order instead of the backing map’s arbitrary order. A real bucket LIST has no defined order, so the pull’s cross-device apply order is arbitrary; a test that needs a fixed order (to reproduce an order-dependent bug deterministically) arms this and picks the order through its device ids.

pub fn arm_write_failures(&self)

Arm every subsequent write (put_object and open_multipart) to fail with a retryable transport error. A test can let a home’s setup writes land and then arm this before driving the path whose uploads must fail; it stays armed for the store’s lifetime.

pub fn fail_next_range_reads(&self, n: usize)

Make the next n read_range calls fail with a retryable transport error before any serves bytes, to exercise a caller’s read-retry path. Each failed call consumes one; once n are spent, ranges serve normally.

pub fn fail_exact_create_before_call(&self, call: usize)

Reset the exact-create counter and fail before the selected call stores bytes.

pub fn fail_exact_create_after_call(&self, call: usize)

Reset the exact-create counter and lose the response after the selected create.

pub fn corrupt_exact_readback_on_call(&self, call: usize)

Replace the selected exact object’s bytes before its verification read.

pub fn pause_after_exact_create_call( &self, call: usize, ) -> (Arc<Notify>, Arc<Notify>)

Pause after the selected exact create is physically visible.

pub fn pause_next_probe(&self) -> (Arc<Notify>, Arc<Notify>)

Pause the next reachability probe after it starts and before it succeeds.

pub fn exact_create_count(&self) -> usize

pub fn exact_full_read_count(&self) -> usize

pub fn exact_stream_read_count(&self) -> usize

pub fn exact_reads(&self) -> Vec<ObjectSlot>

pub fn clear_exact_reads(&self)

pub fn arm_exact_stream_read_concurrency_probe(&self, width: usize)

pub fn exact_stream_read_max_inflight(&self) -> usize

pub fn exact_delete_count(&self) -> usize

pub fn fail_exact_delete_on_call(&self, call: usize)

pub fn fail_nth_exact_delete_of(&self, slots: &[&ObjectSlot], nth: usize)

Fail the nth (1-based) delete of an object among slots, counting only deletes of those objects, then disarm. Unlike [fail_exact_delete_on_call], which counts every exact delete (probes, candidate cleanup), this counts only the identities that matter, so “fail the 2nd package delete” lands deterministically however many unrelated deletes interleave and whatever order the two package deletes arrive in.

pub fn remove(&self, key: &str)

Drop key’s bytes out of band — as if the object vanished from the bucket on its own, without a delete (which deletes_seen would record). Drives missing-blob read failures.

pub fn keys(&self) -> Vec<String>

Snapshot of every key currently in the cloud. Useful for assertions that don’t want to hold the lock across an await.

pub fn get(&self, key: &str) -> Option<Vec<u8>>

Snapshot of the bytes at key, or None if absent. Cloned so the caller can hold the result across await points without retaining the internal lock.

pub fn len(&self) -> usize

Number of objects stored. Cheap snapshot.

pub fn is_empty(&self) -> bool

Returns true if the store is empty.

pub fn deletes_seen(&self) -> Vec<String>

Snapshot of every delete that’s been requested, in arrival order.

pub fn insert_exact_object( &self, logical_key: &str, bytes: Vec<u8>, ) -> ObjectSlot

Insert caller-selected bytes at one exact logical slot.

pub fn stored_exact_bytes(&self, slot: &ObjectSlot) -> Option<Vec<u8>>

Snapshot the bytes stored at one exact slot, or None if absent.

pub fn restore_exact_object(&self, slot: &ObjectSlot, bytes: Vec<u8>)

Re-insert bytes at one exact slot, restoring an object dropped by remove_exact_object.

pub fn remove_exact_object(&self, slot: &ObjectSlot)

Remove one exact object without recording a protocol delete.

pub fn replace_exact_object(&self, slot: &ObjectSlot, bytes: Vec<u8>)

Replace bytes at one exact slot without changing its locator.

Trait Implementations

impl Clone for InMemoryCloudHome

fn clone(&self) -> InMemoryCloudHome

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CloudHome for InMemoryCloudHome

fn exact_slot_storage(self: Arc<Self>) -> Option<Arc<dyn ExactSlotStorage>>

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

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

Verify the backend is reachable with the configured credentials. Setup flows call this before persisting credentials, so a typo or missing bucket fails fast at setup time instead of via a delayed reconnect banner. Default implementation issues a no-op list against a sentinel prefix — backends override with cheaper provider-specific auth checks (e.g. S3 HeadBucket) where available.

fn put_object<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, data: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), CloudHomeError>> + Send + 'async_trait>>

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

One bounded single-request upload, creating or overwriting key. Used only for blobs at or below multipart_threshold; large blobs stream through open_multipart.

fn open_multipart<'a, 'life0, 'async_trait>( &'a self, key: &'life0 str, total_len: u64, ) -> Pin<Box<dyn Future<Output = Result<BoxPartSink<'a>, CloudHomeError>> + Send + 'async_trait>>

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

Open a streaming multipart/resumable upload for total_len bytes, returning the PartSink the driver pumps ordered parts into.

fn multipart_threshold(&self) -> u64

Blobs at or below this size go via put_object; larger ones stream via open_multipart.

fn read<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CloudHomeError>> + Send + 'async_trait>>

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

Read the full contents of a key.

fn read_range<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, start: u64, end: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CloudHomeError>> + Send + 'async_trait>>

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

Read a byte range from a key. start is inclusive, end is exclusive.

fn list<'life0, 'life1, 'async_trait>( &'life0 self, prefix: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, CloudHomeError>> + Send + 'async_trait>>

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

List all keys under a prefix.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), CloudHomeError>> + Send + 'async_trait>>

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

Delete a key. Not an error if the key does not exist.

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, CloudHomeError>> + Send + 'async_trait>>

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

Check whether a key exists.

fn set_access<'life0, 'async_trait>( &'life0 self, desired: CloudAccessState, ) -> Pin<Box<dyn Future<Output = Result<CloudAccessOutcome, CloudHomeError>> + Send + 'async_trait>>

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

Set the provider’s access for one stable member principal to the absolute desired state. Implementations read the authoritative permission state, create/update/delete as required, then read it back and verify the desired state. Repeating a request after an unknown outcome is therefore idempotent. Present returns connection information; Absent returns whether this provider supports withdrawing one member’s credential.

fn write<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, key: &'life1 str, body: BlobBody, progress: &'life2 UploadProgress<'life3>, ) -> Pin<Box<dyn Future<Output = Result<(), CloudHomeError>> + Send + 'async_trait>>

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

Write a sized BlobBody to key. Not overridden — the central [write_blob] driver picks single-request vs multipart and pumps the parts, reporting cumulative bytes through progress for the per-file bar.

impl Default for InMemoryCloudHome

fn default() -> Self

Returns the “default value” for a type.