Trait Vfs 

pub trait Vfs {
    // Required methods
    fn get_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<VfsFile>, BackendApiError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn upsert_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
        data: Bytes,
        retries: usize,
    ) -> Pin<Box<dyn Future<Output = Result<Empty, BackendApiError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn delete_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
    ) -> Pin<Box<dyn Future<Output = Result<Empty, BackendApiError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn list_directory<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 VfsDirectory,
    ) -> Pin<Box<dyn Future<Output = Result<VfsDirectoryList, BackendApiError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: 'async_trait;
    fn encrypt_json<T>(&self, file_id: VfsFileId, value: &T) -> VfsFile
       where T: Serialize;
    fn encrypt_ldk_writeable<W>(
        &self,
        file_id: VfsFileId,
        writeable: &W,
    ) -> VfsFile
       where W: Writeable;
    fn encrypt_bytes(
        &self,
        file_id: VfsFileId,
        plaintext_bytes: &[u8],
    ) -> VfsFile;
    fn decrypt_file(
        &self,
        expected_file_id: &VfsFileId,
        file: VfsFile,
    ) -> Result<Vec<u8>, Error>;

    // Provided methods
    fn get_directory<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 VfsDirectory,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<VfsFile>, BackendApiError>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn read_json<'life0, 'life1, 'async_trait, T>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             T: 'async_trait + DeserializeOwned,
             Self: Sync + 'async_trait { ... }
    fn read_dir_json<'life0, 'life1, 'async_trait, T>(
        &'life0 self,
        dir: &'life1 VfsDirectory,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<(VfsFileId, T)>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             T: 'async_trait + DeserializeOwned,
             Self: Sync + 'async_trait { ... }
    fn read_readableargs<'life0, 'life1, 'async_trait, T, A>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
        read_args: A,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             T: ReadableArgs<A> + 'async_trait,
             A: Send + 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn read_dir_maybereadable<'life0, 'life1, 'async_trait, T>(
        &'life0 self,
        dir: &'life1 VfsDirectory,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<(VfsFileId, T)>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             T: 'async_trait + MaybeReadable,
             Self: Sync + 'async_trait { ... }
    fn read_bytes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn read_dir_bytes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 VfsDirectory,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<(VfsFileId, Vec<u8>)>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn read_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<VfsFile>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn read_dir_files<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 VfsDirectory,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<VfsFile>, Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn deser_readableargs<T, A>(
        file_id: &VfsFileId,
        bytes: &[u8],
        read_args: A,
    ) -> Result<T, Error>
       where T: ReadableArgs<A>,
             A: Send { ... }
    fn persist_json<'life0, 'life1, 'async_trait, T>(
        &'life0 self,
        file_id: VfsFileId,
        value: &'life1 T,
        retries: usize,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             T: 'async_trait + Serialize + Send + Sync,
             Self: Sync + 'async_trait { ... }
    fn persist_ldk_writeable<'life0, 'life1, 'async_trait, W>(
        &'life0 self,
        file_id: VfsFileId,
        writeable: &'life1 W,
        retries: usize,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             W: 'async_trait + Writeable + Send + Sync,
             Self: Sync + 'async_trait { ... }
    fn persist_bytes<'life0, 'life1, 'async_trait>(
        &'life0 self,
        file_id: VfsFileId,
        plaintext_bytes: &'life1 [u8],
        retries: usize,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn persist_file<'life0, 'async_trait>(
        &'life0 self,
        file: VfsFile,
        retries: usize,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             Self: Sync + 'async_trait { ... }
    fn remove_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        file_id: &'life1 VfsFileId,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             Self: Sync + 'async_trait { ... }
}

Lexe’s async persistence interface.

Required Methods

fn get_file<'life0, 'life1, 'async_trait>( &'life0 self, file_id: &'life1 VfsFileId, ) -> Pin<Box<dyn Future<Output = Result<Option<VfsFile>, BackendApiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Fetch the given VfsFile from the backend.

Prefer Vfs::read_file which adds logging and error context.

fn upsert_file<'life0, 'life1, 'async_trait>( &'life0 self, file_id: &'life1 VfsFileId, data: Bytes, retries: usize, ) -> Pin<Box<dyn Future<Output = Result<Empty, BackendApiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Upsert the given file to the backend with the given # of retries.

Prefer Vfs::persist_file which adds logging and error context.

fn delete_file<'life0, 'life1, 'async_trait>( &'life0 self, file_id: &'life1 VfsFileId, ) -> Pin<Box<dyn Future<Output = Result<Empty, BackendApiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Deletes the VfsFile with the given VfsFileId from the backend.

Prefer Vfs::remove_file which adds logging and error context.

fn list_directory<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 VfsDirectory, ) -> Pin<Box<dyn Future<Output = Result<VfsDirectoryList, BackendApiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

List all filenames in the given VfsDirectory.

Returns a VfsDirectoryList containing the directory name and all filenames.

fn encrypt_json<T>(&self, file_id: VfsFileId, value: &T) -> VfsFile

where T: Serialize,

Serialize T then encrypt it to a file under the VFS master key.

