Crate arch_event_queues 

In-memory and RocksDB-backed event queues.

In-memory queue

Use EventQueue when events only need to live in memory.

use arch_event_queues::EventQueue;

#[derive(Debug, PartialEq, Eq)]
struct Event {
    payload: String,
}

let queue = EventQueue::<Event>::new();
queue
    .push(Event {
        payload: "created".to_string(),
    })
    .unwrap();

assert_eq!(
    queue.pop().unwrap(),
    Some(Event {
        payload: "created".to_string(),
    })
);

Durable queue

Use DurableEventQueue when events must survive process restarts until they are acknowledged.

use arch_event_queues::DurableEventQueue;
use borsh::{BorshDeserialize, BorshSerialize};

#[derive(Clone, Debug, PartialEq, Eq, BorshSerialize, BorshDeserialize)]
struct Event {
    payload: String,
}

let dir = tempfile::tempdir().unwrap();
let queue = DurableEventQueue::<Event>::open(dir.path()).unwrap();

let queued = queue
    .push(Event {
        payload: "index block".to_string(),
    })
    .unwrap();

let next = queue.pop().unwrap().expect("queued job");
assert_eq!(next.id, queued.id);

queue.ack(next.id).unwrap();

Re-exports

pub use durable_event_queue::DurableEvent;

pub use durable_event_queue::DurableEventQueue;

pub use durable_event_queue::DurableEventQueueError;

pub use durable_event_queue::DurableEventQueueIterator;

pub use durable_event_queue::DurableEventQueueOptions;

pub use event_queue::EventQueue;

pub use event_queue::EventQueueError;

Modules

durable_event_queue

event_queue