Struct SqliteStore 

pub(crate) struct SqliteStore {
    conn: Connection,
    sql_path: Option<PathBuf>,
    blob_dir: CheckedDir,
    lockfile: Option<LockFile>,
}

Local directory cache using a Sqlite3 connection.

Fields

conn: Connection

Connection to the sqlite3 database.

sql_path: Option<PathBuf>

Location for the sqlite3 database; used to reopen it.

blob_dir: CheckedDir

Location to store blob files.

lockfile: Option<LockFile>

Lockfile to prevent concurrent write attempts from different processes.

If this is None we aren’t using a lockfile. Watch out!

(sqlite supports that with connection locking, but we want to be a little more coarse-grained here)

Implementations

impl SqliteStore

pub(crate) fn from_path_and_mistrust<P: AsRef<Path>>( path: P, mistrust: &Mistrust, readonly: bool, ) -> Result<Self>

Construct or open a new SqliteStore at some location on disk. The provided location must be a directory, or a possible location for a directory: the directory will be created if necessary.

If readonly is true, the result will be a read-only store. Otherwise, when readonly is false, the result may be read-only or read-write, depending on whether we can acquire the lock.

Limitations:

The file locking that we use to ensure that only one dirmgr is writing to a given storage directory at a time is currently per process. Therefore, you might get unexpected results if two SqliteStores are created in the same process with the path.

fn from_conn_internal( conn: Connection, blob_dir: CheckedDir, readonly: bool, ) -> Result<Self>

Construct a new SqliteStore from a database connection and a location for blob files.

The readonly argument specifies whether the database connection should be read-only.

fn check_schema(&mut self, readonly: bool) -> Result<()>

Check whether this database has a schema format we can read, and install or upgrade the schema if necessary.

fn read_blob(&self, path: &str) -> Result<StdResult<InputString, AbsentBlob>>

Read a blob from disk, mapping it if possible.

Return Ok(Err(.)) if the file for the blob was not found on disk; returns an error in other cases.

(See blob_consistency for information on why the blob might be absent.)

fn save_blob_internal( &mut self, contents: &[u8], doctype: &str, digest_type: &str, digest: &[u8], expires: OffsetDateTime, ) -> Result<SavedBlobHandle<'_>>

Write a file to disk as a blob, and record it in the ExtDocs table.

Return a SavedBlobHandle that describes where the blob is, and which can be used either to commit the blob or delete it.

See blob_consistency for more information on guarantees.

fn latest_consensus_internal( &self, flavor: ConsensusFlavor, pending: Option<bool>, ) -> Result<StdResult<InputString, AbsentBlob>>

As latest_consensus, but do not retry.

fn remove_blob_or_warn<P: AsRef<Path>>(&self, fname: P)

Remove the blob with name fname, but do not give an error on failure.

See blob_consistency: we should call this only having first ensured that the blob is removed from the ExtDocs table.

fn remove_unreferenced_blobs( &self, now: OffsetDateTime, expiration: &ExpirationConfig, ) -> Result<()>

Delete any blob files that are old enough, and not mentioned in the ExtDocs table.

There shouldn’t typically be any, but we don’t want to let our cache grow infinitely if we have a bug.

fn remove_entries_for_vanished_blobs<'a>( blob_dir: &CheckedDir, tx: &Transaction<'a>, ) -> Result<usize>

Remove any entry in the ExtDocs table for which a blob file is vanished.

This method is O(n) in the size of the ExtDocs table and the size of the directory. It doesn’t take self, to avoid problems with the borrow checker.

Trait Implementations

impl Store for SqliteStore

fn is_readonly(&self) -> bool

Return true if this Store is opened in read-only mode.

fn upgrade_to_readwrite(&mut self) -> Result<bool>

Try to upgrade from a read-only connection to a read-write connection.

fn expire_all(&mut self, expiration: &ExpirationConfig) -> Result<()>

Delete all completely-expired objects from the database.

fn latest_consensus( &self, flavor: ConsensusFlavor, pending: Option<bool>, ) -> Result<Option<InputString>>

Load the latest consensus from disk.

fn latest_consensus_meta( &self, flavor: ConsensusFlavor, ) -> Result<Option<ConsensusMeta>>

Return the information about the latest non-pending consensus, including its valid-after time and digest.

fn consensus_by_sha3_digest_of_signed_part( &self, d: &[u8; 32], ) -> Result<Option<(InputString, ConsensusMeta)>>

Try to read the consensus whose SHA3-256 digests is the provided value, and its metadata.

fn store_consensus( &mut self, cmeta: &ConsensusMeta, flavor: ConsensusFlavor, pending: bool, contents: &str, ) -> Result<()>

Write a consensus to disk.

fn mark_consensus_usable(&mut self, cmeta: &ConsensusMeta) -> Result<()>

Mark the consensus generated from cmeta as no longer pending.

fn delete_consensus(&mut self, cmeta: &ConsensusMeta) -> Result<()>

Remove the consensus generated from cmeta.

fn authcerts( &self, certs: &[AuthCertKeyIds], ) -> Result<HashMap<AuthCertKeyIds, String>>

Read all of the specified authority certs from the cache.

fn store_authcerts(&mut self, certs: &[(AuthCertMeta, &str)]) -> Result<()>

Save a list of authority certificates to the cache.

fn microdescs(&self, digests: &[MdDigest]) -> Result<HashMap<MdDigest, String>>

Read all the microdescriptors listed in input from the cache.

fn store_microdescs( &mut self, digests: &[(&str, &MdDigest)], when: SystemTime, ) -> Result<()>

Store every microdescriptor in input into the cache, and say that it was last listed at when.

fn update_microdescs_listed( &mut self, digests: &[MdDigest], when: SystemTime, ) -> Result<()>

Update the last-listed time of every microdescriptor in input to when or later.

fn routerdescs(&self, digests: &[RdDigest]) -> Result<HashMap<RdDigest, String>>

Read all the microdescriptors listed in input from the cache.

fn store_routerdescs( &mut self, digests: &[(&str, SystemTime, &RdDigest)], ) -> Result<()>

Store every router descriptors in input into the cache.

fn lookup_bridgedesc( &self, bridge: &BridgeConfig, ) -> Result<Option<CachedBridgeDescriptor>>

Look up a cached bridge descriptor.

fn store_bridgedesc( &mut self, bridge: &BridgeConfig, entry: CachedBridgeDescriptor, until: SystemTime, ) -> Result<()>

Store a cached bridge descriptor.

fn delete_bridgedesc(&mut self, bridge: &BridgeConfig) -> Result<()>

Delete a cached bridge descriptor for this bridge.

fn update_protocol_recommendations( &mut self, valid_after: SystemTime, protocols: &ProtoStatuses, ) -> Result<()>

Try to update our cached protocol recommendations to those listed in protocols.

fn cached_protocol_recommendations( &self, ) -> Result<Option<(SystemTime, ProtoStatuses)>>

Return our most recent cached protocol recommendations.