1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#![doc(html_logo_url = "https://avatars2.githubusercontent.com/u/52050279?s=200&v=4")]
//! # 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:
//! ```rust
//! 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_core;
//! use blobstore::*;
//! use serde_json::json;
//! use log::{error, info};
//!
//! #[no_mangle]
//! pub fn wapc_init() {
//!     http::Handlers::register_handle_request(download_poem);
//!     blobstore::Handlers::register_receive_chunk(handle_chunk);
//!     actor_core::Handlers::register_health_request(health);
//! }
//!
//! /// Start the download of a blob (poem). Chunks will be streamed after download begins
//! fn download_poem(req: http::Request) -> HandlerResult<http::Response> {
//!     let stream_request = StreamRequest {
//!         id: req.path,
//!         container: Container::new("photos".to_string()),
//!         chunk_size: 4096,
//!         context: None
//!     };
//!     // replace `start_download` with `blobstore::default().start_download`
//!     match start_download(stream_request) {
//!         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.
//! 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(())
//! }
//!
//! fn health(_: actor_core::HealthCheckRequest) -> HandlerResult<actor_core::HealthCheckResponse> {
//!   Ok(actor_core::HealthCheckResponse::healthy())   
//! }
//!
//! # fn start_download(req: StreamRequest) -> HandlerResult<()> {
//! #   Ok(())
//! # }
//!
//! ```

mod generated;
#[allow(unused_imports)]
pub use generated::*;

/// Guest sends a Container to the capability provider, receives a Container back
pub const OP_CREATE_CONTAINER: &str = "CreateContainer";
/// Guest sends a Container to the capability provider, lack of error indicates success
pub const OP_REMOVE_CONTAINER: &str = "RemoveContainer";
/// Guest sends a Blob to the capability provider, lack of error indicates success
pub const OP_REMOVE_OBJECT: &str = "RemoveObject";
/// Guest sends a Container to the capability provider, receives a BlobList back
pub const OP_LIST_OBJECTS: &str = "ListObjects";
/// Guest sends a FileChunk to capability provider for storing as part of a Blob, lack of error indicates success
pub const OP_UPLOAD_CHUNK: &str = "UploadChunk";
/// 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
pub const OP_START_DOWNLOAD: &str = "StartDownload";
/// Guest sends a metadata-carrying FileChunk to initiate an upload, lack of error is success
pub const OP_START_UPLOAD: &str = "StartUpload";
/// Guest will receive a FileChunk for each piece of a file requested to download
pub const OP_RECEIVE_CHUNK: &str = "ReceiveChunk";
/// Query information on a single blob. Guest sends an incomplete blob struct and gets a complete one in return
pub const OP_GET_OBJECT_INFO: &str = "GetObjectInfo";

impl Container {
    pub fn new(id: impl Into<String>) -> Self {
        Container { id: id.into() }
    }
}