Struct MemoryBlob 

pub struct MemoryBlob { /* private fields */ }

An in-memory cratefield_core::Blob store for module tests. MemoryBlob::new has no presigned URLs (signed_url reports Unsupported, as a directory store does); MemoryBlob::with_presign signs real SigV4 URLs that MemoryBlob::verify_presigned checks back.

Implementations

impl MemoryBlob

pub fn new() -> Self

pub fn with_presign(clock: Arc<dyn Clock>) -> Self

Opts the store into presigning: signed_url and signed_put_url sign real SigV4 URLs stamped from clock, checked back by verify_presigned.

pub fn len(&self) -> usize

How many objects are stored, for assertions.

pub fn is_empty(&self) -> bool

Whether the store is empty, for assertions.

pub fn verify_presigned( &self, url: &str, method: &str, headers: &[(String, String)], ) -> Result<String, SigV4Error>

Verifies a URL this store minted, at its clock’s current time, and returns the key it names.

Errors

As sigv4::verify_presigned, or SigV4Error::Malformed without a clock or a URL path.

Trait Implementations

impl Blob for MemoryBlob

fn put<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, key: &'life1 str, bytes: &'life2 [u8], content_type: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), BlobError>> + Send + 'async_trait>>

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

Stores bytes at key with content_type, replacing any existing object. Implementations MUST reject a payload larger than MAX_BLOB_BYTES with BlobError::TooLarge via check_blob_size, before writing (issue #136).

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

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

Fetches the object at key, or None if there is none.

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

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

Removes the object at key. Idempotent: removing a missing key is Ok.

fn signed_url<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<String, BlobError>> + Send + 'async_trait>>

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

A presigned GET for key, valid for ttl: a URL that serves the object directly, skipping the Worker. Adapters without presigned URLs (a directory store) return BlobError::Unsupported; callers then serve the bytes through get. The URL’s query string is a bearer credential: never log it.

fn signed_put_url<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, content_type: &'life2 str, content_length: Option<u64>, ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<PresignedPut, BlobError>> + Send + 'async_trait>>

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

A presigned PUT for key with content_type, valid for ttl.

fn put_stream<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, body: BoxStream<'static, Result<Bytes, StreamError>>, content_type: &'life2 str, max_bytes: u64, ) -> Pin<Box<dyn Future<Output = Result<u64, BlobError>> + Send + 'async_trait>>

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

Stores a streamed body at key (issue #586), for an object larger than the MAX_BLOB_BYTES buffered path allows, and returns the number of bytes written. max_bytes is the caller’s ceiling; adapters MUST enforce it (typically by wrapping body in limit_stream) and, once it is passed, answer BlobError::TooLarge and leave no object behind.

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

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

Fetches the object at key as a stream (issue #586), or None if there is none. The size and content type are known before the body is read, so a handler can set headers and hand the body on without buffering it.

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

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

Reports the object’s metadata without reading its bytes (issue #586), or None if there is none.

fn list<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, prefix: &'life1 str, cursor: Option<&'life2 str>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<BlobPage, BlobError>> + Send + 'async_trait>>

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

Lists stored objects whose key starts with prefix (issue #586), newest page at a time. Keys are returned in lexicographic order; cursor is the opaque token from the previous BlobPage, or None to start at the beginning. Adapters cap limit at MAX_LIST_LIMIT.

fn create_multipart<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, content_type: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<UploadId, BlobError>> + Send + 'async_trait>>

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

Starts a multipart upload for key with content_type (issue #586) and returns its id. Parts are then written with upload_part and the object is made visible by complete_multipart; an upload the module abandons must be abort_multiparted, or reclaimed by an R2 lifecycle rule, or its parts linger.

fn upload_part<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, upload_id: &'life2 UploadId, part_number: u16, body: BoxStream<'static, Result<Bytes, StreamError>>, max_part_bytes: u64, ) -> Pin<Box<dyn Future<Output = Result<PartReceipt, BlobError>> + Send + 'async_trait>>

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

Uploads one part of a multipart upload (issue #586), 1 ..= MAX_MULTIPART_PARTS, and returns its PartReceipt. max_part_bytes is the caller’s ceiling, enforced like put_stream’s. Every part but the last listed in complete_multipart must be at least MIN_MULTIPART_PART_BYTES; adapters may enforce it at complete, when the last part is known.

fn complete_multipart<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, key: &'life1 str, upload_id: &'life2 UploadId, parts: &'life3 [PartReceipt], ) -> Pin<Box<dyn Future<Output = Result<(), BlobError>> + Send + 'async_trait>>

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

Assembles the parts listed in parts (in ascending part order) into the object at key and ends the upload (issue #586). A part whose ETag does not match what was uploaded is refused; an unknown upload id is BlobError::Operation.

fn abort_multipart<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, upload_id: &'life2 UploadId, ) -> Pin<Box<dyn Future<Output = Result<(), BlobError>> + Send + 'async_trait>>

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

Abandons a multipart upload (issue #586), discarding its parts. An unknown upload id is BlobError::Operation.

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

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

Lists the module’s multipart uploads in flight whose key starts with prefix (issue #586), so it can abort the ones it abandoned.

impl Clone for MemoryBlob

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for MemoryBlob

fn default() -> Self

Returns the “default value” for a type.