Struct pravega_client::sync::Synchronizer

pub struct Synchronizer { /* private fields */ }

Provide a map that is synchronized across different processes.

The goal is to have a map that can be updated by using Insert or Remove. Each process can do updates to its in memory map by supplying a function to create Insert/Remove objects. Updates from other processes can be obtained by calling fetchUpdates().

The name of the Synchronizer is also the stream name of the table segment. Different instances of Synchronizer with same name will point to the same table segment.

Exmaples

// two synchronizer instances with the same name can communicate with each other.
let mut synchronizer1 = client_factory
    .create_synchronizer(scope.clone(), "synchronizer".to_owned())
    .await;

let mut synchronizer2 = client_factory
    .create_synchronizer(scope.clone(), "synchronizer".to_owned())
    .await;

let result = synchronizer1
    .insert(|table| {
        table.insert(
            "outer_key_foo".to_owned(),
            "inner_key_bar".to_owned(),
            "i32".to_owned(),
            Box::new(1),
        );
        Ok(None)
    })
    .await;
assert!(result.is_ok());

let entries_num = synchronizer2.fetch_updates().await.expect("fetch updates");
assert_eq!(entries_num, 1);
let value_option = synchronizer2.get("outer_key_foo", "inner_key_bar");
assert!(value_option.is_some());

Implementations

impl Synchronizer

pub fn get_outer_map(&self) -> HashMap<String, HashMap<String, Value>>

Get the outer map currently held in memory. The return type does not contain the version information.

pub fn get_inner_map(&self, outer_key: &str) -> HashMap<String, Value>

Get the inner map currently held in memory. The return type does not contain the version information.

pub fn get_name(&self) -> String

Get the name of the Synchronizer.

pub fn get(&self, outer_key: &str, inner_key: &str) -> Option<&Value>

Get the Value associated with the map. The data in Value is not deserialized and the caller should call deserialize_from to deserialize.

pub fn get_key_version( &self, outer_key: &str, inner_key: &Option<String> ) -> Version

Get the Key version of the given key,

pub async fn fetch_updates(&mut self) -> Result<i32, TableError>

Fetch the latest map from remote server and apply it to the local map.

pub async fn insert<R>( &mut self, updates_generator: impl FnMut(&mut Update) -> Result<R, SynchronizerError> ) -> Result<R, SynchronizerError>

Insert/Update a list of keys and applies it atomically to the local map. This will update the local map to the latest version.

pub async fn remove<R>( &mut self, deletes_generator: impl FnMut(&mut Update) -> Result<R, SynchronizerError> ) -> Result<R, SynchronizerError>

Remove a list of keys and apply it atomically to local map. This will update the local map to latest version.