Struct Store

pub struct Store { /* private fields */ }

Manages the replicas and authors for an instance.

Implementations

impl Store

pub fn memory() -> Self

Create a new store in memory.

pub fn persistent(path: impl AsRef<Path>) -> Result<Self>

Create or open a store from a path to a database file.

The file will be created if it does not exist, otherwise it will be opened.

pub fn flush(&mut self) -> Result<()>

Flush the current transaction, if any.

This is the cheapest way to ensure that the data is persisted.

pub fn snapshot(&mut self) -> Result<&ReadOnlyTables>

Get a read-only snapshot of the database.

This has the side effect of committing any open write transaction, so it can be used as a way to ensure that the data is persisted.

pub fn snapshot_owned(&mut self) -> Result<ReadOnlyTables>

Get an owned read-only snapshot of the database.

This will open a new read transaction. The read transaction won’t be reused for other reads.

This has the side effect of committing any open write transaction, so it can be used as a way to ensure that the data is persisted.

impl Store

pub fn new_replica(&mut self, namespace: NamespaceSecret) -> Result<Replica<'_>>

Create a new replica for namespace and persist in this store.

pub fn new_author<R: CryptoRngCore + ?Sized>( &mut self, rng: &mut R, ) -> Result<Author>

Create a new author key and persist it in the store.

pub fn has_news_for_us( &mut self, namespace: NamespaceId, heads: &AuthorHeads, ) -> Result<Option<NonZeroU64>>

Check if a AuthorHeads contains entry timestamps that we do not have locally.

Returns the number of authors that the other peer has updates for.

pub fn open_replica( &mut self, namespace_id: &NamespaceId, ) -> Result<Replica<'_>, OpenError>

Open a replica from this store.

This just calls load_replica_info and then creates a new replica with the info.

pub fn load_replica_info( &mut self, namespace_id: &NamespaceId, ) -> Result<ReplicaInfo, OpenError>

Load the replica info from the store.

pub fn close_replica(&mut self, id: NamespaceId)

Close a replica.

pub fn list_namespaces( &mut self, ) -> Result<impl Iterator<Item = Result<(NamespaceId, CapabilityKind)>>>

List all replica namespaces in this store.

pub fn get_author(&mut self, author_id: &AuthorId) -> Result<Option<Author>>

Get an author key from the store.

pub fn import_author(&mut self, author: Author) -> Result<()>

Import an author key pair.

pub fn delete_author(&mut self, author: AuthorId) -> Result<()>

Delete an author.

pub fn list_authors(&mut self) -> Result<impl Iterator<Item = Result<Author>>>

List all author keys in this store.

pub fn import_namespace( &mut self, capability: Capability, ) -> Result<ImportNamespaceOutcome>

Import a new replica namespace.

pub fn remove_replica(&mut self, namespace: &NamespaceId) -> Result<()>

Remove a replica.

Completely removes a replica and deletes both the namespace private key and all document entries.

Note that a replica has to be closed before it can be removed. The store has to enforce that a replica cannot be removed while it is still open.

pub fn get_many( &mut self, namespace: NamespaceId, query: impl Into<Query>, ) -> Result<QueryIterator>

Get an iterator over entries of a replica.

pub fn get_exact( &mut self, namespace: NamespaceId, author: AuthorId, key: impl AsRef<[u8]>, include_empty: bool, ) -> Result<Option<SignedEntry>>

Get an entry by key and author.

pub fn content_hashes(&mut self) -> Result<ContentHashesIterator>

Get all content hashes of all replicas in the store.

pub fn get_latest_for_each_author( &mut self, namespace: NamespaceId, ) -> Result<LatestIterator<'_>>

Get the latest entry for each author in a namespace.

pub fn register_useful_peer( &mut self, namespace: NamespaceId, peer: PeerIdBytes, ) -> Result<()>

Register a peer that has been useful to sync a document.

pub fn get_sync_peers( &mut self, namespace: &NamespaceId, ) -> Result<Option<IntoIter<PeerIdBytes>>>

Get the peers that have been useful for a document.

pub fn set_download_policy( &mut self, namespace: &NamespaceId, policy: DownloadPolicy, ) -> Result<()>

Set the download policy for a namespace.

pub fn get_download_policy( &mut self, namespace: &NamespaceId, ) -> Result<DownloadPolicy>

Get the download policy for a namespace.

Trait Implementations

impl AsMut<Store> for Store

fn as_mut(&mut self) -> &mut Store

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Store> for Store

fn as_ref(&self) -> &Store

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for Store

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

Formats the value using the given formatter.

impl DownloadPolicyStore for Store

fn get_download_policy( &mut self, namespace: &NamespaceId, ) -> Result<DownloadPolicy>

Get the download policy for a document.

impl Drop for Store

fn drop(&mut self)

Executes the destructor for this type.

impl PublicKeyStore for Store

fn public_key(&self, id: &[u8; 32]) -> Result<VerifyingKey, SignatureError>

Convert a byte array into a [VerifyingKey].

fn namespace_key( &self, bytes: &NamespaceId, ) -> Result<NamespacePublicKey, SignatureError>

Convert a NamespaceId into a NamespacePublicKey.

fn author_key( &self, bytes: &AuthorId, ) -> Result<AuthorPublicKey, SignatureError>

Convert a AuthorId into a AuthorPublicKey.