Files
labyrinth/src/lib.rs
T
phoenix f406ed1961
labyrinth release Tagging / release (push) Successful in 1m15s
simodels Build / build (push) Successful in 1m25s
simodels Build / Test Suite (push) Successful in 1m35s
simodels Build / Check (push) Successful in 1m38s
simodels Build / Rustfmt (push) Successful in 2m33s
simodels Build / Clippy (push) Successful in 2m49s
Delete object (#3)
Reviewed-on: http://git.kundeng.us/phoenix/labyrinth/pulls/3
2026-08-11 10:39:12 -04:00

128 lines
3.5 KiB
Rust

pub mod config;
use aws_sdk_s3::config::{Credentials, Region};
#[derive(Debug, Default)]
pub struct Data {
pub filepath: String,
pub raw_data: Vec<u8>,
}
pub struct Labyrinth {
pub config: config::Config,
}
pub async fn load_data(filepath: &str) -> Result<Vec<u8>, std::io::Error> {
tokio::fs::read(filepath).await
}
pub async fn init_client(config: &config::Config) -> aws_sdk_s3::Client {
let credentials = Credentials::new(
config.access_key_id.clone(),
config.secret_key.clone(),
None,
None,
"maze",
);
let region = Region::new(config.region.to_string());
let config = aws_config::from_env()
.region(region)
.credentials_provider(credentials)
.endpoint_url(config.url.clone())
.load()
.await;
let s3_config = aws_sdk_s3::config::Builder::from(&config)
.force_path_style(true)
.build();
aws_sdk_s3::Client::from_conf(s3_config)
}
#[derive(Debug)]
pub enum Error {
Info(String),
SError(aws_sdk_s3::operation::put_object::PutObjectError),
}
impl Labyrinth {
/// Upload object to the bucket
pub async fn upload(
&self,
file_key: &str,
data: &Data,
) -> Result<aws_sdk_s3::operation::put_object::PutObjectOutput, Error> {
let client = init_client(&self.config).await;
let data_content = if data.raw_data.is_empty() {
match load_data(&data.filepath).await {
Ok(content) => content,
Err(err) => return Err(Error::Info(err.to_string())),
}
} else {
data.raw_data.to_owned()
};
let body = aws_sdk_s3::primitives::SdkBody::from(data_content);
let b_stream = aws_sdk_s3::primitives::ByteStream::from(body);
match client
.put_object()
.bucket(self.config.bucket.clone())
.key(file_key)
.body(b_stream)
.send()
.await
{
Ok(response) => Ok(response),
Err(err) => Err(Error::Info(err.to_string())),
}
}
/// Download object from the bucket
pub async fn download(&self, file_key: &str) -> Result<Vec<u8>, Error> {
let client = init_client(&self.config).await;
match client
.get_object()
.bucket(self.config.bucket.clone())
.key(file_key)
.send()
.await
{
Ok(response) => {
let body = response.body;
// Get the body as ByteStream
match body.collect().await {
Ok(data) => {
let bytes = data.into_bytes();
let raw_data = bytes.to_vec();
Ok(raw_data)
}
Err(err) => Err(Error::Info(err.to_string())),
}
}
Err(err) => Err(Error::Info(err.to_string())),
}
}
/// Delete an object from the bucket
pub async fn delete(
&self,
file_key: &str,
) -> Result<aws_sdk_s3::operation::delete_object::DeleteObjectOutput, Error> {
let client = init_client(&self.config).await;
match client
.delete_object()
.bucket(self.config.bucket.clone())
.key(file_key)
.send()
.await
{
Ok(response) => Ok(response),
Err(err) => Err(Error::Info(err.to_string())),
}
}
}