Struct Database

pub struct Database {
    pub db: Arc<ConnectionThreadSafe>,
}

A file-backed database storing information about the network.

Fields

db: Arc<ConnectionThreadSafe>

Implementations

impl Database

pub fn open<P>(path: P) -> Result<Database, Error>

where P: AsRef<Path>,

Open a database at the given path. Creates a new database if it doesn’t exist.

pub fn reader<P>(path: P) -> Result<Database, Error>

where P: AsRef<Path>,

Same as Self::open, but in read-only mode. This is useful to have multiple open databases, as no locking is required.

pub fn journal_mode(self, mode: JournalMode) -> Result<Database, Error>

Set journal mode.

pub fn init<'a>( self, node: &PublicKey, features: Features, alias: &Alias, agent: &UserAgent, timestamp: Timestamp, addrs: impl IntoIterator<Item = &'a Address>, ) -> Result<Database, Error>

Initialize by adding our local node to the database.

pub fn memory() -> Result<Database, Error>

Create a new in-memory database.

pub fn version(&self) -> Result<usize, Error>

Get the database version. This is updated on schema changes.

pub fn bump(&self) -> Result<usize, Error>

Bump the database version.

Methods from Deref<Target = Connection>

pub fn execute<T>(&self, statement: T) -> Result<(), Error>

where T: AsRef<str>,

Execute a statement without processing the resulting rows if any.

pub fn iterate<T, F>(&self, statement: T, callback: F) -> Result<(), Error>

where T: AsRef<str>, F: FnMut(&[(&str, Option<&str>)]) -> bool,

Execute a statement and process the resulting rows as plain text.

The callback is triggered for each row. If the callback returns false, no more rows will be processed. For large queries and non-string data types, prepared statement are highly preferable; see prepare.

pub fn prepare<T>(&self, statement: T) -> Result<Statement<'_>, Error>

where T: AsRef<str>,

Create a prepared statement.

pub fn set_busy_handler<F>(&mut self, callback: F) -> Result<(), Error>

where F: FnMut(usize) -> bool + Send + 'static,

Set a callback for handling busy events.

The callback is triggered when the database cannot perform an operation due to processing of some other request. If the callback returns true, the operation will be repeated.

pub fn set_busy_timeout(&mut self, milliseconds: usize) -> Result<(), Error>

Set an implicit callback for handling busy events that tries to repeat rejected operations until a timeout expires.

pub fn remove_busy_handler(&mut self) -> Result<(), Error>

Remove the callback handling busy events.

pub fn change_count(&self) -> usize

Return the number of rows inserted, updated, or deleted by the most recent INSERT, UPDATE, or DELETE statement.

pub fn total_change_count(&self) -> usize

Return the total number of rows inserted, updated, and deleted by all INSERT, UPDATE, and DELETE statements since the connection was opened.

Trait Implementations

impl Clone for Database

fn clone(&self) -> Database

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Database

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

Formats the value using the given formatter.

impl Deref for Database

type Target = ConnectionThreadSafe

The resulting type after dereferencing.

fn deref(&self) -> &<Database as Deref>::Target

Dereferences the value.

impl From<ConnectionThreadSafe> for Database

fn from(db: ConnectionThreadSafe) -> Database

Converts to this type from the input type.

impl Store for Database

fn get(&self, node: &PublicKey) -> Result<Option<Node>, Error>

Get the information we have about a node.

fn is_addr_banned(&self, addr: &Address) -> Result<bool, Error>

Check if an address is banned. Also returns true if the node this address belongs to is banned.

fn is_ip_banned(&self, ip: IpAddr) -> Result<bool, Error>

Check if an IP is banned.

fn addresses_of(&self, node: &PublicKey) -> Result<Vec<KnownAddress>, Error>

Get the addresses of a node.

fn len(&self) -> Result<usize, Error>

Returns the number of addresses.

fn nodes(&self) -> Result<usize, Error>

Return the number of nodes.

fn insert( &mut self, node: &PublicKey, version: u8, features: Features, alias: &Alias, pow: u32, agent: &UserAgent, timestamp: Timestamp, addrs: impl IntoIterator<Item = KnownAddress>, ) -> Result<bool, Error>

Insert a node with associated addresses into the store.

fn remove(&mut self, node: &PublicKey) -> Result<bool, Error>

Remove a node from the store.

fn entries(&self) -> Result<Box<dyn Iterator<Item = AddressEntry>>, Error>

Get the address entries in the store.

fn attempted( &self, nid: &PublicKey, addr: &Address, time: Timestamp, ) -> Result<(), Error>

Mark a node as attempted at a certain time.

fn connected( &self, nid: &PublicKey, addr: &Address, time: Timestamp, ) -> Result<(), Error>

Mark a node as successfully connected at a certain time.

