tes 0.10.0

A crate for working with the Task Execution Service (TES) specification
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! Lists all tasks known about within an execution service.
//!
//! You can run this with the following command:
//!
//! ```bash
//! export USER="<USER>"
//! export PASSWORD="<PASSWORD>"
//! export RUST_LOG="tes=debug"
//!
//! cargo run --release --features=client,serde --example task-list-all <URL>
//! ```

use base64::prelude::*;
use miette::Context as _;
use miette::IntoDiagnostic;
use miette::Result;
use tes::v1::client::Client;
use tes::v1::client::strategy::ExponentialFactorBackoff;
use tes::v1::client::strategy::MaxInterval;
use tes::v1::types::requests::ListTasksParams;
use tes::v1::types::requests::View;
use tracing_subscriber::EnvFilter; // Import the Engine trait

/// The environment variable for a basic auth username.
const USER_ENV: &str = "USER";

/// The environment variable for a basic auth password.
const PASSWORD_ENV: &str = "PASSWORD";

/// Lists all tasks on the server.
async fn list_all_tasks(client: &Client) -> Result<()> {
    let mut last_token = None;

    loop {
        let retries = ExponentialFactorBackoff::from_millis(1000, 2.0)
            .max_interval(10000)
            .take(3);

        let response = client
            .list_tasks(
                Some(&ListTasksParams {
                    view: Some(View::Full),
                    page_token: last_token,
                    ..Default::default()
                }),
                retries,
            )
            .await
            .into_diagnostic()
            .context("listing tasks")?;

        println!("{response:#?}");

        last_token = response.next_page_token;
        if last_token.is_none() {
            break;
        }
    }

    Ok(())
}

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    let url = std::env::args().nth(1).expect("url to be present");

    let mut builder = Client::builder()
        .url_from_string(url)
        .expect("url could not be parsed");

    let username = std::env::var(USER_ENV).ok();
    let password = std::env::var(PASSWORD_ENV).ok();

    if (username.is_some() && password.is_none()) || (username.is_none() && password.is_some()) {
        panic!("${USER_ENV} and ${PASSWORD_ENV} must both be set to use basic auth");
    }

    if let Some(username) = username {
        let credentials = format!("{}:{}", username, password.unwrap());
        let encoded = BASE64_STANDARD.encode(credentials);
        builder = builder.insert_header("Authorization", format!("Basic {encoded}"));
    }

    let client = builder.try_build().expect("could not build client");
    list_all_tasks(&client).await?;

    Ok(())
}