Struct tor_persist::FsStateMgr

pub struct FsStateMgr { /* private fields */ }

Implementation of StateMgr that stores state as JSON files on disk.

Locking

This manager uses a lock file to determine whether it’s allowed to write to the disk. Only one process should write to the disk at a time, though any number may read from the disk.

By default, every FsStateMgr starts out unlocked, and only able to read. Use FsStateMgr::try_lock() to lock it.

Limitations

1. This manager only accepts objects that can be serialized as JSON documents. Some types (like maps with non-string keys) can’t be serialized as JSON.

2. This manager normalizes keys to an fs-safe format before saving data with them. This keeps you from accidentally creating or reading files elsewhere in the filesystem, but it doesn’t prevent collisions when two keys collapse to the same fs-safe filename. Therefore, you should probably only use ascii keys that are fs-safe on all systems.

NEVER use user-controlled or remote-controlled data for your keys.

Implementations

impl FsStateMgr

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

Construct a new FsStateMgr to store data in path.

This function will try to create path if it does not already exist.

All files must be “private” according to the rules specified in mistrust.

pub fn path(&self) -> &Path

Return the top-level directory for this storage manager.

(This is the same directory passed to FsStateMgr::from_path_and_mistrust.)

Trait Implementations

impl Clone for FsStateMgr

fn clone(&self) -> FsStateMgr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FsStateMgr

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

Formats the value using the given formatter.

impl StateMgr for FsStateMgr

fn can_store(&self) -> bool

Return true if this is a read-write state manager.

fn try_lock(&self) -> Result<LockStatus, Error>

Try to become a read-write state manager if possible, without blocking.

fn unlock(&self) -> Result<(), Error>

Release any locks held and become a read-only state manager again. If no locks were held, do nothing.

fn load<D>(&self, key: &str) -> Result<Option<D>, Error> where
    D: DeserializeOwned, 

Try to load the object with key key from the store.

fn store<S>(&self, key: &str, val: &S) -> Result<(), Error> where
    S: Serialize, 

Try to save val with key key in the store.

fn create_handle<T>(self, key: impl Into<String>) -> DynStorageHandle<T> where
    Self: Send + Sync + Sized + 'static,
    T: Serialize + DeserializeOwned + 'static, 

Make a new StorageHandle to store values of particular type at a particular key.