wait.rs 50.8%

62 of 122 lines run, 10 of 34 functions · run #203 on main · run missed

//! `flow wait`: follow the checks a push started on OxygenHub until they
//! finish, so scripts (and people) can gate on the pipeline: exit 0 when
//! every check passed, 1 when one failed, 2 on the time limit.

use anyhow::{bail, Context, Result};
use std::collections::BTreeMap;
use std::time::{Duration, Instant};

#[derive(Debug, PartialEq, Eq)]
pub enum Verdict {
    /// Checks still to come or running.
    Pending,
    Passed,
    /// The checks that failed (or, if required, were skipped).
    Failed(Vec<String>),
}

/// Judge a state's checks, `name → status`, against the repository's
/// required checks. A required check that has not reported yet is pending;
/// a skipped one (a job it depends on failed) is a failure.
pub fn verdict(required: &[String], checks: &BTreeMap<String, String>) -> Verdict {
    if checks.is_empty() || required.iter().any(|r| !checks.contains_key(r)) {
        return Verdict::Pending;
    }
    if checks.values().any(|s| s == "queued" || s == "running") {
        return Verdict::Pending;
    }
    let failed: Vec<String> = checks
        .iter()
        .filter(|(name, status)| match status.as_str() {
            "passed" => false,
            "skipped" => required.contains(name),
            _ => true,
        })
        .map(|(name, _)| name.clone())
        .collect();
    if failed.is_empty() {
        Verdict::Passed
    } else {
        Verdict::Failed(failed)
    }
}

/// `https://hub/owner/name` to the hub's base URL and `owner/name`.
pub fn split_repo_url(url: &str) -> Result<(String, String)> {
    let trimmed = url.trim_end_matches('/');
    let (scheme, rest) = trimmed.split_once("://").context("a repository URL starts with https:// or http://")?;
    let parts: Vec<&str> = rest.split('/').collect();
    if parts.len() < 3 || parts[parts.len() - 2].is_empty() || parts[parts.len() - 1].is_empty() {
        bail!("{url} is not a repository URL (https://hub/owner/name)");
    }
    let n = parts.len();
    Ok((format!("{scheme}://{}", parts[..n - 2].join("/")), format!("{}/{}", parts[n - 2], parts[n - 1])))
}

