The get_symlink interface retrieves soft link object information. This article explains how to use the get_symlink interface of the Rust SDK to read the target file and version number pointed to by the soft link.

Notes

You need to fill in the region and access domain in the sample code according to your actual situation. For details, see region and access domain.

To prevent key leakage, the sample code in this article reads the Access Key ID and Secret Access Key from environment variables. Therefore, before using the SDK, you need to configure long-term access credentials. For details, see Configure Long-Term Access Credentials.

symlink_target_key specifies the target file path pointed to by the symlink and must be combined with symlink_target_bucket to determine the complete object location.

Permissions required

The Volcano Engine main account has all permissions by default, but IAM users have no permissions by default. If you need to perform get_symlink operations with a sub-account, the Volcano Engine main account must grant the following permissions to the sub-account through IAM policies and bucket policies:

tos:GetObject

Code example

Get symlink object information

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::object::ObjectAPI;​
use ve_tos_rust_sdk::asynchronous::tos;​
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;​
use ve_tos_rust_sdk::object::GetSymlinkInput;​
use ve_tos_rust_sdk::error::TosError;​
use chrono::{DateTime, Utc};​
​
#[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();​
​
    // Case: Get symlink object information​
    let bucket_name = "example-bucket";​
    let symlink_key = "example-object";​
    let input = GetSymlinkInput::new(bucket_name, symlink_key);​
​
    let result = client.get_symlink(&input).await;​
    match result {​
        Ok(output) => {​
            println!("version_id: {}", output.version_id());​
            println!("symlink_target_key: {}", output.symlink_target_key());​
            println!("symlink_target_bucket: {}", output.symlink_target_bucket());​
            println!("etag: {}", output.etag());​
            if let Some(last_modified) = output.last_modified() {​
                println!("last_modified: {}", last_modified.to_rfc3339());​
            } else {​
                println!("last_modified: None");​
            }​
        }​
        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);​
                }​
            }​
        }​
    }​
}​