Struct AckTicket 

pub struct AckTicket { /* private fields */ }

Durability handle associated with the write operation

Epoch

Every ticket is assigned a monotonically increasing epoch to moniter durability

Durability Guarantee

If wanted, the ticket could be awaited to poll till the epoch becomes durable.

Once a await on ticket is completed successfully, all writes assigned to earlier epochs are also guaranteed to be durable.

NOTE: Using await is optional. Callers that only require fire-and-forget semantics may simply discard the returned ticket.

Implementations

impl AckTicket

pub const fn new(epoch: TEpoch, completion: Arc<Completion>) -> Self

Construct a new AckTicket for a write operation

Example

use frozen_core::ack::{AckTicket, Completion};
use std::sync::Arc;

let completion = Arc::new(Completion::default());
let ticket = AckTicket::new(1, completion);

assert_eq!(ticket.epoch(), 1);

pub const fn epoch(&self) -> TEpoch

Read assigned durability epoch for the AckTicket

Example

use frozen_core::ack::{AckTicket, Completion};
use std::sync::Arc;

let completion = Arc::new(Completion::default());
let ticket = AckTicket::new(0x4C, completion);

assert_eq!(ticket.epoch(), 0x4C);

pub fn wait(&self) -> FrozenResult<TEpoch>

Blocks the current thread unitl the AckTicket becomes durable

If a durability error is reported before the epoch becomes durable, the corresponding FrozenError is returned instead.

Example

use frozen_core::ack::{AckTicket, Completion};
use std::{sync::Arc, thread, time};

let completion = Arc::new(Completion::default());
let epoch = completion.increment_current_epoch();
let ticket = AckTicket::new(epoch, completion.clone());

thread::spawn({
    let completion = completion.clone();

    move || {
        thread::sleep(time::Duration::from_millis(10));
        completion.mark_epoch_as_durable(epoch);
        completion.notify_all_listeners();
    }
});

assert_eq!(ticket.wait().unwrap(), epoch);

Trait Implementations

impl Debug for AckTicket

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Future for AckTicket

type Output = Result<u64, FrozenError>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.