Struct EventGraph

pub struct EventGraph {

    p2p: P2pPtr,
    dag: Tree,
    datastore: PathBuf,
    replay_mode: bool,
    unreferenced_tips: RwLock<BTreeMap<u64, HashSet<Hash>>>,
    broadcasted_ids: RwLock<HashSet<Hash>>,
    pub prune_task: OnceCell<StoppableTaskPtr>,
    pub event_pub: PublisherPtr<Event>,
    current_genesis: RwLock<Event>,
    days_rotation: u64,
    pub synced: RwLock<bool>,
    pub deg_enabled: RwLock<bool>,
    deg_publisher: PublisherPtr<DegEvent>,
}

An Event Graph instance

Fields

p2p: P2pPtr

Pointer to the P2P network instance

dag: Tree

Sled tree containing the DAG

datastore: PathBuf

Replay logs path.

replay_mode: bool

Run in replay_mode where if set we log Sled DB instructions into datastore, useful to reacreate a faulty DAG to debug.

unreferenced_tips: RwLock<BTreeMap<u64, HashSet<Hash>>>

The set of unreferenced DAG tips

broadcasted_ids: RwLock<HashSet<Hash>>

A HashSet containg event IDs and their 1-level parents. These come from the events we’ve sent out using EventPut. They are used with EventReq to decide if we should reply or not. Additionally it is also used when we broadcast the TipRep message telling peers about our unreferenced tips.

prune_task: OnceCell<StoppableTaskPtr>

DAG Pruning Task

event_pub: PublisherPtr<Event>

Event publisher, this notifies whenever an event is inserted into the DAG

current_genesis: RwLock<Event>

Current genesis event

days_rotation: u64

Currently configured DAG rotation, in days

synced: RwLock<bool>

Flag signalling DAG has finished initial sync

deg_enabled: RwLock<bool>

Enable graph debugging

deg_publisher: PublisherPtr<DegEvent>

The publisher for which we can give deg info over

Implementations

impl EventGraph

pub async fn new( p2p: P2pPtr, sled_db: Db, datastore: PathBuf, replay_mode: bool, dag_tree_name: &str, days_rotation: u64, ex: Arc<Executor<'_>>, ) -> Result<EventGraphPtr>

Create a new EventGraph instance, creates a new Genesis event and checks if it is containd in DAG, if not prunes DAG, may also start a pruning task based on days_rotation, and return an atomic instance of Self

• p2p atomic pointer to p2p.
• sled_db sled DB instance.
• datastore path where we should log db instrucion if run in replay mode.
• replay_mode set the flag to keep a log of db instructions.
• dag_tree_name the name of disk-backed tree (or DAG name).
• days_rotation marks the lifetime of the DAG before it’s pruned.

pub fn days_rotation(&self) -> u64

pub async fn dag_sync(&self) -> Result<()>

Sync the DAG from connected peers

async fn dag_prune(&self, genesis_event: Event) -> Result<()>

Atomically prune the DAG and insert the given event as genesis.

async fn dag_prune_task(self: Arc<Self>, days_rotation: u64) -> Result<()>

Background task periodically pruning the DAG.

pub async fn dag_insert(&self, events: &[Event]) -> Result<Vec<Hash>>

Atomically insert given events into the DAG and return the event IDs. All provided events must be valid. An overlay is used over the DAG tree, temporary writting each event in order. After all events have been validated and inserted successfully, we write the overlay to sled. This will append the new events into the unreferenced tips set, and remove the events’ parents from it. It will also append the events’ level-1 parents to the broadcasted_ids set, so the P2P protocol knows that any requests for them are actually legitimate. TODO: The broadcasted_ids set should periodically be pruned, when some sensible time has passed after broadcasting the event.

pub async fn dag_get(&self, event_id: &Hash) -> Result<Option<Event>>

Fetch an event from the DAG

async fn get_next_layer_with_parents(&self) -> (u64, [Hash; 5])

Get next layer along with its N_EVENT_PARENTS from the unreferenced tips of the DAG. Since tips are mapped by their layer, we go backwards until we fill the vector, ensuring we always use latest layers tips as parents.

async fn find_unreferenced_tips(&self) -> BTreeMap<u64, HashSet<Hash>>

Find the unreferenced tips in the current DAG state, mapped by their layers.

async fn get_unreferenced_tips_sorted(&self) -> [Hash; 5]

Internal function used for DAG sorting.

pub async fn order_events(&self) -> Vec<Event>

Perform a topological sort of the DAG.

async fn dfs_topological_sort( &self, event: Event, visited: &mut HashSet<Hash>, ) -> VecDeque<(u64, Event)>

We do a non-recursive DFS (https://en.wikipedia.org/wiki/Depth-first_search), and additionally we consider the timestamps.

pub async fn deg_enable(&self)

Enable graph debugging

pub async fn deg_disable(&self)

Disable graph debugging

pub async fn deg_subscribe(&self) -> Subscription<DegEvent>

Subscribe to deg events

pub async fn deg_notify(&self, event: DegEvent)

Send a deg notification over the publisher

pub async fn eventgraph_info(&self, id: u16, _params: JsonValue) -> JsonResult

pub async fn fetch_successors_of( &self, tips: BTreeMap<u64, HashSet<Hash>>, ) -> Result<Vec<Event>>

Fetch all the events that are on a higher layers than the provided ones.