diff --git a/oxa/oxa-cli/src/work_board/landing.rs b/oxa/oxa-cli/src/work_board/landing.rs index df67eb015..f041957eb 100644 --- a/oxa/oxa-cli/src/work_board/landing.rs +++ b/oxa/oxa-cli/src/work_board/landing.rs @@ -90,6 +90,7 @@ pub(super) fn review_decisions( LandingDecision { next: plan.next, queue_alarm: plan.queue_alarm, + repeat_rejection_alarm: false, queue: queued.remove(&number), latest_reviews: observations[&number].reviews, would_notify_rejection: None, diff --git a/oxa/oxa-work/src/board/queue.rs b/oxa/oxa-work/src/board/queue.rs index b44a9f302..8582595a1 100644 --- a/oxa/oxa-work/src/board/queue.rs +++ b/oxa/oxa-work/src/board/queue.rs @@ -9,7 +9,7 @@ pub mod report; const BATCH: usize = 8; const MAX_PRS: usize = 1000; const MAX_BYTES: usize = 4 * 1024 * 1024; -const QUEUE: &str = r#"mergeQueue(branch:"main"){id}"#; +const QUEUE: &str = r#"id mergeQueue(branch:"main"){id}"#; #[derive(Clone, Debug, Serialize, PartialEq, Eq)] pub struct RejectionEvidence { @@ -18,6 +18,8 @@ pub struct RejectionEvidence { removed_at: String, #[serde(skip)] notification_target: Option, + #[serde(skip)] + publication: Option, merge_group_head: String, failed_required_check_runs: Vec, #[serde(skip_serializing_if = "BTreeMap::is_empty")] @@ -28,9 +30,18 @@ pub struct RejectionEvidence { #[derive(Clone, Debug, Serialize, PartialEq, Eq)] pub(crate) struct NotificationTarget { - pull_request_id: String, - author_id: String, - login: String, + pub(crate) pull_request_id: String, + pub(crate) author_id: String, + pub(crate) login: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct PublicationBinding { + repository_id: String, + queue_id: String, + pr_head: String, + absent: bool, + admission_upper_bound: Option, } impl NotificationTarget { @@ -77,6 +88,24 @@ impl RejectionEvidence { self.notification_target.as_ref() } + pub(crate) fn publication_binding(&self) -> Option<(crate::RejectedLanding, Option)> { + let binding = self.publication.as_ref()?; + let target = self.notification_target()?; + Some(( + crate::RejectedLanding { + repository_id: binding.repository_id.clone(), + queue_id: binding.queue_id.clone(), + pull_request_id: target.pull_request_id.clone(), + pull_request_number: self.number, + pr_head: binding.pr_head.clone(), + rejected_group: self.merge_group_head.clone(), + removal_id: self.removal_event.clone(), + removed_at: oxa_session::parse_utc_seconds(&self.removed_at)?, + }, + binding.admission_upper_bound.filter(|_| binding.absent), + )) + } + pub(crate) fn admission_identity(&self) -> Removal<'_> { Removal { number: self.number, @@ -147,6 +176,10 @@ pub fn read( fields, r#"p{n}:pullRequest(number:{n}){{ id number headRefOid state baseRefName + mergeQueueEntry{{id}} + admissions:timelineItems(last:3,itemTypes:[ADDED_TO_MERGE_QUEUE_EVENT]){{ + pageInfo{{hasPreviousPage hasNextPage}} nodes{{__typename ... on AddedToMergeQueueEvent{{id}}}} + }} author{{__typename login ... on User{{id}} ... on Bot{{id}}}} timelineItems(last:1,itemTypes:[ADDED_TO_MERGE_QUEUE_EVENT,REMOVED_FROM_MERGE_QUEUE_EVENT]){{ nodes{{__typename ... on RemovedFromMergeQueueEvent{{ @@ -182,7 +215,12 @@ pub fn read( } let Some(queue_id) = current else { continue }; for entry in batch { - if let Some(rejection) = rejection(&data[format!("p{}", entry.number)], entry, queue_id)? { + if let Some(rejection) = rejection( + &data[format!("p{}", entry.number)], + entry, + queue_id, + node_id(&data["id"]), + )? { rejections.push(rejection); } } @@ -190,6 +228,33 @@ pub fn read( Ok(rejections) } +/// Re-read the exact pending entry using the same repository Reader. +pub fn read_acknowledged_admission( + acknowledgment: &crate::AdmissionAcknowledgment, + mut repository_read: impl FnMut(&str) -> Result<(Value, usize), String>, +) -> Result { + let rejection = &acknowledgment.intent.delivery.intent.rejection; + let number = rejection.pull_request_number; + let (data, bytes) = repository_read(&format!( + r#"id mergeQueue(branch:"main"){{id}} pullRequest(number:{number}){{ + mergeQueueEntry{{id enqueuedAt mergeQueue{{id repository{{id}}}} + pullRequest{{id number headRefOid}} headCommit{{oid}} + enqueuer{{__typename ... on User{{id}} ... on Bot{{id}}}}}} + }}"# + ))?; + if bytes > MAX_BYTES + || data["id"].as_str() != Some(&rejection.repository_id) + || data["mergeQueue"]["id"].as_str() != Some(&rejection.queue_id) + { + return Err("queue changed since the recorded admission acknowledgment".into()); + } + data["pullRequest"]["mergeQueueEntry"] + .as_object() + .cloned() + .map(Value::Object) + .ok_or_else(|| "the acknowledged queue entry is unavailable".into()) +} + fn node_id(value: &Value) -> Option<&str> { value.as_str().filter(|id| is_node_id(id)) } @@ -209,7 +274,12 @@ pub fn is_object_id(sha: &str) -> bool { .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) } -fn rejection(row: &Value, entry: &Entry, queue_id: &str) -> Result, String> { +fn rejection( + row: &Value, + entry: &Entry, + queue_id: &str, + repository_id: Option<&str>, +) -> Result, String> { if row["number"].as_u64() != Some(entry.number) || row["headRefOid"].as_str() != Some(entry.head.as_str()) || row["state"] != "OPEN" @@ -286,6 +356,13 @@ fn rejection(row: &Value, entry: &Entry, queue_id: &str) -> Result Result Option { + let nodes = page["nodes"].as_array().filter(|nodes| nodes.len() <= 3)?; + if page["pageInfo"]["hasPreviousPage"] != false || page["pageInfo"]["hasNextPage"] != false { + return None; + } + let mut ids = BTreeSet::new(); + nodes + .iter() + .all(|row| { + row["__typename"] == "AddedToMergeQueueEvent" + && node_id(&row["id"]).is_some_and(|id| ids.insert(id)) + }) + .then_some(nodes.len() as u8) +} + /// Validate a canonical UTC second before comparing GitHub event times. pub(super) fn github_utc(value: &Value) -> Option<&str> { value @@ -308,6 +400,15 @@ mod tests { use super::*; use serde_json::json; + #[test] + fn admission_cap_counts_filtered_events_and_refuses_incomplete_pages() { + let mut page = json!({"totalCount":42,"pageInfo":{"hasPreviousPage":false,"hasNextPage":false}, + "nodes":[{"__typename":"AddedToMergeQueueEvent","id":"E_admitted"}]}); + assert_eq!(admission_upper_bound(&page), Some(1)); + page["pageInfo"]["hasPreviousPage"] = json!(true); + assert_eq!(admission_upper_bound(&page), None); + } + #[test] fn notification_target_requires_the_pr_and_a_supported_author_identity() { let mut row = json!({"id":"pr-42"}); diff --git a/oxa/oxa-work/src/board/queue/report.rs b/oxa/oxa-work/src/board/queue/report.rs index 7a2154ca4..325c58697 100644 --- a/oxa/oxa-work/src/board/queue/report.rs +++ b/oxa/oxa-work/src/board/queue/report.rs @@ -224,6 +224,7 @@ mod tests { removal_event: "removal".into(), removed_at: "2026-01-01T00:09:00Z".into(), notification_target: None, + publication: None, merge_group_head: HEAD.into(), failed_required_check_runs: vec![42], failed_required_workflows: [( diff --git a/oxa/oxa-work/src/publish/landing.rs b/oxa/oxa-work/src/publish/landing.rs index 73564257b..be9a85894 100644 --- a/oxa/oxa-work/src/publish/landing.rs +++ b/oxa/oxa-work/src/publish/landing.rs @@ -9,11 +9,13 @@ use serde_json::Value; use std::{fs::File, path::Path}; const ADD_COMMENT: &str = "mutation($pr:ID!,$body:String!){addComment(input:{subjectId:$pr,body:$body}){ - commentEdge{node{id repository{id} pullRequest{id} author{__typename + commentEdge{node{id repository{id} pullRequest{id headRefOid author{login ... on User{id} ... on Bot{id}}} + author{__typename ... on User{id} ... on Bot{id}} createdAt}}}}"; const ENQUEUE: &str = "mutation($pr:ID!,$head:GitObjectID!){enqueuePullRequest(input:{ pullRequestId:$pr,expectedHeadOid:$head}){mergeQueueEntry{id enqueuedAt - mergeQueue{id repository{id}} pullRequest{id headRefOid} headCommit{oid}}}}"; + mergeQueue{id repository{id}} pullRequest{id number headRefOid} headCommit{oid} + enqueuer{__typename ... on User{id} ... on Bot{id}}}}}"; /// Identity supplied by the board Reader and matched to the owner journal. #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] @@ -21,6 +23,7 @@ pub struct RejectedLanding { pub repository_id: String, pub queue_id: String, pub pull_request_id: String, + pub pull_request_number: u64, pub pr_head: String, pub rejected_group: String, pub removal_id: String, @@ -41,6 +44,7 @@ impl RejectedLanding { || !is_object_id(&self.rejected_group) || self.rejected_group == self.pr_head || self.removed_at == 0 + || self.pull_request_number == 0 { return Err("invalid rejected landing identity".into()); } @@ -268,6 +272,9 @@ fn timestamp(value: &Value) -> Option { fn delivery(intent: &NoticeIntent, node: &Value) -> Result { if node["repository"]["id"].as_str() != Some(&intent.rejection.repository_id) || node["pullRequest"]["id"].as_str() != Some(&intent.rejection.pull_request_id) + || node["pullRequest"]["headRefOid"].as_str() != Some(&intent.rejection.pr_head) + || node["pullRequest"]["author"]["id"].as_str() != Some(&intent.recipient_id) + || node["pullRequest"]["author"]["login"].as_str() != Some(&intent.recipient_login) || !matches!(node["author"]["__typename"].as_str(), Some("User" | "Bot")) || node["author"]["id"].as_str() != Some(&intent.publisher_id) { @@ -290,6 +297,9 @@ fn admission(intent: &RetryIntent, entry: &Value) -> Result { || entry["mergeQueue"]["id"].as_str() != Some(&rejection.queue_id) || entry["pullRequest"]["id"].as_str() != Some(&rejection.pull_request_id) || entry["pullRequest"]["headRefOid"].as_str() != Some(&rejection.pr_head) + || entry["pullRequest"]["number"].as_u64() != Some(rejection.pull_request_number) + || !matches!(entry["enqueuer"]["__typename"].as_str(), Some("User" | "Bot")) + || entry["enqueuer"]["id"].as_str() != Some(&intent.delivery.intent.publisher_id) { return Err("admission acknowledgment does not match the landing reservation".into()); } @@ -322,13 +332,13 @@ mod tests { use super::*; use serde_json::json; - #[test] - fn typed_landing_receipts_refuse_partial_and_mismatched_evidence() { - let intent = NoticeIntent { + fn test_intent() -> NoticeIntent { + NoticeIntent { rejection: RejectedLanding { repository_id: "R_repo".into(), queue_id: "MQ_main".into(), pull_request_id: "PR_pull".into(), + pull_request_number: 42, pr_head: "a".repeat(40), rejected_group: "b".repeat(40), removal_id: "E_removed".into(), @@ -337,21 +347,72 @@ mod tests { recipient_id: "U_author".into(), recipient_login: "synthetic-author".into(), publisher_id: "U_publisher".into(), + } + } + + #[test] + fn notice_uses_the_canonical_transport_on_a_mock_executable() { + use std::{fs, os::unix::fs::PermissionsExt}; + let temp = crate::test_dir::PrivateDir::new("landing-transport"); + let git = temp.path().join("git"); + let gh = temp.path().join("gh"); + fs::write( + &git, + "#!/bin/sh\nprintf '%s\\n' https://example.invalid/sample/repo\n", + ) + .unwrap(); + fs::write(&gh, r#"#!/bin/sh +test -z "${GH_TOKEN+x}" || exit 1 +case "$*" in + 'repo view https://example.invalid/sample/repo --json id,nameWithOwner,url') + printf '%s\n' '{"id":"R_repo","nameWithOwner":"sample/repo","url":"https://example.invalid/sample/repo"}' ;; + 'api graphql --hostname example.invalid -f query=query{viewer{id}}') + printf '%s\n' '{"data":{"viewer":{"id":"U_publisher"}}}' ;; + 'api graphql --hostname example.invalid -f query=mutation('*' pr=PR_pull -f body=@synthetic-author '*) + printf '%s\n' '{"data":{"addComment":{"commentEdge":{"node":{"id":"IC_comment", + "repository":{"id":"R_repo"},"pullRequest":{"id":"PR_pull","author":{"id":"U_author","login":"synthetic-author"}, + "headRefOid":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, + "author":{"__typename":"User","id":"U_publisher"},"createdAt":"1970-01-01T01:00:00Z"}}}}}' + ;; + *) exit 1 ;; +esac +"#).unwrap(); + for binary in [&git, &gh] { + fs::set_permissions(binary, fs::Permissions::from_mode(0o700)).unwrap(); + } + let policy = RunPolicy { + git_binary: git, + host_path: Default::default(), + terminate_binary: None, + offline: false, + runner_owns_github: false, + storage: temp.path().to_owned(), }; + let log = crate::shadow::open_log(&temp.path().join("owner.jsonl")).unwrap(); + let publisher = LandingPublisher::new(temp.path(), &policy, &gh, &log); + let receipt = publisher.notice(&test_intent(), &["synthetic::test"]).unwrap(); + assert_eq!(receipt.comment_id, "IC_comment"); + } + + #[test] + fn typed_landing_receipts_refuse_partial_and_mismatched_evidence() { + let intent = test_intent(); let body = intent.body(&["suite::test`@unrelated"]).unwrap(); assert!(body.starts_with("@synthetic-author ")); assert!(body.ends_with("`suite::test’@unrelated`")); - assert!(intent - .body(&["bad -name"]) - .is_err()); + assert!(intent.body(&["bad\nname"]).is_err()); let mut node = json!({ - "id":"IC_comment","repository":{"id":"R_repo"},"pullRequest":{"id":"PR_pull"}, + "id":"IC_comment","repository":{"id":"R_repo"}, + "pullRequest":{"id":"PR_pull","headRefOid":intent.rejection.pr_head, + "author":{"id":"U_author","login":"synthetic-author"}}, "author":{"__typename":"User","id":"U_publisher"},"createdAt":"1970-01-01T00:59:59Z" }); assert!(delivery(&intent, &node).is_err()); node["createdAt"] = json!("1970-01-01T01:00:00Z"); let delivered = delivery(&intent, &node).unwrap(); + node["pullRequest"]["author"]["id"] = json!("U_wrong_recipient"); + assert!(delivery(&intent, &node).is_err()); + node["pullRequest"]["author"]["id"] = json!("U_author"); node["author"]["id"] = json!("U_unrelated"); assert!(delivery(&intent, &node).is_err()); assert!(data(json!({"data":{"addComment": node},"errors":[{}]})).is_err()); @@ -369,7 +430,8 @@ name"]) let mut entry = json!({ "id":"MQE_entry","enqueuedAt":"1970-01-01T01:00:00Z", "mergeQueue":{"id":"MQ_main","repository":{"id":"R_repo"}}, - "pullRequest":{"id":"PR_pull","headRefOid":intent.rejection.pr_head}, + "pullRequest":{"id":"PR_pull","number":42,"headRefOid":intent.rejection.pr_head}, + "enqueuer":{"__typename":"User","id":"U_publisher"}, "headCommit":null }); let Admission::Pending(pending) = admission(&retry, &entry).unwrap() else { diff --git a/oxa/oxa-work/src/shadow.rs b/oxa/oxa-work/src/shadow.rs index 267a0cb69..103cad546 100644 --- a/oxa/oxa-work/src/shadow.rs +++ b/oxa/oxa-work/src/shadow.rs @@ -328,6 +328,8 @@ pub fn run_with_queue_evidence( pub struct LandingDecision { pub next: Next, pub queue_alarm: bool, + #[serde(skip_serializing_if = "std::ops::Not::not")] + pub repeat_rejection_alarm: bool, #[serde(skip_serializing_if = "Option::is_none")] pub queue: Option, #[serde(skip)] @@ -399,6 +401,7 @@ pub fn run_with_landing( landing_main.as_deref().unwrap_or_default(), &queue_rejections, &matched_queue_admissions, + history.as_ref().map(|history| &history.publications), ); let sample = Sample { schema_version: 1, @@ -435,6 +438,7 @@ fn plan_matched_rejections( main: &str, rejections: &[RejectionEvidence], admissions: &BTreeMap, + published: Option<&publication::Publications>, ) { let rejections: BTreeMap<_, _> = rejections .iter() @@ -452,6 +456,31 @@ fn plan_matched_rejections( else { continue; }; + let binding = rejection.publication_binding().map(|(binding, _)| binding); + let (delivery, retry) = match (published, binding.as_ref()) { + (Some(published), Some(binding)) => { + let delivered = published.delivered(binding).filter(|receipt| { + rejection.notification_target().is_some_and(|target| { + target.author_id == receipt.intent.recipient_id + && target.login == receipt.intent.recipient_login + }) + }); + let retry = published + .admitted(binding) + .map_or(landing::Retry::Unknown, |receipt| landing::Retry::Consumed { + first_rejected_group: &receipt + .acknowledgment + .intent + .delivery + .intent + .rejection + .rejected_group, + admitted_group: Some(&receipt.admitted_group), + }); + (delivered, retry) + } + _ => (None, landing::Retry::Unknown), + }; let failed_tests = rejection.reported_failure_names(); let plan = landing::Policy { enabled: true }.plan( entry, @@ -466,13 +495,14 @@ fn plan_matched_rejections( } else { landing::RejectionCause::FailedTests(&failed_tests) }, - notified_event: None, - retry: landing::Retry::Unknown, + notified_event: delivery.map(|receipt| receipt.intent.rejection.removal_id.as_str()), + retry, }), main, board.observed_at, ); decision.next = plan.next; + decision.repeat_rejection_alarm = plan.repeat_rejection_alarm; if let ( Some(landing::Notice { head, diff --git a/oxa/oxa-work/src/shadow/landing_history.rs b/oxa/oxa-work/src/shadow/landing_history.rs index 39cf46edb..056acf93f 100644 --- a/oxa/oxa-work/src/shadow/landing_history.rs +++ b/oxa/oxa-work/src/shadow/landing_history.rs @@ -65,6 +65,10 @@ struct RejectionBaseline { } impl AdmissionEvidence { + pub(super) fn last_admission_at(&self) -> u64 { + self.enqueued_at + } + pub(super) fn baseline_main(&self) -> &str { self.rejection_baseline.as_ref().map_or("", |value| &value.main) } diff --git a/oxa/oxa-work/src/shadow/publication.rs b/oxa/oxa-work/src/shadow/publication.rs index bf1fdb4a1..43c74f786 100644 --- a/oxa/oxa-work/src/shadow/publication.rs +++ b/oxa/oxa-work/src/shadow/publication.rs @@ -1,5 +1,6 @@ //! Opt-in landing dispatch through the canonical publisher under the owner journal lock. -use super::{append, open_log, Admissions, Board, File, Sample}; +use super::{append, open_log, Admissions, Board, File, LandingSample, Sample}; +use crate::board::{landing, queue::RejectionEvidence, Action}; use crate::{ Admission, AdmissionAcknowledgment, AdmissionReceipt, DeliveryReceipt, LandingPublisher, NoticeIntent, RejectedLanding, Result, RetryIntent, RunPolicy, @@ -11,24 +12,25 @@ use std::{collections::BTreeMap, path::Path}; #[derive(Default)] pub struct Policy { pub enabled: bool, + pub publisher_id: String, } -pub enum Approved { +enum Approved { Notice { intent: NoticeIntent, failed_tests: Vec, }, Retry { intent: RetryIntent, - /// Count established by the existing Reader and owner journal. + /// A conservative admission count from the existing Reader. prior_admissions: u8, }, Reconcile(AdmissionAcknowledgment), } -pub struct Authorization { - pub number: u64, - pub operation: Approved, +struct Authorization { + number: u64, + operation: Approved, } #[derive(Clone, Deserialize, Serialize)] @@ -167,24 +169,34 @@ fn record(log: &mut File, board: &Board, publication: &Publication) -> Result<() ) } -/// The existing Reader supplies the fresh board and authorization after the -/// journal lock is acquired. Reconciliation reads the precise acknowledged -/// entry with that Reader. With the default policy neither callback is used. +/// Apply one fresh Reader snapshot under the existing owner-journal lock. pub fn run_once( policy: &Policy, journal_path: &Path, repo: &Path, run: &RunPolicy, gh_binary: &Path, - read: impl FnOnce(&Publications) -> Result<(Board, Option)>, + read: impl FnOnce() -> Result, read_acknowledged: impl FnOnce(&AdmissionAcknowledgment) -> Result, ) -> Result<()> { if !policy.enabled || run.offline { return Ok(()); } let mut log = open_log(journal_path)?; - let history = Admissions::load(&mut log)?; - let (board, action) = read(&history.publications)?; + if !crate::board::queue::is_node_id(&policy.publisher_id) { + return Err("landing policy requires the intended publisher identity".into()); + } + let mut history = Admissions::load(&mut log)?; + let sample = read()?; + let action = authorize(policy, &mut history, &sample); + let board = sample.board.clone(); + let mut sample = Some(sample); + super::run_with_landing( + &mut log, + true, + || sample.take().ok_or_else(|| "snapshot already written".into()), + |_| {}, + )?; advance(&mut log, &history.publications, &board, action, |file, action| { let publisher = LandingPublisher::new(repo, run, gh_binary, file); match action { @@ -204,6 +216,128 @@ pub fn run_once( }) } +fn authorize(policy: &Policy, history: &mut Admissions, sample: &LandingSample) -> Option { + let main = sample.landing_main.as_deref().unwrap_or_default(); + let matched = history.matches( + &sample.board, + sample.landing_main.as_deref(), + sample + .queue_rejections + .iter() + .map(RejectionEvidence::admission_identity), + ); + sample + .queue_rejections + .iter() + .find_map(|rejection| { + let number = rejection.admission_identity().number; + let decision = sample.landing.get(&number)?; + if decision.queue.is_some() { + return None; + } + let admission = matched.get(&number)?; + let entry = sample.board.entries.iter().find(|entry| entry.number == number)?; + let target = rejection.notification_target()?; + let (binding, prior_admissions) = rejection.publication_binding()?; + let intent = NoticeIntent { + rejection: binding, + recipient_id: target.author_id.clone(), + recipient_login: target.login.clone(), + publisher_id: policy.publisher_id.clone(), + }; + let tests = rejection.reported_failure_names(); + let known = history + .publications + .delivered(&intent.rejection) + .filter(|receipt| receipt.intent == intent); + let consumed = history.publications.attempted_retry(&intent.rejection); + let prior_admissions = prior_admissions.filter(|n| (1..3).contains(n)); + let retry = if !consumed && prior_admissions.is_some() { + landing::Retry::Unused { + last_admission_at: admission.last_admission_at(), + } + } else { + landing::Retry::Unknown + }; + let plan = landing::Policy { enabled: true }.plan( + entry, + decision.latest_reviews, + landing::Queue::Rejected(landing::Rejection { + head: &intent.rejection.pr_head, + main: admission.baseline_main(), + merge_group_head: &intent.rejection.rejected_group, + removal_event: &intent.rejection.removal_id, + cause: if tests.is_empty() { + landing::RejectionCause::Unknown + } else { + landing::RejectionCause::FailedTests(&tests) + }, + notified_event: known.map(|receipt| receipt.intent.rejection.removal_id.as_str()), + retry, + }), + main, + sample.board.observed_at, + ); + if let (landing::Next::Retry, Some(delivery), Some(prior_admissions)) = + (plan.next, known, prior_admissions) + { + return Some(Authorization { + number, + operation: Approved::Retry { + intent: RetryIntent { + delivery: delivery.clone(), + observed_main: main.to_owned(), + observed_at: sample.board.observed_at, + last_admission_at: admission.last_admission_at(), + }, + prior_admissions, + }, + }); + } + if plan.notify_rejection.is_some() + && !tests.is_empty() + && history.publications.prior(&intent.rejection, false).is_none() + { + return Some(Authorization { + number, + operation: Approved::Notice { + intent, + failed_tests: tests.into_iter().map(str::to_owned).collect(), + }, + }); + } + None + }) + .or_else(|| reconcile(&history.publications, sample)) +} + +fn reconcile(history: &Publications, sample: &LandingSample) -> Option { + history.latest.values().find_map(|record| { + let Publication::Acknowledged(ack) = record else { + return None; + }; + let rejection = &ack.intent.delivery.intent.rejection; + let number = sample + .board + .entries + .iter() + .find(|entry| { + entry.number == rejection.pull_request_number + && entry.head == rejection.pr_head + && sample + .landing + .get(&entry.number) + .and_then(|decision| decision.queue.as_ref()) + .is_some_and(|queue| queue.enqueued_at == ack.enqueued_at) + })? + .number; + Some(Authorization { + number, + operation: Approved::Reconcile(ack.clone()), + }) + }) +} + fn advance( log: &mut File, history: &Publications, @@ -223,11 +357,11 @@ fn advance( Approved::Retry { intent, .. } => (&intent.delivery.intent.rejection, true), Approved::Reconcile(ack) => (&ack.intent.delivery.intent.rejection, true), }; - let Some(entry) = board - .entries - .iter() - .find(|entry| entry.number == number && entry.head == rejection.pr_head) - else { + let Some(entry) = board.entries.iter().find(|entry| { + entry.number == number + && entry.number == rejection.pull_request_number + && entry.head == rejection.pr_head + }) else { return Ok(()); }; let previous = history.prior(rejection, retry); @@ -238,7 +372,7 @@ fn advance( prior_admissions, } if previous.is_none() && (1..3).contains(prior_admissions) - && entry.action == crate::board::Action::Ready + && entry.action == Action::Ready && entry.eligible && board.observed_at == intent.observed_at && matches!( @@ -270,7 +404,32 @@ fn advance( #[cfg(test)] mod tests { use super::*; - use crate::board::{Action, Entry}; + use crate::board::Entry; + + #[test] + fn default_off_does_not_open_the_journal_or_call_the_reader() { + let temp = crate::test_dir::PrivateDir::new("landing-off"); + let path = temp.path().join("owner.jsonl"); + let run = RunPolicy { + git_binary: temp.path().join("git"), + host_path: Default::default(), + terminate_binary: None, + offline: false, + runner_owns_github: false, + storage: temp.path().to_owned(), + }; + run_once( + &Policy::default(), + &path, + temp.path(), + &run, + &temp.path().join("gh"), + || panic!("default off cannot read a board"), + |_| panic!("default off cannot reconcile"), + ) + .unwrap(); + assert!(!path.exists()); + } #[test] fn ambiguous_delivery_reservation_survives_reopening_and_refuses_redispatch() { @@ -281,6 +440,7 @@ mod tests { repository_id: "R_repo".into(), queue_id: "MQ_main".into(), pull_request_id: "PR_pull".into(), + pull_request_number: 42, pr_head: "a".repeat(40), rejected_group: "b".repeat(40), removal_id: "E_removed".into(), diff --git a/oxa/oxa-work/tests/board_queue.rs b/oxa/oxa-work/tests/board_queue.rs index 97b54286f..5677f3ee6 100644 --- a/oxa/oxa-work/tests/board_queue.rs +++ b/oxa/oxa-work/tests/board_queue.rs @@ -190,6 +190,7 @@ fn the_owner_journal_matches_only_the_previously_queued_head_and_group() { LandingDecision { next: Next::AlreadyQueued, queue_alarm: false, + repeat_rejection_alarm: false, latest_reviews: LatestReviews::Clear, would_notify_rejection: None, queue: Some(QueueObservation { @@ -280,6 +281,7 @@ fn the_owner_journal_matches_only_the_previously_queued_head_and_group() { Next::WaitQueue }, queue_alarm: false, + repeat_rejection_alarm: false, queue: queued, latest_reviews: reviews, would_notify_rejection: None,