use std::sync::Arc;
use super::admission::MarkView;
use super::*;
use crate::spawn_authority::{MarkStatus, SpawnAuthorityRecord};
pub(crate) trait MarkPublisher: Send + Sync {
fn activate(&self, record: &Arc<SpawnAuthorityRecord>) -> bool;
fn lower(&self, record: &Arc<SpawnAuthorityRecord>);
}
struct RecordOnly;
impl MarkPublisher for RecordOnly {
fn activate(&self, record: &Arc<SpawnAuthorityRecord>) -> bool {
record.activate(|| Ok::<_, ()>(())).unwrap_or(false)
}
fn lower(&self, record: &Arc<SpawnAuthorityRecord>) {
record.lower(|_| ());
}
}
impl RuntimeOwner {
pub(crate) fn install_mark_publisher(&self, publisher: Arc<dyn MarkPublisher>) {
let _ = self.mark_publisher.set(publisher);
}
fn mark_publisher(&self) -> &dyn MarkPublisher {
self.mark_publisher
.get()
.map_or(&RecordOnly as &dyn MarkPublisher, |publisher| {
publisher.as_ref()
})
}
pub(crate) fn mark_ready(&self, spawn: &DeliverySpawn) -> Result<()> {
let Some(record) = spawn.authority() else {
return Ok(());
};
let mut state = self.lock()?;
state.delivery.track_mark(spawn);
record.note_ready();
evaluate(self, &state, spawn);
Ok(())
}
pub(crate) fn mark_not_ready(&self, spawn: &DeliverySpawn) -> Result<()> {
if spawn.authority().is_none() {
return Ok(());
}
let mut state = self.lock()?;
state.delivery.track_mark(spawn);
evaluate(self, &state, spawn);
Ok(())
}
}
pub(super) fn acknowledged(
owner: &RuntimeOwner,
state: &OwnerState,
spawn: Option<&DeliverySpawn>,
generation: u64,
) {
let Some(spawn) = spawn else {
return;
};
if let Some(record) = spawn.authority() {
record.note_active_acknowledgement(generation);
evaluate(owner, state, spawn);
}
}
pub(super) fn acknowledgement_refused(
_owner: &RuntimeOwner,
_state: &OwnerState,
spawn: Option<&DeliverySpawn>,
) {
let Some(record) = spawn.and_then(DeliverySpawn::authority) else {
return;
};
if record.mark_facts().unmarked {
record.set_unmarked_status(MarkStatus::AcknowledgementRefused);
tracing::warn!(
module_id = record.module_id(),
spawn = record.spawn_number(),
"spawn is not marked first-party: it did not acknowledge its module's active configuration"
);
}
}
pub(super) fn delivery_failed(owner: &RuntimeOwner, spawn: Option<&DeliverySpawn>) {
if let Some(record) = spawn.and_then(DeliverySpawn::authority) {
let facts = record.mark_facts();
if facts.marked || facts.unmarked {
owner.mark_publisher().lower(record);
}
}
}
fn evaluate(owner: &RuntimeOwner, state: &OwnerState, spawn: &DeliverySpawn) {
let Some(record) = spawn.authority() else {
return;
};
let facts = record.mark_facts();
if !facts.unmarked {
return;
}
let (view, program) = owner
.published
.read()
.map(|published| {
(
published.admission.mark_view(spawn.module()),
published.admission.admitted_program(spawn.module()),
)
})
.unwrap_or((MarkView::Undecided, None));
if superseded(spawn.admitted_program(), program.as_ref()) {
owner.mark_publisher().lower(record);
return;
}
let status = blocker(state, spawn, record, view);
match status {
None => {
if owner.mark_publisher().activate(record) {
tracing::info!(
module_id = record.module_id(),
spawn = record.spawn_number(),
"spawn marked first-party"
);
}
}
Some(status) => {
if record.set_unmarked_status(status) {
tracing::warn!(
module_id = record.module_id(),
spawn = record.spawn_number(),
"spawn is not marked first-party: it has not reported ready. A module must \
reach ready without first-party grants and use them once they work"
);
}
}
}
}
fn blocker(
state: &OwnerState,
spawn: &DeliverySpawn,
record: &SpawnAuthorityRecord,
view: MarkView,
) -> Option<MarkStatus> {
let facts = record.mark_facts();
let (store, body) = state.store.loaded_admission_state();
if !spawn.stamped() || store != StoreState::Stamped || !facts.origin_qualifies {
return Some(MarkStatus::NotEligible);
}
let MarkView::Gated {
generation,
delivers_config,
} = view
else {
return Some(MarkStatus::NotEligible);
};
if delivers_config {
let active = active_generation(body, spawn.module());
if active.is_none() || facts.acknowledged_active != active {
return Some(match record.mark_status() {
MarkStatus::AcknowledgementRefused => MarkStatus::AcknowledgementRefused,
_ => MarkStatus::AwaitingAcknowledgement,
});
}
} else if spawn.generation() != generation {
return Some(MarkStatus::NotEligible);
}
if !facts.ready {
return Some(MarkStatus::AwaitingReadiness);
}
None
}
fn superseded(
admitted: Option<&super::admission::AdmittedProgram>,
now: Option<&super::admission::AdmittedProgram>,
) -> bool {
admitted
.zip(now)
.is_some_and(|(admitted, now)| admitted != now)
}
fn active_generation(body: &crate::config_store::StoreBody, module: &str) -> Option<u64> {
body.versions
.iter()
.find(|(tuple, _)| tuple.module == module && tuple.project.is_none())
.and_then(|(_, versions)| versions.active)
}
pub(super) fn sweep(
owner: &RuntimeOwner,
state: &mut OwnerState,
view: &super::admission::AdmissionCache,
) {
let records = state.delivery.mark_records();
let (store, body) = state.store.loaded_admission_state();
for (record, admitted) in &records {
let facts = record.mark_facts();
if !facts.marked && !facts.unmarked {
continue;
}
let module = record.module_id();
let mark_view = if store == StoreState::Unstamped {
MarkView::NotGated
} else {
view.mark_view(module)
};
let lower = match mark_view {
MarkView::Undecided => false,
MarkView::NotGated => true,
MarkView::Gated {
delivers_config, ..
} => {
superseded(admitted.as_ref(), view.admitted_program(module).as_ref())
|| (facts.marked
&& delivers_config
&& facts.acknowledged_active != active_generation(body, module))
}
};
if lower {
owner.mark_publisher().lower(record);
}
}
}