Struct Operator

pub struct Operator { /* private fields */ }

Operator for uploading, downloading, and deleting files to a R2 bucket.

Example

use cf_r2_sdk::builder::Builder;
use cf_r2_sdk::error::Error;
use dotenvy::dotenv;
use std::env;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Error> {
   // load .env file
   dotenv().expect(".env file not found.");
   // insert a environment variable
   let bucket_name = env::var("BUCKET_NAME").expect("BUCKET_NAME not found in .env file.");
   let endpoint_url: String =
       env::var("ENDPOINT_URL").expect("ENDPOINT_URL not found in .env file.");
   let access_key_id: String =
       env::var("ACCESS_KEY_ID").expect("ACCESS_KEY_ID not found in .env file.");
   let secret_access_key: String =
      env::var("SECRET_ACCESS_KEY").expect("SECRET_ACCESS_KEY not found in .env file.");
   let region: String = env::var("REGION").expect("REGION not found in .env file.");

   let object: cf_r2_sdk::operator::Operator = Builder::new()
       .set_bucket_name(bucket_name)
       .set_access_key_id(access_key_id)
       .set_secret_access_key(secret_access_key)
       .set_endpoint(endpoint_url)
       .set_region(region)
       .create_client_result()?;

   let _ = object
       .upload_binary("sample.txt", "test/plain", b"Hello, World!", None)
       .await?;
   Ok(())
}

Implementations

impl Operator

pub fn new(bucket_name: String, client: Client) -> Self

Create a new Operator instance.

pub async fn upload_file( &self, file_name: &str, mime_type: &str, file_path: &str, cache_control: Option<&str>, ) -> Result<(), OperationError>

Upload a file to the R2 bucket.

Example

use cf_r2_sdk::builder::Builder;
use cf_r2_sdk::error::Error;
use dotenvy::dotenv;
use std::env;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Error> {
   // load .env file
   dotenv().expect(".env file not found.");
   // insert a environment variable
   let bucket_name = env::var("BUCKET_NAME").expect("BUCKET_NAME not found in .env file.");
   let endpoint_url: String =
       env::var("ENDPOINT_URL").expect("ENDPOINT_URL not found in .env file.");
   let access_key_id: String =
       env::var("ACCESS_KEY_ID").expect("ACCESS_KEY_ID not found in .env file.");
   let secret_access_key: String =
      env::var("SECRET_ACCESS_KEY").expect("SECRET_ACCESS_KEY not found in .env file.");
   let region: String = env::var("REGION").expect("REGION not found in .env file.");

   let object: cf_r2_sdk::operator::Operator = Builder::new()
       .set_bucket_name(bucket_name)
       .set_access_key_id(access_key_id)
       .set_secret_access_key(secret_access_key)
       .set_endpoint(endpoint_url)
       .set_region(region)
       .create_client_result()?;

   // upload file
   object
       .upload_file("sample.jpg", "image/jpeg", "./data/sample.jpg", None)
       .await?;
  Ok(())
}

pub async fn upload_binary( &self, file_name: &str, mime_type: &str, binary: &[u8], cache_control: Option<&str>, ) -> Result<(), OperationError>

Upload binary data to the R2 bucket.

Example

use cf_r2_sdk::builder::Builder;
use cf_r2_sdk::error::Error;
use dotenvy::dotenv;
use std::env;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Error> {
   // load .env file
   dotenv().expect(".env file not found.");
   // insert a environment variable
   let bucket_name = env::var("BUCKET_NAME").expect("BUCKET_NAME not found in .env file.");
   let endpoint_url: String =
       env::var("ENDPOINT_URL").expect("ENDPOINT_URL not found in .env file.");
   let access_key_id: String =
       env::var("ACCESS_KEY_ID").expect("ACCESS_KEY_ID not found in .env file.");
   let secret_access_key: String =
      env::var("SECRET_ACCESS_KEY").expect("SECRET_ACCESS_KEY not found in .env file.");
   let region: String = env::var("REGION").expect("REGION not found in .env file.");

   let object: cf_r2_sdk::operator::Operator = Builder::new()
       .set_bucket_name(bucket_name)
       .set_access_key_id(access_key_id)
       .set_secret_access_key(secret_access_key)
       .set_endpoint(endpoint_url)
       .set_region(region)
       .create_client_result()?;

   // upload binary data
   object
       .upload_binary("sample.txt", "test/plain", b"Hello, World!", None)
       .await?;

   Ok(())
}

pub async fn download(&self, file_name: &str) -> Result<Vec<u8>, OperationError>

