Crate wasmcloud_actor_blobstore

Expand description

§wasmCloud Blob Store Actor Interface

This crate provides wasmCloud actors with an interface to the blobstore capability provider. Actors using this interface must have the claim wasmcloud:blobstore in order to have permission to communicate with the store.

This generic protocol can be used to support capability providers like local blob storage, Amazon S3, Azure blob storage, Google blob storage, and more.

§Example:

extern crate wapc_guest as guest;
use guest::prelude::*;
use wasmcloud_actor_blobstore as blobstore;
use wasmcloud_actor_http_server as http;
use wasmcloud_actor_core::serialize;
use wasmcloud_actor_core as actor;
use blobstore::*;
use serde_json::json;
use log::{error, info};

#[actor::init]
fn init() {
    http::Handlers::register_handle_request(download_poem);
    blobstore::Handlers::register_receive_chunk(handle_chunk);
}

/// Start the download of a blob (poem). Chunks will be streamed after download begins
fn download_poem(req: http::Request) -> HandlerResult<http::Response> {
    // replace `start_download` with `blobstore::default().start_download`
    match start_download(req.path, "poems".to_string(), 4096, None) {
        Ok(_) => Ok(http::Response::ok()),
        Err(_) => Err("Failed to initiate download of chunk".into())
    }
}

/// Handle the incoming chunk as a poem "verse" and log the result
/// Note that these chunks can be received out of order, so the poem
/// in this case might be displayed in a different order and could look
/// funny if the verse continues across a chunk boundary
fn handle_chunk(chunk: FileChunk) -> HandlerResult<()> {
    let verse = String::from_utf8(chunk.chunk_bytes)?;
    info!("Poem {} part {}:\n{}", chunk.id, chunk.sequence_no, verse);
    Ok(())
}

Structs§

Blob: A blob is a representation of an object in a blobstore, similar to a file in a file system.
BlobList: A wrapper object around a list of blobs.
BlobstoreResult: Used to return success and error information for common blobstore operations
Container: A container is a logical grouping of blobs, similar to a directory in a file system.
ContainerList: A wrapper object around a list of containers.
CreateContainerArgs
FileChunk: Represents a single chunk that may comprise part of a file or an entire file. The fields for sequence number, total bytes and chunk bytes should be used to determine the chunk order, as well as the optional context field.
GetObjectInfoArgs
Handlers
Host
ListObjectsArgs
ReceiveChunkArgs
RemoveContainerArgs
RemoveObjectArgs
StartDownloadArgs
StartUploadArgs
Transfer
UploadChunkArgs

Constants§

OP_CREATE_CONTAINER: Guest sends a Container to the capability provider, receives a Container back
OP_GET_OBJECT_INFO: Query information on a single blob. Guest sends an incomplete blob struct and gets a complete one in return
OP_LIST_OBJECTS: Guest sends a Container to the capability provider, receives a BlobList back
OP_RECEIVE_CHUNK: Guest will receive a FileChunk for each piece of a file requested to download
OP_REMOVE_CONTAINER: Guest sends a Container to the capability provider, lack of error indicates success
OP_REMOVE_OBJECT: Guest sends a Blob to the capability provider, lack of error indicates success
OP_START_DOWNLOAD: Guest sends a StreamRequest to the capability provider, immediate termination w/success. Guest will then start receiving OP_RECEIVE_CHUNK operations from the provider as chunks are streamed to the guest
OP_START_UPLOAD: Guest sends a metadata-carrying FileChunk to initiate an upload, lack of error is success
OP_UPLOAD_CHUNK: Guest sends a FileChunk to capability provider for storing as part of a Blob, lack of error indicates success

Functions§

default: Creates the default host binding
deserialize: The standard function for de-serializing codec structs from a format suitable for message exchange between actor and host. Use of any other function to deserialize could result in breaking incompatibilities.
host: Creates a named host binding
serialize: The standard function for serializing codec structs into a format that can be used for message exchange between actor and host. Use of any other function to serialize could result in breaking incompatibilities.