Struct libp2p_networking::network::behaviours::dht::store::persistent::PersistentStore

pub struct PersistentStore<R: RecordStore, D: DhtPersistentStorage> {
    underlying_record_store: R,
    persistent_storage: D,
    semaphore: Arc<Semaphore>,
    max_record_delta: u64,
    record_delta: Arc<AtomicU64>,
}

A RecordStore wrapper that occasionally saves the DHT to a persistent storage.

Fields

underlying_record_store: R

The underlying record store

persistent_storage: D

The persistent storage

semaphore: Arc<Semaphore>

The semaphore for limiting the number of concurrent operations (to one)

max_record_delta: u64

The maximum number of records that can be added to the store before the store is saved to the persistent storage

record_delta: Arc<AtomicU64>

The running delta between the records in the persistent storage and the records in the underlying store

Implementations

impl<R: RecordStore, D: DhtPersistentStorage> PersistentStore<R, D>

pub async fn new( underlying_record_store: R, persistent_storage: D, max_record_delta: u64, ) -> Self

Create a new PersistentStore with the given underlying store and path. On creation, the DHT is restored from the persistent storage if possible.

max_record_delta is the maximum number of records that can be added to the store before the store is saved to the persistent storage.

fn try_save_to_persistent_storage(&mut self) -> bool

Try saving the DHT to persistent storage if a task is not already in progress.

Returns true if the DHT was saved, false otherwise.

pub async fn restore_from_persistent_storage(&mut self) -> Result<()>

Attempt to restore the DHT to the underlying store from the persistent storage

Errors

• If we fail to load from the persistent storage

Trait Implementations

impl<R: RecordStore, D: DhtPersistentStorage> RecordStore for PersistentStore<R, D>

Implement the RecordStore trait for PersistentStore

fn put(&mut self, record: Record) -> Result<()>

Overwrite the put method to potentially sync the DHT to the persistent store

fn remove(&mut self, k: &RecordKey)

Overwrite the remove method to potentially sync the DHT to the persistent store

type ProvidedIter<'a> = <R as RecordStore>::ProvidedIter<'a> where R: 'a, D: 'a

type RecordsIter<'a> = <R as RecordStore>::RecordsIter<'a> where R: 'a, D: 'a

fn add_provider(&mut self, record: ProviderRecord) -> Result<()>

Adds a provider record to the store.

fn get(&self, k: &RecordKey) -> Option<Cow<'_, Record>>

Gets a record from the store, given its key.

fn provided(&self) -> Self::ProvidedIter<'_>

Gets an iterator over all stored provider records for which the node owning the store is itself the provider.

fn providers(&self, key: &RecordKey) -> Vec<ProviderRecord>

Gets a copy of the stored provider records for the given key.

fn records(&self) -> Self::RecordsIter<'_>

Gets an iterator over all (value-) records currently stored.

fn remove_provider(&mut self, k: &RecordKey, p: &PeerId)

Removes a provider record from the store.