Struct async_nats::jetstream::object_store::ObjectStore

pub struct ObjectStore { /* private fields */ }

A blob store capable of storing large objects efficiently in streams.

Implementations

impl ObjectStore

pub async fn get<T: AsRef<str> + Send>( &self, object_name: T, ) -> Result<Object, GetError>

Gets an Object from the ObjectStore.

Object implements tokio::io::AsyncRead that allows to read the data from Object Store.

Examples

use tokio::io::AsyncReadExt;
let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let bucket = jetstream.get_object_store("store").await?;
let mut object = bucket.get("FOO").await?;

// Object implements `tokio::io::AsyncRead`.
let mut bytes = vec![];
object.read_to_end(&mut bytes).await?;

pub async fn delete<T: AsRef<str>>( &self, object_name: T, ) -> Result<(), DeleteError>

Deletes an Object from the ObjectStore.

Examples

let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let bucket = jetstream.get_object_store("store").await?;
bucket.delete("FOO").await?;

pub async fn info<T: AsRef<str>>( &self, object_name: T, ) -> Result<ObjectInfo, InfoError>

Retrieves Object ObjectInfo.

Examples

let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let bucket = jetstream.get_object_store("store").await?;
let info = bucket.info("FOO").await?;

pub async fn put<T>( &self, meta: T, data: &mut (impl AsyncRead + Unpin), ) -> Result<ObjectInfo, PutError>

where ObjectMetadata: From<T>,

Puts an Object into the ObjectStore. This method implements tokio::io::AsyncRead.

Examples

let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let bucket = jetstream.get_object_store("store").await?;
let mut file = tokio::fs::File::open("foo.txt").await?;
bucket.put("file", &mut file).await.unwrap();

pub async fn watch(&self) -> Result<Watch, WatchError>

Creates a Watch stream over changes in the ObjectStore.

Examples

use futures::StreamExt;
let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let bucket = jetstream.get_object_store("store").await?;
let mut watcher = bucket.watch().await.unwrap();
while let Some(object) = watcher.next().await {
    println!("detected changes in {:?}", object?);
}

pub async fn watch_with_history(&self) -> Result<Watch, WatchError>

Creates a Watch stream over changes in the ObjectStore which yields values whenever there are changes for that key with as well as last value.

pub async fn list(&self) -> Result<List, ListError>

Returns a List stream with all not deleted Objects in the ObjectStore.

Examples

use futures::StreamExt;
let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let bucket = jetstream.get_object_store("store").await?;
let mut list = bucket.list().await.unwrap();
while let Some(object) = list.next().await {
    println!("object {:?}", object?);
}

pub async fn seal(&mut self) -> Result<(), SealError>

Seals a ObjectStore, preventing any further changes to it or its Objects.

Examples

use futures::StreamExt;
let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let mut bucket = jetstream.get_object_store("store").await?;
bucket.seal().await.unwrap();

pub async fn update_metadata<A: AsRef<str>>( &self, object: A, metadata: UpdateMetadata, ) -> Result<ObjectInfo, UpdateMetadataError>

Updates Object ObjectMetadata.

Examples

use async_nats::jetstream::object_store;
let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);

let mut bucket = jetstream.get_object_store("store").await?;
bucket
    .update_metadata(
        "object",
        object_store::UpdateMetadata {
            name: "new_name".to_string(),
            description: Some("a new description".to_string()),
        },
    )
    .await?;

pub async fn add_link<'a, T, O>( &self, name: T, object: O, ) -> Result<ObjectInfo, AddLinkError>

where T: ToString, O: AsObjectInfo,

Adds a link to an Object. It creates a new Object in the ObjectStore that points to another Object and does not have any contents on it’s own. Links are automatically followed (one level deep) when calling ObjectStore::get.

Examples

use async_nats::jetstream::object_store;
let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);
let bucket = jetstream.get_object_store("bucket").await?;
let object = bucket.get("object").await?;
bucket.add_link("link_to_object", &object).await?;

pub async fn add_bucket_link<T: ToString, U: ToString>( &self, name: T, bucket: U, ) -> Result<ObjectInfo, AddLinkError>

Adds a link to another ObjectStore bucket by creating a new Object in the current ObjectStore that points to another ObjectStore and does not contain any data.

Examples

use async_nats::jetstream::object_store;
let client = async_nats::connect("demo.nats.io").await?;
let jetstream = async_nats::jetstream::new(client);
let bucket = jetstream.get_object_store("bucket").await?;
bucket
    .add_bucket_link("link_to_object", "another_bucket")
    .await?;

Trait Implementations

impl Clone for ObjectStore

fn clone(&self) -> ObjectStore

Returns a copy of the value.

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

Performs copy-assignment from source.