Struct s3handler::tokio_async::primitives::Canal

pub struct Canal {
    pub up_pool: Option<Box<dyn DataPool>>,
    pub upstream_object: Option<S3Object>,
    pub down_pool: Option<Box<dyn DataPool>>,
    pub downstream_object: Option<S3Object>,
    // some fields omitted
}

Fields

up_pool: Option<Box<dyn DataPool>>

upstream_object: Option<S3Object>

down_pool: Option<Box<dyn DataPool>>

downstream_object: Option<S3Object>

Implementations

impl Canal

A canal presets a object link for two object from resource pool to pool. If everything is set, the async api can pull/push the objects.

The download_file, and upload_file api will setup the up pool as s3 pool, and set up the down pool as file pool for the most usage case.

The terms object, key, bucket, folder, path may be easiler for readness in coding, so there are several similar methods help you to setup things. If you down want these duplicate functions, you can enable the slim feature.

pub fn is_connect(&self) -> bool

Check the two pools are set or not

pub fn toward(mut self: Self, resource_location: &str) -> Result<Self, Error>

Set downd pool as file pool, and toward to the resource_location

pub fn from(mut self: Self, resource_location: &str) -> Result<Self, Error>

Set up pool as file pool, and from to the resource_location

pub async fn download_file(self, resource_location: &str) -> Result<(), Error>

Download object from s3 pool to file pool This function set file pool as down pool and s3 pool as up pool then toward to the resource_location, pull the object from uppool into down pool.

pub async fn upload_file(self, resource_location: &str) -> Result<(), Error>

Upload object from file pool to s3 pool This function set file pool as down pool and s3 pool as up pool then toward to the resource_location, push the object from uppool into down pool.

pub fn from_pool(&mut self, pool: Box<dyn DataPool>)

Setup the up pool

pub fn toward_pool(&mut self, pool: Box<dyn DataPool>)

Setup the down pool

pub fn _object(mut self: Self, object_name: &str) -> Self

pub fn _bucket(mut self: Self, bucket_name: &str) -> Self

pub fn object(self, object_name: &str) -> Self

Setup the object for the first pool connected by canal, This api can be used without fully setting up two pools, and just set up the object as you what you think.

pub fn key(self, key_name: &str) -> Self

The same as object()

pub fn bucket(self, bucket_name: &str) -> Self

Setup the bucket for the first pool connected by canal, This api can be used without fully setting up two pools, and just set up the object as you what you think.

pub fn folder(self, folder_name: &str) -> Self

The same as bucket()

pub fn _toward_object(&mut self, object_name: &str)

pub fn toward_object(&mut self, object_name: &str)

Setup the object in the down pool

pub fn toward_key(&mut self, object_name: &str)

The same as toward_object()

pub fn _toward_bucket(&mut self, bucket_name: &str)

pub fn toward_bucket(&mut self, bucket_name: &str)

Setup the bucket in the down pool

pub fn toward_folder(&mut self, folder_name: &str)

The same as toward_bucket()

pub fn toward_path(&mut self, path: &str)

Setup the path in the down pool

pub fn _from_object(&mut self, object_name: &str)

pub fn from_object(&mut self, object_name: &str)

Setup the object in the up pool

pub fn from_key(&mut self, object_name: &str)

The same as from_object()

pub fn _from_bucket(&mut self, bucket_name: &str)

pub fn from_bucket(&mut self, bucket_name: &str)

Setup the bucket in the up pool

pub fn from_folder(&mut self, folder_name: &str)

The same as from_bucket()

pub fn from_path(&mut self, path: &str)

Setup the path in the up pool

pub async fn push(self) -> Result<(), Error>

Push the object from down pool to up pool. It will raise error if the canal is not will setup.

pub async fn pull(self) -> Result<(), Error>

Pull the object from up pool to down pool. It will raise error if the canal is not will setup.

pub async fn upstream_remove(self) -> Result<(), Error>

Remove the object in the up pool.

pub async fn downstream_remove(self) -> Result<(), Error>

Remove the object in the down pool.

pub async fn remove(self) -> Result<(), Error>

Remove the object depence on the first pool connected by the canal This api can be used without fully setting up two pools, and remove object as you what you think.

pub async fn upstream_list(self) -> Result<Box<dyn S3Folder>, Error>

List the objects in the up pool.

pub async fn downstream_list(self) -> Result<Box<dyn S3Folder>, Error>

List the objects in the down pool.

pub async fn list(self) -> Result<Box<dyn S3Folder>, Error>

List the objects depence on the first pool connected by the canal This api can be used without fully setting up two pools, and list objects as you what you think.

Trait Implementations

impl Debug for Canal

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

Formats the value using the given formatter.