get_fetch_task 接口用于查询异步抓取任务详情，含状态与回调信息。Rust SDK 示例展示如何传入 taskId 获取结果，仅支持 72 小时内任务。

注意事项

您需要根据实际情况，填写示例代码中的地域和访问域名，详细介绍，请参见地域和访问域名。

为了防止密钥泄露，本文示例代码需要从环境变量中读取 Access Key ID 和 Secret Access Key。因此使用 SDK 前，您需要配置长期访问凭证，详细介绍，请参见配置长期访问凭证。

get_fetch_task 仅支持查询 72 小时内的任务，超时后无法返回结果。

分层桶不支持 get_fetch_task，调用前需确认桶类型。

权限说明

火山引擎主账号默认拥有全部权限，但是 IAM 用户默认没有任何权限。如果您需要使用子账号执行 get_fetch_task 操作，火山引擎主账号需通过 IAM策略和桶策略为该子账号授予以下权限：

tos:GetFetchTask

代码示例

查询抓取任务的详细信息

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::object::ObjectAPI;​
use ve_tos_rust_sdk::asynchronous::tos;​
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;​
use ve_tos_rust_sdk::object::{GetFetchTaskInput};​
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();​
​
    // Prepare input for GetFetchTask​
    let bucket = "example-bucket";​
    let task_id = "3b35b85c-b724-***";​
    let input = GetFetchTaskInput::new(bucket, task_id);​
​
    // Call GetFetchTask API​
    let result = client.get_fetch_task(&input).await;​
    match result {​
        Ok(output) => {​
            println!("state: {}", output.state());​
            if !output.err().is_empty() {​
                println!("err: {}", output.err());​
            }​
            if let Some(task) = output.task() {​
                println!("task.url: {}", task.url());​
                println!("task.ignore_same_key: {}", task.ignore_same_key());​
                println!("task.content_md5: {}", task.content_md5());​
                println!("task.bucket: {}", task.bucket());​
                println!("task.key: {}", task.key());​
                println!("task.callback_url: {}", task.callback_url());​
                println!("task.callback_host: {}", task.callback_host());​
                println!("task.callback_body_type: {}", task.callback_body_type());​
                println!("task.callback_body: {}", task.callback_body());​
                if let Some(sc) = task.storage_class() {​
                    println!("task.storage_class: {}", sc.as_str());​
                }​
                if let Some(acl) = task.acl() {​
                    println!("task.acl: {}", acl.as_str());​
                }​
                println!("task.grant_fullcontrol: {}", task.grant_fullcontrol());​
                println!("task.grant_read: {}", task.grant_read());​
                println!("task.grant_read_acp: {}", task.grant_read_acp());​
                println!("task.grant_write: {}", task.grant_write());​
                println!("task.grant_write_acp: {}", task.grant_write_acp());​
                println!("task.ssec_algorithm: {}", task.ssec_algorithm());​
                println!("task.ssec_key: {}", task.ssec_key());​
                println!("task.ssec_key_md5: {}", task.ssec_key_md5());​
                println!("task.user_meta entries:");​
                for (idx, meta) in task.meta().iter().enumerate() {​
                    println!("  [{}] key: {}, value: {}", idx, meta.0, meta.1);​
                }​
                println!("task.meta entries:");​
                for (k, v) in task.meta().iter() {​
                    println!("  {}: {}", k, v);​
                }​
            }​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error: request_id: {}, ec: {}, code: {}", request_id, ec, code);​
                }​
            }​
        }​
    }​
}​
​

对象存储