Trait libunftp::storage::StorageBackend[−][src]

pub trait StorageBackend<U: Sync + Send + Debug>: Send + Sync + Debug {
    type Metadata: Metadata + Sync + Send;

Show methods    #[must_use]
    fn metadata<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<Self::Metadata>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn list<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Fileinfo<PathBuf, Self::Metadata>>>> + Send + 'async_trait>>
    where
        Self::Metadata: Metadata,
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn get<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P, 
        start_pos: u64
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn AsyncRead + Send + Sync + Unpin>>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn put<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug, R: AsyncRead + Send + Sync + Unpin + 'static>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        input: R, 
        path: P, 
        start_pos: u64
    ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        R: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn del<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn mkd<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn rename<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        from: P, 
        to: P
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn rmd<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    #[must_use]
    fn cwd<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
    where
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

    fn name(&self) -> &str { ... }

    fn supported_features(&self) -> u32 { ... }

    #[must_use]
    fn md5<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
    where
        P: AsRef<Path> + Send + Debug,
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait,
    { ... }

    #[must_use]
    fn list_fmt<'life0, 'life1, 'async_trait, P>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<Cursor<Vec<u8>>, Error>> + Send + 'async_trait>>
    where
        P: AsRef<Path> + Send + Debug,
        Self::Metadata: Metadata + 'static,
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait,
    { ... }

    #[must_use]
    fn nlst<'life0, 'life1, 'async_trait, P>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P
    ) -> Pin<Box<dyn Future<Output = Result<Cursor<Vec<u8>>, Error>> + Send + 'async_trait>>
    where
        P: AsRef<Path> + Send + Debug,
        Self::Metadata: Metadata + 'static,
        P: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait,
    { ... }

    #[must_use]
    fn get_into<'a, 'life0, 'life1, 'async_trait, P, W: ?Sized>(
        &'life0 self, 
        user: &'life1 Option<U>, 
        path: P, 
        start_pos: u64, 
        output: &'a mut W
    ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>
    where
        W: AsyncWrite + Unpin + Sync + Send,
        P: AsRef<Path> + Send + Debug,
        'a: 'async_trait,
        P: 'async_trait,
        W: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait,
    { ... }

}
Expand description

The StorageBackend trait defines a common interface to different storage backends for our FTP Server, e.g. for a Filesystem or Google Cloud Storage.

Associated Types

type Metadata: Metadata + Sync + Send[src]

The concrete type of the metadata used by this storage backend.

Required methods

#[must_use]
fn metadata<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<Self::Metadata>> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Returns the Metadata for the given file.

#[must_use]
fn list<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<Vec<Fileinfo<PathBuf, Self::Metadata>>>> + Send + 'async_trait>> where
    Self::Metadata: Metadata,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Returns the list of files in the given directory.

#[must_use]
fn get<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P,
    start_pos: u64
) -> Pin<Box<dyn Future<Output = Result<Box<dyn AsyncRead + Send + Sync + Unpin>>> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Returns the content of the given file from offset start_pos. The starting position will only be greater than zero if the storage back-end implementation advertises to support partial reads through the supported_features method i.e. the result from supported_features yield 1 if a logical and operation is applied with FEATURE_RESTART.

#[must_use]
fn put<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug, R: AsyncRead + Send + Sync + Unpin + 'static>(
    &'life0 self,
    user: &'life1 Option<U>,
    input: R,
    path: P,
    start_pos: u64
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    P: 'async_trait,
    R: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Writes bytes from the given reader to the specified path starting at offset start_pos in the file

#[must_use]
fn del<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Deletes the file at the given path.

#[must_use]
fn mkd<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Creates the given directory.

#[must_use]
fn rename<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    from: P,
    to: P
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Renames the given file to the given new filename.

#[must_use]
fn rmd<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Deletes the given directory.

#[must_use]
fn cwd<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Changes the working directory to the given path.

Provided methods

fn name(&self) -> &str[src]

Implement to set the name of the storage back-end. By default it returns the type signature.

fn supported_features(&self) -> u32[src]

Tells which optional features are supported by the storage back-end Return a value with bits set according to the FEATURE_* constants.

#[must_use]
fn md5<'life0, 'life1, 'async_trait, P: AsRef<Path> + Send + Debug>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>> where
    P: AsRef<Path> + Send + Debug,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Returns the MD5 hash for the given file.

Whether or not you want to implement the md5 method yourself, or you want to let your StorageBackend make use of the below default implementation, you must still explicitly enable the feature via the supported_features method.

When implementing, use the lower case 2-digit hexadecimal format (like the output of the md5sum command)

#[must_use]
fn list_fmt<'life0, 'life1, 'async_trait, P>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<Cursor<Vec<u8>>, Error>> + Send + 'async_trait>> where
    P: AsRef<Path> + Send + Debug,
    Self::Metadata: Metadata + 'static,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Returns some bytes that make up a directory listing that can immediately be sent to the client.

#[must_use]
fn nlst<'life0, 'life1, 'async_trait, P>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P
) -> Pin<Box<dyn Future<Output = Result<Cursor<Vec<u8>>, Error>> + Send + 'async_trait>> where
    P: AsRef<Path> + Send + Debug,
    Self::Metadata: Metadata + 'static,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Returns some bytes that make up a NLST directory listing (only the basename) that can immediately be sent to the client.

#[must_use]
fn get_into<'a, 'life0, 'life1, 'async_trait, P, W: ?Sized>(
    &'life0 self,
    user: &'life1 Option<U>,
    path: P,
    start_pos: u64,
    output: &'a mut W
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    W: AsyncWrite + Unpin + Sync + Send,
    P: AsRef<Path> + Send + Debug,
    'a: 'async_trait,
    P: 'async_trait,
    W: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

Gets the content of the given FTP file from offset start_pos file by copying it to the output writer. The starting position will only be greater than zero if the storage back-end implementation advertises to support partial reads through the supported_features method i.e. the result from supported_features yield 1 if a logical and operation is applied with FEATURE_RESTART.

Implementors