biolib 1.3.301

BioLib client library and CLI for running applications on BioLib
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

use std::cell::RefCell;
use std::time::{Duration, Instant};

use crate::api::ApiClient;

pub trait RemoteEndpoint {
    fn get_remote_url(&self) -> crate::Result<String>;
}

pub struct RemoteJobStorageEndpoint {
    job_uuid: String,
    job_auth_token: String,
    storage_type: String,
    presigned_url: RefCell<Option<String>>,
    fetched_at: RefCell<Option<Instant>>,
}

// 8-minute TTL matching Python client's RemoteJobStorageEndpoint
const PRESIGNED_URL_TTL: Duration = Duration::from_secs(8 * 60);

impl RemoteJobStorageEndpoint {
    pub fn new(job_uuid: String, job_auth_token: String, storage_type: String) -> Self {
        Self {
            job_uuid,
            job_auth_token,
            storage_type,
            presigned_url: RefCell::new(None),
            fetched_at: RefCell::new(None),
        }
    }
}

impl RemoteEndpoint for RemoteJobStorageEndpoint {
    fn get_remote_url(&self) -> crate::Result<String> {
        let needs_refresh = {
            let url = self.presigned_url.borrow();
            let fetched = self.fetched_at.borrow();
            url.is_none() || fetched.is_none_or(|t| t.elapsed() > PRESIGNED_URL_TTL)
        };

        if needs_refresh {
            let config = crate::Config::load();
            let mut client = ApiClient::new(&config)?;

            let mut last_err = None;
            for attempt in 0..3 {
                match client.get_job_storage_download_url(
                    &self.job_uuid,
                    &self.job_auth_token,
                    &self.storage_type,
                ) {
                    Ok(url) => {
                        crate::logging::debug(&format!(
                            "Job \"{}\" fetched presigned URL (TTL {}s)",
                            self.job_uuid,
                            PRESIGNED_URL_TTL.as_secs()
                        ));
                        *self.presigned_url.borrow_mut() = Some(url);
                        *self.fetched_at.borrow_mut() = Some(Instant::now());
                        last_err = None;
                        break;
                    }
                    Err(err) => {
                        crate::logging::warning(&format!(
                            "Failed to fetch presigned URL for job \"{}\" (attempt {}): {}",
                            self.job_uuid,
                            attempt + 1,
                            err
                        ));
                        last_err = Some(err);
                        std::thread::sleep(Duration::from_secs(3 * (attempt + 1)));
                    }
                }
            }
            if let Some(err) = last_err {
                return Err(err);
            }
        }

        Ok(self.presigned_url.borrow().clone().unwrap())
    }
}