fn record_ip( &self, nid: &PublicKey, ip: IpAddr, time: Timestamp, ) -> Result<(), Error>

Record a node IP address and connection time.

fn disconnected( &mut self, nid: &PublicKey, addr: &Address, severity: Severity, ) -> Result<(), Error>

Mark a node as disconnected.

fn is_empty(&self) -> Result<bool, Error>

Returns true if there are no addresses.

impl Store for Database

fn set( &mut self, repo: &RepoId, namespace: &PublicKey, refname: &Qualified<'_>, oid: Oid, timestamp: LocalTime, ) -> Result<bool, Error>

Set a reference under a remote namespace to the given Oid.

fn get( &self, repo: &RepoId, namespace: &PublicKey, refname: &Qualified<'_>, ) -> Result<Option<(Oid, LocalTime)>, Error>

Get a reference’s Oid and timestamp.

fn delete( &mut self, repo: &RepoId, namespace: &PublicKey, refname: &Qualified<'_>, ) -> Result<bool, Error>

Delete a reference.

fn count(&self) -> Result<usize, Error>

Return the number of references.

fn populate<S>(&mut self, storage: &S) -> Result<(), Error>

where S: ReadStorage,

Populate the database from storage.

fn is_empty(&self) -> Result<bool, Error>

Check if there are any references.

impl Store for Database

fn get(&self, id: &RepoId) -> Result<HashSet<PublicKey>, Error>

Get the nodes seeding the given id.

fn get_inventory(&self, node: &PublicKey) -> Result<HashSet<RepoId>, Error>

Get the inventory seeded by the given node.

fn entry( &self, id: &RepoId, node: &PublicKey, ) -> Result<Option<Timestamp>, Error>

Get a specific entry.

fn add_inventory<'a>( &mut self, ids: impl IntoIterator<Item = &'a RepoId>, node: PublicKey, time: Timestamp, ) -> Result<Vec<(RepoId, InsertResult)>, Error>

Add a new node seeding the given id.

fn entries( &self, ) -> Result<Box<dyn Iterator<Item = (RepoId, PublicKey)>>, Error>

Iterate over all entries in the routing table.

fn remove_inventory( &mut self, id: &RepoId, node: &PublicKey, ) -> Result<bool, Error>

Remove an inventory from the given node.

fn remove_inventories<'a>( &mut self, rids: impl IntoIterator<Item = &'a RepoId>, nid: &PublicKey, ) -> Result<(), Error>

Remove multiple inventories from the given node.

fn len(&self) -> Result<usize, Error>

Get the total number of routing entries.

fn prune( &mut self, oldest: Timestamp, limit: Option<usize>, ignore: &PublicKey, ) -> Result<usize, Error>

Prune entries older than the given timestamp.

fn count(&self, id: &RepoId) -> Result<usize, Error>

Count the number of routes for a specific repo RID.

fn is_empty(&self) -> Result<bool, Error>

Checks if any entries are available.

impl Store for Database

fn synced( &mut self, rid: &RepoId, nid: &PublicKey, at: Oid, timestamp: Timestamp, ) -> Result<bool, Error>

Mark a repo as synced on the given node.

fn seeds_for( &self, rid: &RepoId, ) -> Result<Box<dyn Iterator<Item = Result<SyncedSeed, Error>> + '_>, Error>

Get nodes that have synced the given repo.

fn seeded_by( &self, nid: &PublicKey, ) -> Result<Box<dyn Iterator<Item = Result<(RepoId, SyncedAt), Error>> + '_>, Error>

Get the repos seeded by the given node.

impl Store for Database

fn prune(&mut self, cutoff: Timestamp) -> Result<usize, Error>

Prune announcements older than the cutoff time.

fn last(&self) -> Result<Option<Timestamp>, Error>

Get the timestamp of the last announcement in the store.

fn announced( &mut self, nid: &PublicKey, ann: &Announcement, ) -> Result<Option<u64>, Error>

Process an announcement for the given node. Returns true if the timestamp was updated or the announcement wasn’t there before.

fn set_relay(&mut self, id: u64, relay: RelayStatus) -> Result<(), Error>

Set whether a message should be relayed or not.

fn relays(&mut self, now: Timestamp) -> Result<Vec<(u64, Announcement)>, Error>

Return messages that should be relayed.

fn filtered<'a>( &'a self, filter: &'a Filter, from: Timestamp, to: Timestamp, ) -> Result<Box<dyn Iterator<Item = Result<Announcement, Error>> + 'a>, Error>

Get all the latest gossip messages of all nodes, filtered by inventory filter and announcement timestamps.

impl StoreExt for Database

type NodeAlias<'a> = NodeAliasIter<'a> where Database: 'a

fn nodes_by_alias<'a>( &'a self, alias: &Alias, ) -> Result<<Database as StoreExt>::NodeAlias<'a>, Error>

impl Store for Database