use std::collections::BTreeMap;
use std::collections::HashMap;
use std::panic::AssertUnwindSafe;
use std::panic::catch_unwind;
use std::sync::Arc;
use std::sync::Mutex;
use crate::domain::index::CatalogPath;
use crate::domain::index::MetadataOnlyReason;
use super::capacity::CapacityPermit;
use super::capacity::CapacityRefusal;
use super::capacity::OwnerIdentity;
use super::capacity::ProcessCapacityPool;
use super::supervisor::AttemptId;
use super::supervisor::ClassifiedFailure;
use super::supervisor::LoadAttempt;
use super::supervisor::SupervisorState;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SourceId(pub u64);
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SourceContentToken(pub u64);
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum ArtifactKind {
Catalog,
Symbols,
References,
Outline,
}
impl ArtifactKind {
pub const REQUIRED: [ArtifactKind; 4] = [
ArtifactKind::Catalog,
ArtifactKind::Symbols,
ArtifactKind::References,
ArtifactKind::Outline,
];
}
#[derive(Clone, Copy, Debug)]
pub struct CapabilityCertificate {
_private: (),
}
impl CapabilityCertificate {
pub fn for_test() -> Self {
Self { _private: () }
}
}
#[derive(Clone, Debug)]
pub enum SourceObservation {
Content {
path: CatalogPath,
token: SourceContentToken,
bytes: u64,
},
MetadataOnly {
path: CatalogPath,
reason: MetadataOnlyReason,
},
Failed(ClassifiedFailure),
}
#[derive(Clone, Debug)]
pub struct CandidateSource {
pub id: SourceId,
pub observation: SourceObservation,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum EntryDisposition {
Indexed { content_stamp: u64 },
MetadataOnly { reason: MetadataOnlyReason },
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ManifestEntry {
pub path: CatalogPath,
pub disposition: EntryDisposition,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct CandidateManifest {
pub entries: Vec<ManifestEntry>,
}
#[derive(Debug)]
pub struct SourceArtifacts {
pub token: SourceContentToken,
pub manifest: CandidateManifest,
pub artifacts: BTreeMap<ArtifactKind, u64>,
}
#[derive(Debug, Default)]
pub struct ProjectArtifacts {
pub sources: HashMap<SourceId, Arc<SourceArtifacts>>,
}
#[derive(Debug, Default)]
pub struct ProjectArtifactRoot {
pub(crate) inner: Mutex<Arc<ProjectArtifacts>>,
}
impl ProjectArtifactRoot {
pub fn empty() -> Self {
Self::default()
}
pub fn load(&self) -> Arc<ProjectArtifacts> {
Arc::clone(&self.inner.lock().expect("artifact root lock"))
}
pub fn publish_claiming_epoch_only(&self, epoch: u64) -> PromotionRefusal {
let _ = epoch;
PromotionRefusal::EpochIsNotAuthority
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PromotionRefusal {
Failure(ClassifiedFailure),
CapabilityCannotAuthorize,
Superseded,
AttemptAlreadyTerminal,
SameSourceDrift {
expected: Option<SourceContentToken>,
found: Option<SourceContentToken>,
},
EpochIsNotAuthority,
Panicked,
}
#[derive(Debug)]
struct DeltaSpec {
changed: SourceId,
expected: Option<SourceContentToken>,
}
#[derive(Debug)]
enum BuildOutcome {
Ready {
built: HashMap<SourceId, Arc<SourceArtifacts>>,
delta: Option<DeltaSpec>,
},
Classified(ClassifiedFailure),
Panicked,
}
#[derive(Debug)]
pub struct IsolatedCandidate {
outcome: BuildOutcome,
attempt: AttemptId,
supervisor: Arc<Mutex<SupervisorState>>,
_permit: CapacityPermit,
}
fn reserved_bytes(sources: &[CandidateSource]) -> u64 {
sources
.iter()
.map(|source| match &source.observation {
SourceObservation::Content { bytes, .. } => *bytes,
_ => 0,
})
.sum::<u64>()
.max(1)
}
fn build_sources(
sources: &[CandidateSource],
derive: &mut dyn FnMut(&CandidateSource) -> u64,
) -> BuildOutcome {
let mut built = HashMap::new();
for source in sources {
match &source.observation {
SourceObservation::Failed(cause) => return BuildOutcome::Classified(*cause),
SourceObservation::Content { path, token, .. } => {
let stamp = match catch_unwind(AssertUnwindSafe(|| derive(source))) {
Ok(stamp) => stamp,
Err(_) => return BuildOutcome::Panicked,
};
let mut artifacts = BTreeMap::new();
for (offset, kind) in ArtifactKind::REQUIRED.into_iter().enumerate() {
artifacts.insert(kind, stamp.wrapping_add(offset as u64));
}
built.insert(
source.id,
Arc::new(SourceArtifacts {
token: *token,
manifest: CandidateManifest {
entries: vec![ManifestEntry {
path: path.clone(),
disposition: EntryDisposition::Indexed {
content_stamp: stamp,
},
}],
},
artifacts,
}),
);
}
SourceObservation::MetadataOnly { path, reason } => {
built.insert(
source.id,
Arc::new(SourceArtifacts {
token: SourceContentToken(0),
manifest: CandidateManifest {
entries: vec![ManifestEntry {
path: path.clone(),
disposition: EntryDisposition::MetadataOnly {
reason: reason.clone(),
},
}],
},
artifacts: BTreeMap::new(),
}),
);
}
}
}
BuildOutcome::Ready { built, delta: None }
}
impl IsolatedCandidate {
pub fn prepare_full(
pool: &Arc<ProcessCapacityPool>,
owner: OwnerIdentity,
attempt: &LoadAttempt,
sources: Vec<CandidateSource>,
mut derive: impl FnMut(&CandidateSource) -> u64,
) -> Result<Self, CapacityRefusal> {
let permit = pool.redeem(pool.reserve(owner, reserved_bytes(&sources))?)?;
let outcome = build_sources(&sources, &mut derive);
Ok(Self {
outcome,
attempt: attempt.id,
supervisor: Arc::clone(&attempt.state),
_permit: permit,
})
}
pub fn prepare_delta(
pool: &Arc<ProcessCapacityPool>,
owner: OwnerIdentity,
attempt: &LoadAttempt,
changed: CandidateSource,
expected: Option<SourceContentToken>,
mut derive: impl FnMut(&CandidateSource) -> u64,
) -> Result<Self, CapacityRefusal> {
let changed_id = changed.id;
let sources = vec![changed];
let permit = pool.redeem(pool.reserve(owner, reserved_bytes(&sources))?)?;
let outcome = match build_sources(&sources, &mut derive) {
BuildOutcome::Ready { built, .. } => BuildOutcome::Ready {
built,
delta: Some(DeltaSpec {
changed: changed_id,
expected,
}),
},
terminal => terminal,
};
Ok(Self {
outcome,
attempt: attempt.id,
supervisor: Arc::clone(&attempt.state),
_permit: permit,
})
}
pub fn classified_failure(&self) -> Option<ClassifiedFailure> {
match &self.outcome {
BuildOutcome::Classified(cause) => Some(*cause),
_ => None,
}
}
pub fn commit(
self,
root: &ProjectArtifactRoot,
) -> Result<Arc<ProjectArtifacts>, PromotionRefusal> {
let mut supervisor = self.supervisor.lock().expect("supervisor lock");
if supervisor.is_superseded(self.attempt) {
return Err(PromotionRefusal::Superseded);
}
if supervisor.is_terminal(self.attempt) {
return Err(PromotionRefusal::AttemptAlreadyTerminal);
}
match self.outcome {
BuildOutcome::Classified(cause) => {
supervisor.record_discard(self.attempt, cause);
Err(PromotionRefusal::Failure(cause))
}
BuildOutcome::Panicked => {
supervisor.record_panic(self.attempt);
Err(PromotionRefusal::Panicked)
}
BuildOutcome::Ready { built, delta } => {
let mut inner = root.inner.lock().expect("artifact root lock");
let next = match delta {
None => Arc::new(ProjectArtifacts { sources: built }),
Some(spec) => {
let found = inner.sources.get(&spec.changed).map(|arts| arts.token);
if found != spec.expected {
return Err(PromotionRefusal::SameSourceDrift {
expected: spec.expected,
found,
});
}
let changed = built
.get(&spec.changed)
.expect("a delta candidate builds its changed source");
let mut sources = inner.sources.clone();
sources.insert(spec.changed, Arc::clone(changed));
Arc::new(ProjectArtifacts { sources })
}
};
*inner = Arc::clone(&next);
drop(inner);
supervisor.record_commit(self.attempt);
Ok(next)
}
}
}
pub fn promote_partial_with_capability(
self,
root: &ProjectArtifactRoot,
certificate: CapabilityCertificate,
) -> PromotionRefusal {
let _ = (root, certificate);
PromotionRefusal::CapabilityCannotAuthorize
}
}