/// Poll every `every` until the checks of `state` are decided or `limit`
/// passes; print each check when its status changes. Returns the process
/// exit code.
pub fn wait(url: &str, state: &str, token: Option<&str>, ca: Option<&std::path::Path>, limit: Duration, every: Duration) -> Result<i32> {
    if state.len() != 64 || !state.chars().all(|c| c.is_ascii_hexdigit()) {
        bail!("the state is a 64-character hex state hash (oxy push --json prints it)");
    }
    let (base, repo) = split_repo_url(url)?;
    let tls = oxy_core::protocol::tls_client_config(ca).map_err(|e| anyhow::anyhow!("{e}"))?;
    let agent = ureq::AgentBuilder::new().tls_config(tls).timeout(Duration::from_secs(30)).build();
    let get = |path: &str| -> Result<serde_json::Value> {
        let url = format!("{base}/api/v1/repos/{repo}{path}");
        let mut req = agent.get(&url);
        if let Some(t) = token {
            req = req.set("Authorization", &format!("Bearer {t}"));
        }
        match req.call() {
            Ok(r) => Ok(r.into_json()?),
            Err(ureq::Error::Status(code, r)) => bail!("{url}: HTTP {code}: {}", r.into_string().unwrap_or_default()),
            Err(e) => bail!("{url}: {e}"),
        }
    };
    let required: Vec<String> = get("/checks/required")?["names"]
        .as_array()
        .map(|a| a.iter().filter_map(|v| v.as_str().map(String::from)).collect())
        .unwrap_or_default();
    let started = Instant::now();
    let mut seen: BTreeMap<String, String> = BTreeMap::new();
    loop {
        let checks: BTreeMap<String, (String, String)> = get(&format!("/checks/{state}"))?
            .as_array()
            .map(|a| {
                a.iter()
                    .filter_map(|c| {
                        Some((
                            c["name"].as_str()?.to_string(),
                            (c["status"].as_str()?.to_string(), c["summary"].as_str().unwrap_or("").to_string()),
                        ))
                    })
                    .collect()
            })
            .unwrap_or_default();
        for (name, (status, summary)) in &checks {
            if seen.get(name) != Some(status) {
                println!("{name:<24} {status}{}", if summary.is_empty() { String::new() } else { format!("  {summary}") });
                seen.insert(name.clone(), status.clone());
            }
        }
        let statuses: BTreeMap<String, String> = checks.into_iter().map(|(n, (s, _))| (n, s)).collect();
        match verdict(&required, &statuses) {
            Verdict::Passed => {
                println!("every check passed");
                return Ok(0);
            }
            Verdict::Failed(names) => {
                println!("failed: {}", names.join(", "));
                return Ok(1);
            }
            Verdict::Pending if started.elapsed() >= limit => {
                println!("still pending after {} min", limit.as_secs() / 60);
                return Ok(2);
            }
            Verdict::Pending => std::thread::sleep(every),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn checks(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
        pairs.iter().map(|(n, s)| (n.to_string(), s.to_string())).collect()
    }

    #[test]
    fn verdicts() {
        let req = vec!["flow/fmt".to_string(), "flow/test".to_string()];
        assert_eq!(verdict(&req, &checks(&[])), Verdict::Pending, "nothing reported yet");
        assert_eq!(verdict(&req, &checks(&[("flow/fmt", "passed")])), Verdict::Pending, "a required check still to come");
        assert_eq!(verdict(&req, &checks(&[("flow/fmt", "passed"), ("flow/test", "running")])), Verdict::Pending);
        assert_eq!(verdict(&req, &checks(&[("flow/fmt", "passed"), ("flow/test", "passed")])), Verdict::Passed);
        assert_eq!(
            verdict(&req, &checks(&[("flow/fmt", "passed"), ("flow/test", "failed"), ("lint", "passed")])),
            Verdict::Failed(vec!["flow/test".into()])
        );
        assert_eq!(
            verdict(&req, &checks(&[("flow/fmt", "failed"), ("flow/test", "skipped")])),
            Verdict::Failed(vec!["flow/fmt".into(), "flow/test".into()]),
            "a skipped required check fails"
        );
        assert_eq!(
            verdict(&[], &checks(&[("extra", "skipped"), ("other", "passed")])),
            Verdict::Passed,
            "an optional skipped check does not"
        );
        assert_eq!(verdict(&[], &checks(&[("x", "error")])), Verdict::Failed(vec!["x".into()]));
    }

    #[test]
    fn repository_urls() {
        assert_eq!(
            split_repo_url("https://earth.example:7343/andy/oxygen").unwrap(),
            ("https://earth.example:7343".into(), "andy/oxygen".into())
        );
        assert_eq!(split_repo_url("http://h/sub/path/a/b/").unwrap(), ("http://h/sub/path".into(), "a/b".into()));
        assert!(split_repo_url("https://h/only").is_err());
        assert!(split_repo_url("h/a/b").is_err());
    }
}

1		//! `flow wait`: follow the checks a push started on OxygenHub until they
2		//! finish, so scripts (and people) can gate on the pipeline: exit 0 when
3		//! every check passed, 1 when one failed, 2 on the time limit.
4
5		use anyhow::{bail, Context, Result};
6		use std::collections::BTreeMap;
7		use std::time::{Duration, Instant};
8
9		#[derive(Debug, PartialEq, Eq)]
10		pub enum Verdict {
11		/// Checks still to come or running.
12		Pending,
13		Passed,
14		/// The checks that failed (or, if required, were skipped).
15		Failed(Vec<String>),
16		}
17
18		/// Judge a state's checks, `name → status`, against the repository's
19		/// required checks. A required check that has not reported yet is pending;
20		/// a skipped one (a job it depends on failed) is a failure.
21	8×	pub fn verdict(required: &[String], checks: &BTreeMap<String, String>) -> Verdict {
22	10×	if checks.is_empty() \|\| required.iter().any(\|r\| !checks.contains_key(r)) {
23	2×	return Verdict::Pending;
24	6×	}
25	12×	if checks.values().any(\|s\| s == "queued" \|\| s == "running") {
26	1×	return Verdict::Pending;
27	5×	}
28	5×	let failed: Vec<String> = checks
29	5×	.iter()
30	10×	.filter(\|(name, status)\| match status.as_str() {
31	10×	"passed" => false,
32	5×	"skipped" => required.contains(name),
33	3×	_ => true,
34	10×	})
35	5×	.map(\|(name, _)\| name.clone())
36	5×	.collect();
37	5×	if failed.is_empty() {
38	2×	Verdict::Passed
39		} else {
40	3×	Verdict::Failed(failed)
41		}
42	8×	}
43
44		/// `https://hub/owner/name` to the hub's base URL and `owner/name`.
45	4×	pub fn split_repo_url(url: &str) -> Result<(String, String)> {
46	4×	let trimmed = url.trim_end_matches('/');
47	4×	let (scheme, rest) = trimmed.split_once("://").context("a repository URL starts with https:// or http://")?;
48	3×	let parts: Vec<&str> = rest.split('/').collect();
49	3×	if parts.len() < 3 \|\| parts[parts.len() - 2].is_empty() \|\| parts[parts.len() - 1].is_empty() {
50	1×	bail!("{url} is not a repository URL (https://hub/owner/name)");
51	2×	}
52	2×	let n = parts.len();
53	2×	Ok((format!("{scheme}://{}", parts[..n - 2].join("/")), format!("{}/{}", parts[n - 2], parts[n - 1])))
54	4×	}
55
56		/// Poll every `every` until the checks of `state` are decided or `limit`
57		/// passes; print each check when its status changes. Returns the process
58		/// exit code.
59	0×	pub fn wait(url: &str, state: &str, token: Option<&str>, ca: Option<&std::path::Path>, limit: Duration, every: Duration) -> Result<i32> {
60	0×	if state.len() != 64 \|\| !state.chars().all(\|c\| c.is_ascii_hexdigit()) {
61	0×	bail!("the state is a 64-character hex state hash (oxy push --json prints it)");
62	0×	}
63	0×	let (base, repo) = split_repo_url(url)?;
64	0×	let tls = oxy_core::protocol::tls_client_config(ca).map_err(\|e\| anyhow::anyhow!("{e}"))?;
65	0×	let agent = ureq::AgentBuilder::new().tls_config(tls).timeout(Duration::from_secs(30)).build();
66	0×	let get = \|path: &str\| -> Result<serde_json::Value> {
67	0×	let url = format!("{base}/api/v1/repos/{repo}{path}");
68	0×	let mut req = agent.get(&url);
69	0×	if let Some(t) = token {
70	0×	req = req.set("Authorization", &format!("Bearer {t}"));
71	0×	}
72	0×	match req.call() {
73	0×	Ok(r) => Ok(r.into_json()?),
74	0×	Err(ureq::Error::Status(code, r)) => bail!("{url}: HTTP {code}: {}", r.into_string().unwrap_or_default()),
75	0×	Err(e) => bail!("{url}: {e}"),
76		}
77	0×	};
78	0×	let required: Vec<String> = get("/checks/required")?["names"]
79	0×	.as_array()
80	0×	.map(\|a\| a.iter().filter_map(\|v\| v.as_str().map(String::from)).collect())
81	0×	.unwrap_or_default();
82	0×	let started = Instant::now();
83	0×	let mut seen: BTreeMap<String, String> = BTreeMap::new();
84		loop {
85	0×	let checks: BTreeMap<String, (String, String)> = get(&format!("/checks/{state}"))?
86	0×	.as_array()
87	0×	.map(\|a\| {
88	0×	a.iter()
89	0×	.filter_map(\|c\| {
90		Some((
91	0×	c["name"].as_str()?.to_string(),
92	0×	(c["status"].as_str()?.to_string(), c["summary"].as_str().unwrap_or("").to_string()),
93		))
94	0×	})
95	0×	.collect()
96	0×	})
97	0×	.unwrap_or_default();
98	0×	for (name, (status, summary)) in &checks {
99	0×	if seen.get(name) != Some(status) {
100	0×	println!("{name:<24} {status}{}", if summary.is_empty() { String::new() } else { format!(" {summary}") });
101	0×	seen.insert(name.clone(), status.clone());
102	0×	}
103		}
104	0×	let statuses: BTreeMap<String, String> = checks.into_iter().map(\|(n, (s, _))\| (n, s)).collect();
105	0×	match verdict(&required, &statuses) {
106		Verdict::Passed => {
107	0×	println!("every check passed");
108	0×	return Ok(0);
109		}
110	0×	Verdict::Failed(names) => {
111	0×	println!("failed: {}", names.join(", "));
112	0×	return Ok(1);
113		}
114	0×	Verdict::Pending if started.elapsed() >= limit => {
115	0×	println!("still pending after {} min", limit.as_secs() / 60);
116	0×	return Ok(2);
117		}
118	0×	Verdict::Pending => std::thread::sleep(every),
119		}
120		}
121	0×	}
122
123		#[cfg(test)]
124		mod tests {
125		use super::*;
126
127	8×	fn checks(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
128	13×	pairs.iter().map(\|(n, s)\| (n.to_string(), s.to_string())).collect()
129	8×	}
130
131		#[test]
132	1×	fn verdicts() {
133	1×	let req = vec!["flow/fmt".to_string(), "flow/test".to_string()];
134	1×	assert_eq!(verdict(&req, &checks(&[])), Verdict::Pending, "nothing reported yet");
135	1×	assert_eq!(verdict(&req, &checks(&[("flow/fmt", "passed")])), Verdict::Pending, "a required check still to come");
136	1×	assert_eq!(verdict(&req, &checks(&[("flow/fmt", "passed"), ("flow/test", "running")])), Verdict::Pending);
137	1×	assert_eq!(verdict(&req, &checks(&[("flow/fmt", "passed"), ("flow/test", "passed")])), Verdict::Passed);
138	1×	assert_eq!(
139	1×	verdict(&req, &checks(&[("flow/fmt", "passed"), ("flow/test", "failed"), ("lint", "passed")])),
140	1×	Verdict::Failed(vec!["flow/test".into()])
141		);
142	1×	assert_eq!(
143	1×	verdict(&req, &checks(&[("flow/fmt", "failed"), ("flow/test", "skipped")])),
144	1×	Verdict::Failed(vec!["flow/fmt".into(), "flow/test".into()]),
145		"a skipped required check fails"
146		);
147	1×	assert_eq!(
148	1×	verdict(&[], &checks(&[("extra", "skipped"), ("other", "passed")])),
149		Verdict::Passed,
150		"an optional skipped check does not"
151		);
152	1×	assert_eq!(verdict(&[], &checks(&[("x", "error")])), Verdict::Failed(vec!["x".into()]));
153	1×	}
154
155		#[test]
156	1×	fn repository_urls() {
157	1×	assert_eq!(
158	1×	split_repo_url("https://earth.example:7343/andy/oxygen").unwrap(),
159	1×	("https://earth.example:7343".into(), "andy/oxygen".into())
160		);
161	1×	assert_eq!(split_repo_url("http://h/sub/path/a/b/").unwrap(), ("http://h/sub/path".into(), "a/b".into()));
162	1×	assert!(split_repo_url("https://h/only").is_err());
163	1×	assert!(split_repo_url("h/a/b").is_err());
164	1×	}
165		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/flow/src/wait.rs 50.8%

Keyboard