use anyhow::{Context, Result};
use crate::git::Git;
use crate::issue::IssueUrl;
use crate::progress;
pub(crate) mod inbox;
mod recovery;
pub(crate) use recovery::recover;
pub struct Reservation {
launch: Git,
reference: String,
token: String,
}
impl Reservation {
pub(crate) fn release(launch: &Git) -> Result<Option<Self>> {
Self::take_ref(
launch,
"refs/thirdshift/reservations/release".into(),
"Release run",
)
}
pub fn is_held(launch: &Git, issue: &IssueUrl) -> Result<bool> {
let origin = launch.run(&["config", "remote.origin.url"])?;
let remote = if issue.matches_origin(&origin) {
"origin".to_owned()
} else {
format!("https://github.com/{}.git", issue.repo_slug())
};
let reference = reference(issue.number);
let held = launch.run(&["ls-remote", "--refs", &remote, &reference])?;
if remote == "origin"
&& let Some((sha, _)) = held.split_once('\t')
{
recovery::blocked(launch, &reference, sha);
}
Ok(!held.is_empty())
}
pub fn take(launch: &Git, issue: &IssueUrl) -> Result<Option<Self>> {
Self::take_ref(launch, reference(issue.number), &issue.url)
}
pub(crate) fn pull_request(
launch: &Git,
pr: &crate::review::PullRequestUrl,
) -> Result<Option<Self>> {
Self::take_ref(
launch,
format!("refs/thirdshift/reservations/{}", pr.issue.number),
&pr.url,
)
}
pub fn of_published(launch: &Git, issue: &IssueUrl) -> Result<Self> {
Self::take(launch, issue)?.with_context(|| {
format!(
"#{} is already reserved on origin, at {}",
issue.number,
reference(issue.number)
)
})
}
pub fn ci_red(launch: &Git) -> Result<Option<Self>> {
Self::take_ref(
launch,
"refs/heads/thirdshift/pickup/ci-red".into(),
"CI-red Ticket filing",
)
}
fn take_ref(launch: &Git, reference: String, subject: &str) -> Result<Option<Self>> {
let nonce = tempfile::Builder::new().rand_bytes(32).tempfile()?;
let tree = launch.run(&["mktree"])?;
let message = format!(
"thirdshift Pickup reservation for {}\n\nToken: {}\nHost: {}\nLaunch: {}\nProcess: {}\nStarted: {}",
subject,
nonce.path().display(),
crate::host::name().unwrap_or_else(|| "unknown".into()),
launch.dir().display(),
std::process::id(),
chrono::Utc::now(),
);
let token = launch.run(&[
"-c",
"commit.gpgSign=false",
"commit-tree",
&tree,
"-m",
&message,
])?;
let pushed = launch.run(&[
"push",
"--no-verify",
&format!("--force-with-lease={reference}:"),
"origin",
&format!("{token}:{reference}"),
]);
if let Err(error) = pushed {
let remote = launch.run(&["ls-remote", "--refs", "origin", &reference])
.with_context(|| format!(
"{error:#}; could not verify reservation {reference}; check origin by hand (our token {token})"
))?;
if let Some((other, _)) = remote.split_once('\t')
&& other != token
{
recovery::blocked(launch, &reference, other);
return Ok(None);
}
return Err(error).with_context(|| format!(
"could not reserve {reference}; check origin by hand before retrying (our token {token})"
));
}
Ok(Some(Self {
launch: launch.completion(),
reference,
token,
}))
}
}
pub fn reference(number: u64) -> String {
format!("refs/heads/thirdshift/pickup/{number}")
}
impl Drop for Reservation {
fn drop(&mut self) {
if let Err(error) = self.launch.run(&[
"push",
"--no-verify",
&format!("--force-with-lease={}:{}", self.reference, self.token),
"origin",
&format!(":{}", self.reference),
]) {
progress::warn(
&error,
format_args!(
"could not release Pickup reservation {}; check origin by hand (our token {})",
self.reference, self.token
),
);
}
}
}