Struct nats::object_store::ObjectStore

pub struct ObjectStore { /* private fields */ }

Available on crate feature unstable only.

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

Implementations

impl ObjectStore

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

Retrieve the current information for the object.

Examples

let bucket = context.create_object_store(&Config {
  bucket: "info".to_string(),
  ..Default::default()
})?;

let bytes = vec![0];
let info = bucket.put("foo", &mut bytes.as_slice())?;
assert_eq!(info.name, "foo");
assert_eq!(info.size, bytes.len());

pub fn seal(&self) -> Result<()>

Seals the object store from further modifications.

pub fn put<T>(&self, meta: T, data: &mut impl Read) -> Result<ObjectInfo> where
    ObjectMeta: From<T>, 

Put will place the contents from the given reader into this object-store.

Example

let bucket = context.create_object_store(&Config {
  bucket: "put".to_string(),
  ..Default::default()
})?;

let bytes = vec![0, 1, 2, 3, 4];
let info = bucket.put("foo", &mut bytes.as_slice())?;
assert_eq!(bucket.info("foo").unwrap(), info);

pub fn get(&self, object_name: &str) -> Result<Object>

Get an existing object by name.

Example

use std::io::Read;
let bucket = context.create_object_store(&Config {
  bucket: "get".to_string(),
  ..Default::default()
})?;

let bytes = vec![0, 1, 2, 3, 4];
let info = bucket.put("foo", &mut bytes.as_slice())?;

let mut result = Vec::new();
bucket.get("foo").unwrap().read_to_end(&mut result)?;

pub fn delete(&self, object_name: &str) -> Result<()>

Places a delete marker and purges the data stream associated with the key.

Example

use std::io::Read;
let bucket = context.create_object_store(&Config {
  bucket: "delete".to_string(),
  ..Default::default()
})?;

let bytes = vec![0, 1, 2, 3, 4];
bucket.put("foo", &mut bytes.as_slice())?;

bucket.delete("foo")?;

let info = bucket.info("foo")?;
assert!(info.deleted);
assert_eq!(info.size, 0);
assert_eq!(info.chunks, 0);

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

Watch for changes in the underlying store and receive meta information updates.

Example

use std::io::Read;
let bucket = context.create_object_store(&Config {
  bucket: "watch".to_string(),
  ..Default::default()
})?;

let mut watch = bucket.watch()?;

let bytes = vec![0, 1, 2, 3, 4];
bucket.put("foo", &mut bytes.as_slice())?;

let info = watch.next().unwrap();
assert_eq!(info.name, "foo");
assert_eq!(info.size, bytes.len());

let bytes = vec![0];
bucket.put("bar", &mut bytes.as_slice())?;

let info = watch.next().unwrap();
assert_eq!(info.name, "bar");
assert_eq!(info.size, bytes.len());