fn encrypt_ldk_writeable<W>(&self, file_id: VfsFileId, writeable: &W) -> VfsFile

where W: Writeable,

Serialize a LDK Writeable then encrypt it under the VFS master key.

fn encrypt_bytes(&self, file_id: VfsFileId, plaintext_bytes: &[u8]) -> VfsFile

Encrypt plaintext bytes to a file under the VFS master key.

Prefer Vfs::encrypt_json and Vfs::encrypt_ldk_writeable, since those avoid the need to write to an intermediate plaintext buffer.

fn decrypt_file( &self, expected_file_id: &VfsFileId, file: VfsFile, ) -> Result<Vec<u8>, Error>

Decrypt a file previously encrypted under the VFS master key.

Provided Methods

fn get_directory<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 VfsDirectory, ) -> Pin<Box<dyn Future<Output = Result<Vec<VfsFile>, BackendApiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Fetches all files in the given VfsDirectory from the backend.

Prefer Vfs::read_dir_files which adds logging and error context.

fn read_json<'life0, 'life1, 'async_trait, T>( &'life0 self, file_id: &'life1 VfsFileId, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, T: 'async_trait + DeserializeOwned, Self: Sync + 'async_trait,

Reads, decrypts, and JSON-deserializes a type T from the DB.

fn read_dir_json<'life0, 'life1, 'async_trait, T>( &'life0 self, dir: &'life1 VfsDirectory, ) -> Pin<Box<dyn Future<Output = Result<Vec<(VfsFileId, T)>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, T: 'async_trait + DeserializeOwned, Self: Sync + 'async_trait,

Reads, decrypts, and JSON-deserializes a VfsDirectory of type T.

fn read_readableargs<'life0, 'life1, 'async_trait, T, A>( &'life0 self, file_id: &'life1 VfsFileId, read_args: A, ) -> Pin<Box<dyn Future<Output = Result<Option<T>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, T: ReadableArgs<A> + 'async_trait, A: Send + 'async_trait, Self: Sync + 'async_trait,

Reads, decrypts, and deserializes a LDK ReadableArgs of type T with read args A from the DB.

fn read_dir_maybereadable<'life0, 'life1, 'async_trait, T>( &'life0 self, dir: &'life1 VfsDirectory, ) -> Pin<Box<dyn Future<Output = Result<Vec<(VfsFileId, T)>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, T: 'async_trait + MaybeReadable, Self: Sync + 'async_trait,

Reads, decrypts, and deserializes a VfsDirectory of LDK MaybeReadables from the DB, along with their VfsFileIds. None values are omitted from the result.

fn read_bytes<'life0, 'life1, 'async_trait>( &'life0 self, file_id: &'life1 VfsFileId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Reads and decrypts VfsFile bytes from the DB.

fn read_dir_bytes<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 VfsDirectory, ) -> Pin<Box<dyn Future<Output = Result<Vec<(VfsFileId, Vec<u8>)>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Reads and decrypts all files in the given VfsDirectory from the DB, returning the VfsFileId and plaintext bytes for each file.

fn read_file<'life0, 'life1, 'async_trait>( &'life0 self, file_id: &'life1 VfsFileId, ) -> Pin<Box<dyn Future<Output = Result<Option<VfsFile>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Wraps Vfs::get_file to add logging and error context.

fn read_dir_files<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 VfsDirectory, ) -> Pin<Box<dyn Future<Output = Result<Vec<VfsFile>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Wraps Vfs::get_directory to add logging and error context.

fn deser_readableargs<T, A>( file_id: &VfsFileId, bytes: &[u8], read_args: A, ) -> Result<T, Error>

where T: ReadableArgs<A>, A: Send,

Deserializes a LDK ReadableArgs of type T from bytes.

fn persist_json<'life0, 'life1, 'async_trait, T>( &'life0 self, file_id: VfsFileId, value: &'life1 T, retries: usize, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, T: 'async_trait + Serialize + Send + Sync, Self: Sync + 'async_trait,

JSON-serializes, encrypts, then persists a type T to the DB.

fn persist_ldk_writeable<'life0, 'life1, 'async_trait, W>( &'life0 self, file_id: VfsFileId, writeable: &'life1 W, retries: usize, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, W: 'async_trait + Writeable + Send + Sync, Self: Sync + 'async_trait,

Serializes, encrypts, then persists a LDK Writeable to the DB.

fn persist_bytes<'life0, 'life1, 'async_trait>( &'life0 self, file_id: VfsFileId, plaintext_bytes: &'life1 [u8], retries: usize, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Encrypts plaintext bytes then persists them to the DB.

Prefer Vfs::persist_json and Vfs::persist_ldk_writeable, since those avoid the need to write to an intermediate plaintext buffer.

fn persist_file<'life0, 'async_trait>( &'life0 self, file: VfsFile, retries: usize, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Wraps Vfs::upsert_file to add logging and error context.

fn remove_file<'life0, 'life1, 'async_trait>( &'life0 self, file_id: &'life1 VfsFileId, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Wraps Vfs::delete_file to add logging and error context.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors