Struct asuran::manifest::destination::filesystem::FileSystemTarget

pub struct FileSystemTarget { /* fields omitted */ }

A type that handles the complexities of dealing with a file system for you.

Implementations

impl FileSystemTarget

pub fn new(root_directory: &str) -> FileSystemTarget

Creates a new FileSystemTarget with the given path as its top level directory.

The FileSystemTarget will consider all paths below this directory for backup.

pub fn set_root_directory(&mut self, new_root: &str)

Trait Implementations

impl BackupDriver<File> for FileSystemTarget

fn raw_store_object<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, B: BackendClone, C: AsyncChunker + Send + 'static>(
    &'life0 self,
    repo: &'life1 mut Repository<B>,
    chunker: C,
    archive: &'life2 ActiveArchive,
    node: Node,
    objects: HashMap<String, BackupObject<T>>,
    ex: &'life3 Executor<'life4>
) -> Pin<Box<dyn Future<Output = Result<(), DriverError>> + Send + 'async_trait>> where
    B: 'async_trait,
    C: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: Sync + 'async_trait, 

Inserts an object into the repository using the output from BackupTarget::backup_object

fn store_object<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, B: BackendClone, C: AsyncChunker + Send + 'static>(
    &'life0 self,
    repo: &'life1 mut Repository<B>,
    chunker: C,
    archive: &'life2 ActiveArchive,
    node: Node,
    ex: &'life3 Executor<'life4>
) -> Pin<Box<dyn Future<Output = Result<(), DriverError>> + Send + 'async_trait>> where
    B: 'async_trait,
    C: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: Sync + 'async_trait, 

Convenience method that performs a call to self.backup_object for you and routes the results into self.raw_store_object

impl BackupTarget<File> for FileSystemTarget

fn backup_paths<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Listing> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns a listing of all the backup-able objects in the target’s domain

fn backup_object<'life0, 'async_trait>(
    &'life0 self,
    node: Node
) -> Pin<Box<dyn Future<Output = HashMap<String, BackupObject<File>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Takes a path and returns a reader for the path this object represents

fn backup_listing<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Listing> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns a serialized listing that should be stored in an archive at archive:listing

impl Clone for FileSystemTarget

fn clone(&self) -> FileSystemTarget

Returns a copy of the value.

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

Performs copy-assignment from source.

impl RestoreDriver<File> for FileSystemTarget

fn raw_retrieve_object<'life0, 'life1, 'life2, 'async_trait, B: BackendClone>(
    &'life0 self,
    repo: &'life1 mut Repository<B>,
    archive: &'life2 ActiveArchive,
    node: Node,
    objects: HashMap<String, RestoreObject<T>>
) -> Pin<Box<dyn Future<Output = Result<(), DriverError>> + Send + 'async_trait>> where
    B: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, 

Retrives an object from the repository using the output from RestoreTarget::restore_object

fn retrieve_object<'life0, 'life1, 'life2, 'async_trait, B: BackendClone>(
    &'life0 self,
    repo: &'life1 mut Repository<B>,
    archive: &'life2 ActiveArchive,
    node: Node
) -> Pin<Box<dyn Future<Output = Result<(), DriverError>> + Send + 'async_trait>> where
    B: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Sync + 'async_trait, 

Retrieves an object, performing the call to BackupTarget::restore_object and raw_retrive_object for you.

impl RestoreTarget<File> for FileSystemTarget

fn load_listing<'life0, 'async_trait>(
    root_path: &'life0 str,
    listing: Listing
) -> Pin<Box<dyn Future<Output = Self> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Loads an object listing and creates a new restore target from it

fn restore_object<'life0, 'async_trait>(
    &'life0 self,
    node: Node
) -> Pin<Box<dyn Future<Output = HashMap<String, RestoreObject<File>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Takes an object path

fn restore_listing<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Listing> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns a copy of the internal listing object