Struct blip::service::cache::Cache

pub struct Cache<S: ?Sized = dyn Source>(_);

This is supported on feature="cache" only.

A distributed binary cache. May be used standalone, or added to a Mesh to operate in networked mode.

Examples

use blip::service::Cache;
use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};

let loads = AtomicUsize::new(0);
let c = Cache::from_fn(32, move |key| {
    assert_eq!(0, loads.swap(1, SeqCst));
    key.into()
});

let val = c.get("test key").await?;
assert_eq!(&*val, b"test key");
let val = c.get("test key").await?;
assert_eq!(&*val, b"test key");

Implementations

impl Cache

pub fn new<S: Source>(max_keys: usize, source: S) -> Self

This is supported on feature="cache" only.

Create a new cache from a Source. At most max_keys + (max_keys / 8) keys will be cached locally at any point in time.

Panics

Panics if max_keys == 0.

Examples

use blip::service::{cache::Source, Cache};
use tonic::Status;

struct Echo;

#[blip::async_trait]
impl Source for Echo {
    async fn get(&self, key: &[u8]) -> Result<Vec<u8>, Status> {
        Ok(key.into())
    }
}

let cache = Cache::new(1024, Echo);

pub fn from_fn<F>(max_keys: usize, source: F) -> Self where
    F: Sync + Send + 'static + Fn(&[u8]) -> Vec<u8>, 

This is supported on feature="cache" only.

Create a new cache from a source Fn. At most max_keys + (max_keys / 8) keys will be cached locally at any point in time.

Panics

Panics if max_keys == 0.

Examples

use blip::service::Cache;

let cache = Cache::from_fn(1024, |key| key.into());

pub async fn get<'_, K: Into<Bytes>>(&'_ self, key: K) -> Result<Bytes, Status>

This is supported on feature="cache" only.

Retrieve the value associated with key.

Trait Implementations

impl<S: ?Sized> Clone for Cache<S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ExposedService for Cache

fn add_metadata<K: Extend<(String, Vec<u8>)>>(&self, keys: &mut K)

Add metadata to distribute to other members of the mesh.

type Service = CacheServer<Self>

The service implementation.

fn into_service(self) -> Self::Service

Convert self into a Service.

impl MeshService for Cache

fn accept<'async_trait>(
    self: Box<Self>,
    cuts: Subscription
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    Self: 'async_trait, 

Receive accepted view-change proposals.