Struct tor_dirmgr::storage::sqlite::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.

pub(crate) fn from_conn(conn: Connection, blob_dir: CheckedDir) -> Result<Self>

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

Used for testing with a memory-backed database.

fn check_schema(&mut self) -> Result<()>

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

fn read_blob<P>(&self, path: P) -> Result<InputString>

where P: AsRef<Path>,

Read a blob from disk, mapping it if possible.

fn save_blob_internal( &mut self, contents: &[u8], doctype: &str, dtype: &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.

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>>

Available on crate feature routerdesc only.

Read all the microdescriptors listed in input from the cache.

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

Available on crate feature routerdesc only.

Store every router descriptors in input into the cache.

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

Available on crate feature bridge-client only.

Look up a cached bridge descriptor.

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

Available on crate feature bridge-client only.

Store a cached bridge descriptor.

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

Available on crate feature bridge-client only.

Delete a cached bridge descriptor for this bridge.