use async_trait::async_trait;
use tokio::runtime::Handle;
use ve_tos_rust_sdk::common::init_tracing_log;
use ve_tos_rust_sdk::asynchronous::bucket::BucketAPI;
use ve_tos_rust_sdk::asynchronous::tos;
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;
use ve_tos_rust_sdk::bucket::HeadBucketInput;
use ve_tos_rust_sdk::error::TosError;
#[derive(Debug, Default)]
pub struct TokioRuntime {}
impl AsyncRuntime for TokioRuntime {
type JoinError = tokio::task::JoinError;
async fn sleep(&self, duration: std::time::Duration) {
tokio::time::sleep(duration).await;
fn spawn<'a, F>(&self, future: F) -> futures_core::future::BoxFuture<'a, Result<F::Output, Self::JoinError>>
F: std::future::Future + Send + 'static,
F::Output: Send + 'static,
Box::pin(Handle::current().spawn(future))
fn block_on<F: std::future::Future>(&self, future: F) -> F::Output {
Handle::current().block_on(future)
init_tracing_log("info", "temp/logs", "app.log");
let ak = env::var("TOS_ACCESS_KEY").unwrap_or_default();
let sk = env::var("TOS_SECRET_KEY").unwrap_or_default();
let endpoint = "https://tos-cn-beijing.volces.com";
let region = "cn-beijing";
let bucket_name = "example-bucket";
let client = tos::builder::<TokioRuntime>()
let input = HeadBucketInput::new(bucket_name);
let result = client.head_bucket(&input).await;
println!("Bucket '{}' exists and is accessible.", bucket_name);
println!("Bucket region: {}", output.region());
println!("Default storage class: {}", output.storage_class().as_ref().map(|sc| sc.as_str()).unwrap_or("Unknown"));
println!("AZ redundancy type: {}", output.az_redundancy().as_ref().map(|az| az.as_str()).unwrap_or("Unknown"));
println!("Bucket type: {}", output.bucket_type().as_ref().map(|bt| bt.as_str()).unwrap_or("flat"));
TosError::TosServerError { status_code, .. } => {
println!("Bucket '{}' does not exist.", bucket_name);
} else if status_code == 403 {
println!("No access permission to bucket '{}'.", bucket_name);
println!("Server error: {:?}", err);
println!("Client error: {:?}", err);