Download a file as binary data from the R2 bucket.

Example

use cf_r2_sdk::builder::Builder;
use cf_r2_sdk::error::Error;
use dotenvy::dotenv;
use std::env;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Error> {
   // load .env file
   dotenv().expect(".env file not found.");
   // insert a environment variable
   let bucket_name = env::var("BUCKET_NAME").expect("BUCKET_NAME not found in .env file.");
   let endpoint_url: String =
       env::var("ENDPOINT_URL").expect("ENDPOINT_URL not found in .env file.");
   let access_key_id: String =
       env::var("ACCESS_KEY_ID").expect("ACCESS_KEY_ID not found in .env file.");
   let secret_access_key: String =
      env::var("SECRET_ACCESS_KEY").expect("SECRET_ACCESS_KEY not found in .env file.");
   let region: String = env::var("REGION").expect("REGION not found in .env file.");

   let object: cf_r2_sdk::operator::Operator = Builder::new()
       .set_bucket_name(bucket_name)
       .set_access_key_id(access_key_id)
       .set_secret_access_key(secret_access_key)
       .set_endpoint(endpoint_url)
       .set_region(region)
       .create_client_result()?;

   object
       .upload_binary("sample.txt", "test/plain", b"Hello, World!", None)
       .await?;

   // download binary data
   object
       .download("sample.txt")
       .await?;
  Ok(())
}

pub async fn delete(&self, file_name: &str) -> Result<(), OperationError>

Delete a file from the R2 bucket.

Example

use cf_r2_sdk::builder::Builder;
use cf_r2_sdk::error::Error;
use dotenvy::dotenv;
use std::env;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Error> {
   // load .env file
   dotenv().expect(".env file not found.");
   // insert a environment variable
   let bucket_name = env::var("BUCKET_NAME").expect("BUCKET_NAME not found in .env file.");
   let endpoint_url: String =
       env::var("ENDPOINT_URL").expect("ENDPOINT_URL not found in .env file.");
   let access_key_id: String =
       env::var("ACCESS_KEY_ID").expect("ACCESS_KEY_ID not found in .env file.");
   let secret_access_key: String =
      env::var("SECRET_ACCESS_KEY").expect("SECRET_ACCESS_KEY not found in .env file.");
   let region: String = env::var("REGION").expect("REGION not found in .env file.");

   let object: cf_r2_sdk::operator::Operator = Builder::new()
       .set_bucket_name(bucket_name)
       .set_access_key_id(access_key_id)
       .set_secret_access_key(secret_access_key)
       .set_endpoint(endpoint_url)
       .set_region(region)
       .create_client_result()?;

   object
       .upload_binary("sample.txt", "test/plain", b"Hello, World!", None)
       .await?;

   // delete file
   let bin: Vec<u8> = object.download("sample.txt").await?;

   println!("{:?}", bin);
   Ok(())
}

pub async fn list_objects(&self) -> Result<Vec<String>, OperationError>

Get file names vector from the R2 bucket.

Example

use cf_r2_sdk::builder::Builder;
use cf_r2_sdk::error::Error;
use dotenvy::dotenv;
use std::env;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Error> {
   // load .env file
   dotenv().expect(".env file not found.");
   // insert a environment variable
   let bucket_name = env::var("BUCKET_NAME").expect("BUCKET_NAME not found in .env file.");
   let endpoint_url: String =
       env::var("ENDPOINT_URL").expect("ENDPOINT_URL not found in .env file.");
   let access_key_id: String =
       env::var("ACCESS_KEY_ID").expect("ACCESS_KEY_ID not found in .env file.");
   let secret_access_key: String =
      env::var("SECRET_ACCESS_KEY").expect("SECRET_ACCESS_KEY not found in .env file.");
   let region: String = env::var("REGION").expect("REGION not found in .env file.");

   let object: cf_r2_sdk::operator::Operator = Builder::new()
       .set_bucket_name(bucket_name)
       .set_access_key_id(access_key_id)
       .set_secret_access_key(secret_access_key)
       .set_endpoint(endpoint_url)
       .set_region(region)
       .create_client_result()?;

   object
      .upload_binary("sample.txt", "test/plain", b"Hello, World!", None)
      .await?;

   // get file names vector
   let file_names: Vec<String> = object.list_objects().await?;

   for file_name in file_names {
      println!("{}", file_name);
   }

   Ok(())
}

Trait Implementations

impl Clone for Operator

fn clone(&self) -> Operator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Operator

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

Formats the value using the given formatter.