The does_bucket_exist interface checks if a bucket with the specified name exists. This article explains how to use the does_bucket_exist interface in the Rust SDK to perform this check.

Notes

You need to fill in the region and endpoint in the sample code according to your actual situation. For details, see Regions and endpoints.

To prevent key leakage, the sample code reads the Access Key ID and Secret Access Key from environment variables. Therefore, before using the SDK, you must configure long-term access credentials. For details, see Configure long-term access credentials.

Permissions required

The Volcano Engine primary account has all permissions by default, but IAM users have no permissions by default. If you want to perform the does_bucket_exist operation with a sub-account, the Volcano Engine primary account must grant the following permissions to the sub-account through IAM policies and Bucket policies:

tos:HeadBucket

Code example

Check if the bucket exists

use async_trait::async_trait;​
use futures_core::future::BoxFuture;​
use std::env;​
use std::future::Future;​
use std::time::Duration;​
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::DoesBucketExistInput;​
use ve_tos_rust_sdk::error::TosError;​
​
#[derive(Debug, Default)]​
pub struct TokioRuntime {}​
​
#[async_trait]​
impl AsyncRuntime for TokioRuntime {​
    type JoinError = tokio::task::JoinError;​
    async fn sleep(&self, duration: Duration) {​
        tokio::time::sleep(duration).await;​
    }​
​
    fn spawn<'a, F>(&self, future: F) -> BoxFuture<'a, Result<F::Output, Self::JoinError>>​
    where​
        F: Future + Send + 'static,​
        F::Output: Send + 'static,​
    {​
        Box::pin(Handle::current().spawn(future))​
    }​
​
    fn block_on<F: Future>(&self, future: F) -> F::Output {​
        Handle::current().block_on(future)​
    }​
}​
​
#[tokio::main]​
async fn main() {​
    let _guard = init_tracing_log("info", "temp/logs", "app.log");​
    let ak = env::var("TOS_ACCESS_KEY").unwrap_or("".to_string());​
    let sk = env::var("TOS_SECRET_KEY").unwrap_or("".to_string());​
    let endpoint = "https://tos-cn-beijing.volces.com";​
    let region = "cn-beijing";​
    let client = tos::builder::<TokioRuntime>()​
        .connection_timeout(3000)​
        .request_timeout(10000)​
        .max_retry_count(3)​
        .ak(ak)​
        .sk(sk)​
        .region(region)​
        .endpoint(endpoint)​
        .build().unwrap();​
​
    // Check if specified bucket exists​
    let input = DoesBucketExistInput::new("example-bucket");​
    let result = client.does_bucket_exist(&input).await;​
    match result {​
        Ok(exists) => {​
            println!("Bucket 'example-bucket' exists: {}", exists);​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error message: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error: request_id: {}, ec: {}, code: {}", request_id, ec, code);​
                }​
                _ => println!("Unknown error: {:?}", err)​
            }​
        }​
    }​
}​