Struct ate::prelude::Chain

pub struct Chain { /* fields omitted */ }

Represents the main API to access a specific chain-of-trust

This object must stay within scope for the duration of its use which has been optimized for infrequent initialization as creating this object will reload the entire chain’s metadata into memory.

The actual data of the chain is stored locally on disk thus huge chains can be stored here however very random access on large chains will result in random access IO on the disk.

Chains also allow subscribe/publish models to be applied to particular vectors (see the examples for details)

Implementations

impl<'a> Chain

pub async fn backup(
    &'a self,
    include_active_files: bool
) -> Result<(), SerializationError>

impl<'a> Chain

pub async fn compact(self: &'a Chain) -> Result<(), CompactError>

impl<'a> Chain

pub fn key(&'a self) -> &'a ChainKey

pub fn remote_addr(&'a self) -> Option<&'a MeshAddress>

pub async fn single(&'a self) -> ChainSingleUser<'a>

pub async fn multi(&'a self) -> ChainMultiUser

pub async fn name(&'a self) -> String

pub fn default_format(&'a self) -> MessageFormat

pub async fn count(&'a self) -> usize

pub async fn flush(&'a self) -> Result<(), Error>

pub async fn sync(&'a self) -> Result<(), CommitError>

pub async fn sync_ext(&'a self, timeout: Duration) -> Result<(), CommitError>

pub async fn shutdown(&self) -> Result<(), CompactError>

pub fn metrics(&'a self) -> &'a Arc<StdMutex<Metrics>>

pub fn throttle(&'a self) -> &'a Arc<StdMutex<Throttle>>

impl<'a> Chain

pub async fn new_ext(
    builder: ChainBuilder,
    key: ChainKey,
    extra_loader: Option<Box<dyn Loader>>,
    allow_process_errors: bool,
    load_integrity: TrustMode,
    idle_integrity: TrustMode
) -> Result<Chain, ChainCreationError>

impl<'a> Chain

pub async fn rotate(&'a self) -> Result<(), SerializationError>

impl Chain

pub async fn dio(self: &Arc<Chain>, session: &dyn AteSession) -> Arc<Dio>

Opens a data access layer that allows read only access to data within the chain In order to make changes to data you must use ‘.dio_mut’, ‘.dio_fire’, ‘.dio_full’ or ‘.dio_trans’

impl Chain

pub async fn dio_mut(self: &Arc<Chain>, session: &dyn AteSession) -> Arc<DioMut>

Opens a data access layer that allows mutable changes to data. Transaction consistency on commit will be guarranted for local redo log files

pub async fn dio_fire(
    self: &Arc<Chain>,
    session: &dyn AteSession
) -> Arc<DioMut>

Opens a data access layer that allows mutable changes to data (in a fire-and-forget mode). No transaction consistency on commits will be enforced

pub async fn dio_full(
    self: &Arc<Chain>,
    session: &dyn AteSession
) -> Arc<DioMut>

Opens a data access layer that allows mutable changes to data. Transaction consistency on commit will be guarranted for all remote replicas

pub async fn dio_trans(
    self: &Arc<Chain>,
    session: &dyn AteSession,
    scope: TransactionScope
) -> Arc<DioMut>

Opens a data access layer that allows mutable changes to data. Transaction consistency on commit must be specified

impl Chain

pub async fn invoke<REQ, RES, ERR>(
    self: Arc<Self>,
    request: REQ
) -> Result<Result<RES, ERR>, InvokeError> where
    REQ: Clone + Serialize + DeserializeOwned + Sync + Send + ?Sized,
    RES: Serialize + DeserializeOwned + Sync + Send + ?Sized,
    ERR: Serialize + DeserializeOwned + Sync + Send + ?Sized, 

pub async fn invoke_ext<REQ, RES, ERR>(
    self: Arc<Self>,
    session: Option<&dyn AteSession>,
    request: REQ,
    timeout: Duration
) -> Result<Result<RES, ERR>, InvokeError> where
    REQ: Clone + Serialize + DeserializeOwned + Sync + Send + ?Sized,
    RES: Serialize + DeserializeOwned + Sync + Send + ?Sized,
    ERR: Serialize + DeserializeOwned + Sync + Send + ?Sized, 

impl Chain

pub fn add_service<CTX, REQ, RES, ERR, C, F>(
    self: &Arc<Self>,
    session: &dyn AteSession,
    context: Arc<CTX>,
    callback: C
) -> Arc<ServiceHook> where
    CTX: Send + Sync + 'static,
    REQ: DeserializeOwned + Send + Sync + Sized + 'static,
    RES: Serialize + Send + Sync + Sized + 'static,
    ERR: Serialize + Send + Sync + Sized + 'static,
    C: Fn(Arc<CTX>, REQ) -> F + Send + 'static,
    F: Future<Output = Result<RES, ERR>> + Send + 'static, 

pub fn add_generic_service(
    self: &Arc<Self>,
    session: Box<dyn AteSession>,
    handler: &Arc<dyn ServiceInvoker>
) -> Arc<ServiceHook>

Trait Implementations

impl Clone for Chain

fn clone(&self) -> Chain

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Drop for Chain

fn drop(&mut self)

Executes the destructor for this type.