Module libunftp::storage

Contains the StorageBackend trait that can be implemented to create virtual file systems for libunftp.

Pre-made implementations exists on crates.io (search for unftp-sbe-) and you can define your own implementation to integrate your FTP(S) server with whatever storage mechanism you prefer.

To create a new storage back-end:

1. Declare a dependency on the async-trait crate

async-trait = "0.1.50"

2. Implement the StorageBackend trait and optionally the Metadata trait:

use async_trait::async_trait;
use libunftp::storage::{Fileinfo, Metadata, Result, StorageBackend};
use std::fmt::Debug;
use std::path::{Path, PathBuf};
use libunftp::auth::DefaultUser;
use std::time::SystemTime;

#[derive(Debug)]
pub struct Vfs {}

#[derive(Debug)]
pub struct Meta {
    inner: std::fs::Metadata,
}

impl Vfs {
  fn new() -> Vfs { Vfs{} }
}

#[async_trait]
impl libunftp::storage::StorageBackend<DefaultUser> for Vfs {
    type Metadata = Meta;

    async fn metadata<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        path: P,
    ) -> Result<Self::Metadata> {
        unimplemented!()
    }

    async fn list<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        path: P,
    ) -> Result<Vec<Fileinfo<PathBuf, Self::Metadata>>>
    where
        <Self as StorageBackend<DefaultUser>>::Metadata: Metadata,
    {
        unimplemented!()
    }

    async fn get<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        path: P,
        start_pos: u64,
    ) -> Result<Box<dyn tokio::io::AsyncRead + Send + Sync + Unpin>> {
        unimplemented!()
    }

    async fn put<
        P: AsRef<Path> + Send + Debug,
        R: tokio::io::AsyncRead + Send + Sync + Unpin + 'static,
    >(
        &self,
        user: &DefaultUser,
        input: R,
        path: P,
        start_pos: u64,
    ) -> Result<u64> {
        unimplemented!()
    }

    async fn del<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        path: P,
    ) -> Result<()> {
        unimplemented!()
    }

    async fn mkd<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        path: P,
    ) -> Result<()> {
        unimplemented!()
    }

    async fn rename<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        from: P,
        to: P,
    ) -> Result<()> {
        unimplemented!()
    }

    async fn rmd<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        path: P,
    ) -> Result<()> {
        unimplemented!()
    }

    async fn cwd<P: AsRef<Path> + Send + Debug>(
        &self,
        user: &DefaultUser,
        path: P,
    ) -> Result<()> {
        unimplemented!()
    }
}

impl Metadata for Meta {
    fn len(&self) -> u64 {
        self.inner.len()
    }

    fn is_dir(&self) -> bool {
        self.inner.is_dir()
    }

    fn is_file(&self) -> bool {
        self.inner.is_file()
    }

    fn is_symlink(&self) -> bool {
       self.inner.file_type().is_symlink()
    }

    fn modified(&self) -> Result<SystemTime> {
        self.inner.modified().map_err(|e| e.into())
    }

    fn gid(&self) -> u32 {
        0
    }

    fn uid(&self) -> u32 {
        0
    }
}

3. Initialize it with the Server:

let vfs_provider = Box::new(|| Vfs::new());
let server = libunftp::Server::new(vfs_provider);

Structs

• Error
  The Error returned by storage backends. Storage backend implementations should choose the ErrorKind chosen for errors carefully since that will determine what is returned to the FTP client.
• Fileinfo
  Fileinfo contains the path and Metadata of a file.
• Permissions
  Represents the permissions of a FTP File

Enums

• ErrorKind
  The ErrorKind variants that can be produced by the StorageBackend implementations.

Constants

• FEATURE_RESTART
  Tells if STOR/RETR restarts are supported by the storage back-end i.e. starting from a different byte offset.
• FEATURE_SITEMD5
  Whether or not this storage backend supports the SITE MD5 command

Traits

• Metadata
  Represents the metadata of a FTP File
• StorageBackend
  The StorageBackend trait can be implemented to create custom FTP virtual file systems. Once implemented it needs to be registered with the Server on construction.

Type Aliases

• Result
  Result type used by traits in this module