walker-extras 0.17.0

Additional functionality for SBOM and CSAF walker
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::visitors::SendVisitor;
use reqwest::Url;
use std::path::PathBuf;
use walker_common::sender::{
    HttpSender, HttpSenderOptions, provider::OpenIdTokenProviderConfigArguments,
};

#[derive(Debug, clap::Parser)]
#[command(next_help_heading = "Sending")]
pub struct SendArguments {
    /// Target to send to
    pub target: Url,

    /// Sender connect timeout
    #[arg(
        id = "sender-connect-timeout",
        long,
        env = "SENDER_CONNECT_TIMEOUT",
        default_value = "15s"
    )]
    pub connect_timeout: humantime::Duration,

    /// Sender request timeout
    #[arg(
        id = "sender-timeout",
        long,
        env = "SENDER_TIMEOUT",
        default_value = "5m"
    )]
    pub timeout: humantime::Duration,

    /// Additional root certificates
    #[arg(id = "sender-tls-ca-certificate", long)]
    pub additional_root_certificates: Vec<PathBuf>,

    /// Allow using TLS in an insecure mode when contacting the target (DANGER!)
    #[arg(id = "sender-tls-insecure", long)]
    pub tls_insecure: bool,

    /// Number of retries in case of temporary failures
    #[arg(
        id = "sender-retries",
        long,
        env = "SENDER_RETRIES",
        default_value = "0"
    )]
    pub retries: usize,

    /// Minimum delay between retries
    #[arg(
        id = "sender-min-delay",
        long,
        env = "SENDER_MIN_DELAY",
        default_value = "1s"
    )]
    pub min_delay: humantime::Duration,

    /// Maximum delay between retries
    #[arg(
        id = "sender-max-delay",
        long,
        env = "SENDER_MAX_DELAY",
        default_value = "60s"
    )]
    pub max_delay: humantime::Duration,

    /// Custom query parameters
    #[arg(
        id = "sender-query-parameter",
        long,
        env = "SENDER_QUERY_PARAMETER",
        value_delimiter = ','
    )]
    pub query: Vec<String>,

    #[command(flatten)]
    pub oidc: OpenIdTokenProviderConfigArguments,
}

impl SendArguments {
    pub async fn into_visitor(self) -> Result<SendVisitor, anyhow::Error> {
        let SendArguments {
            target,
            connect_timeout,
            timeout,
            additional_root_certificates,
            tls_insecure,
            retries,
            min_delay,
            max_delay,
            oidc,
            query,
        } = self;

        let provider = oidc.into_provider().await?;
        let sender = HttpSender::new(
            provider,
            HttpSenderOptions::default()
                .connect_timeout(Some(connect_timeout.into()))
                .timeout(Some(timeout.into()))
                .tls_insecure(tls_insecure)
                .additional_root_certificates(additional_root_certificates)
                .query_parameters(query.into_iter().map(|entry| match entry.split_once('=') {
                    Some((key, value)) => (key.to_string(), value.to_string()),
                    None => (entry, "".to_string()),
                })),
        )
        .await?;

        Ok(SendVisitor::new(target, sender)
            .retries(retries)
            .min_delay(min_delay)
            .max_delay(max_delay))
    }
}