pub mod execute;
pub mod observe;
pub mod plan;
use std::collections::{BTreeMap, BTreeSet};
use std::fmt;
use crate::name::GroupId;
use crate::runtime::Runtime;
use crate::state::State;
use self::execute::{Execution, Executor, StateSink};
use self::observe::{Note, Observed};
use self::plan::{ConflictKind, Finding, Plan, PlanInput};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Trigger {
Startup,
Inotify,
Resync,
Reload,
Cli,
}
impl fmt::Display for Trigger {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::Startup => "startup",
Self::Inotify => "inotify",
Self::Resync => "resync",
Self::Reload => "reload",
Self::Cli => "cli",
})
}
}
#[derive(Debug)]
pub struct Pass {
pub observed: Observed,
pub plan: Plan,
pub execution: Execution,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Degraded {
pub groups: BTreeSet<GroupId>,
pub sets: BTreeSet<crate::name::Name>,
}
impl Degraded {
#[must_use]
pub fn is_empty(&self) -> bool {
self.groups.is_empty() && self.sets.is_empty()
}
}
pub fn discover_and_observe(
runtime: &mut Runtime,
state: &State,
degraded: &Degraded,
unique_supported: bool,
after_discovery: &mut dyn FnMut(&Runtime),
) -> Observed {
let discovery = runtime.discover(°raded.sets);
after_discovery(runtime);
let mut frozen_sets = degraded.sets.clone();
frozen_sets.extend(discovery.unavailable_sets.iter().cloned());
let mut frozen = degraded.groups.clone();
frozen.extend(discovery.unavailable.iter().cloned());
frozen.extend(
state
.records()
.filter(|r| {
r.group.set().is_some_and(|set| frozen_sets.contains(set))
|| discovery
.unavailable
.iter()
.any(|prefix| r.group.starts_with(prefix))
})
.map(|r| r.group.clone()),
);
let mut observed = observe::observe(runtime, state, &frozen, unique_supported);
let mut notes = discovery.notes;
notes.append(&mut observed.notes);
observed.notes = notes;
observed.scanned_sets = discovery.scanned_sets;
observed
}
#[derive(Debug, Clone, Copy)]
pub struct PassOptions<'a> {
pub degraded: &'a Degraded,
pub unique_supported: bool,
pub trigger: Trigger,
}
pub fn run_pass<S: StateSink>(
runtime: &mut Runtime,
state: &mut State,
sink: &S,
options: PassOptions<'_>,
notes: &mut NoteLog,
after_discovery: &mut dyn FnMut(&Runtime),
) -> Pass {
let PassOptions {
degraded,
unique_supported,
trigger,
} = options;
let observed =
discover_and_observe(runtime, state, degraded, unique_supported, after_discovery);
notes.report(&observed, trigger);
let plan = plan::plan(PlanInput {
desired: &observed.desired,
state,
frozen_groups: &observed.frozen,
observations: &observed.observations,
});
log_findings(&plan.findings, trigger);
let execution = Executor {
runtime,
state,
sink,
unique_supported,
trigger,
}
.execute(&plan);
Pass {
observed,
plan,
execution,
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NoteEvent<'a> {
Raised(&'a Note),
Cleared {
group: String,
subject: String,
},
}
#[derive(Debug, Default)]
pub struct NoteLog {
active: BTreeMap<(String, String), String>,
}
fn note_identity(note: &Note) -> ((String, String), String) {
match note {
Note::Rejected { group, rejection } => (
(group.to_string(), rejection.display_name.clone()),
rejection.reason.to_string(),
),
Note::InterpolationFailed {
group,
name,
field,
error,
} => (
(group.to_string(), name.to_string()),
format!("{field} template: {error}"),
),
Note::MembershipDeleted { group } => ((group.to_string(), String::new()), "deleted".into()),
Note::MembershipUnreadable { group, error } => {
((group.to_string(), String::new()), error.clone())
}
Note::SetEntryRejected { set, rejection } => (
(set_label(set), rejection.display_name.clone()),
rejection.reason.to_string(),
),
Note::SetRootDeleted { set } => ((set_label(set), String::new()), "deleted".into()),
Note::SetRootUnreadable { set, error } => ((set_label(set), String::new()), error.clone()),
}
}
#[must_use]
pub fn set_label(set: &crate::name::Name) -> String {
format!("{set}/*")
}
impl NoteLog {
pub fn update<'a>(&mut self, observed: &'a Observed) -> Vec<NoteEvent<'a>> {
let mut events = Vec::new();
let mut current = BTreeMap::new();
let mut examined: BTreeSet<String> =
observed.members.keys().map(ToString::to_string).collect();
examined.extend(observed.scanned_sets.iter().map(set_label));
for note in &observed.notes {
let (key, detail) = note_identity(note);
examined.insert(key.0.clone());
if self.active.get(&key) != Some(&detail) {
events.push(NoteEvent::Raised(note));
}
current.insert(key, detail);
}
for (key, detail) in std::mem::take(&mut self.active) {
if current.contains_key(&key) {
continue;
}
if examined.contains(&key.0) {
events.push(NoteEvent::Cleared {
group: key.0,
subject: key.1,
});
} else {
current.insert(key, detail);
}
}
self.active = current;
events
}
pub fn report(&mut self, observed: &Observed, trigger: Trigger) {
for event in self.update(observed) {
match event {
NoteEvent::Raised(note) => log_note(note, trigger),
NoteEvent::Cleared { group, subject } if subject.is_empty() => tracing::info!(
op = "scan",
group = %group,
trigger = %trigger,
result = "ok",
msg = "membership directory readable again",
),
NoteEvent::Cleared { group, subject } => tracing::info!(
op = "reject_cleared",
group = %group,
name = %subject,
trigger = %trigger,
msg = "membership entry is no longer rejected",
),
}
}
for (group, names) in &observed.ignored {
tracing::debug!(
op = "ignore",
group = %group,
trigger = %trigger,
count = names.len(),
names = %names.join(","),
msg = "hidden membership entries ignored",
);
}
}
}
fn log_note(note: &Note, trigger: Trigger) {
match note {
Note::SetEntryRejected { set, rejection } => tracing::warn!(
op = "reject",
group = %set_label(set),
name = %rejection.display_name,
trigger = %trigger,
reason = %rejection.reason,
),
Note::SetRootDeleted { set } => tracing::error!(
op = "degrade",
group = %set_label(set),
trigger = %trigger,
msg = "group set membership root has been deleted; keeping existing mounts and making no changes to this set until configuration is reloaded",
),
Note::SetRootUnreadable { set, error } => tracing::error!(
op = "scan",
group = %set_label(set),
trigger = %trigger,
result = "failed",
error = %error,
msg = "group set membership root unreadable; set left unchanged",
),
Note::Rejected { group, rejection } => tracing::warn!(
op = "reject",
group = %group,
name = %rejection.display_name,
trigger = %trigger,
reason = %rejection.reason,
),
Note::InterpolationFailed {
group,
name,
field,
error,
} => tracing::warn!(
op = "reject",
group = %group,
name = %name,
trigger = %trigger,
reason = %format!("{field} template: {error}"),
),
Note::MembershipDeleted { group } => tracing::error!(
op = "degrade",
group = %group,
trigger = %trigger,
msg = "membership directory has been deleted; keeping existing mounts and making no changes to this group until configuration is reloaded",
),
Note::MembershipUnreadable { group, error } => tracing::error!(
op = "scan",
group = %group,
trigger = %trigger,
result = "failed",
error = %error,
msg = "membership directory unreadable; group left unchanged",
),
}
}
pub fn log_findings(findings: &[Finding], trigger: Trigger) {
for finding in findings {
match finding {
Finding::Conflict { key, target, kind } => tracing::warn!(
op = "conflict",
group = %key.group,
name = %key.name,
target = %target,
trigger = %trigger,
reason = match kind {
ConflictKind::ForeignMount =>
"mount present at target but not recorded in state; not touching foreign mount",
ConflictKind::TargetReplaced =>
"mount at target is not the recorded mount; not touching it",
},
),
Finding::SourceUnavailable {
key,
source,
reason,
} => tracing::warn!(
op = "skip",
group = %key.group,
name = %key.name,
source = %source,
trigger = %trigger,
reason = %reason,
),
Finding::TargetUnavailable {
key,
target,
reason,
} => tracing::warn!(
op = "skip",
group = %key.group,
name = %key.name,
target = %target,
trigger = %trigger,
reason = %format!("target cannot be inspected: {reason}"),
),
Finding::TargetCollision {
target,
members,
kept,
} => tracing::warn!(
op = "conflict",
target = %target,
trigger = %trigger,
members = %members.iter().map(ToString::to_string).collect::<Vec<_>>().join(","),
kept = %kept.as_ref().map_or_else(|| "none".to_owned(), ToString::to_string),
reason = "several members resolve to the same target",
),
Finding::RelocationBlocked { key, old_target } => tracing::warn!(
op = "skip",
group = %key.group,
name = %key.name,
target = %old_target,
trigger = %trigger,
reason = "member moved but its existing mount cannot be verified; not relocating",
),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::membership::{EntryKind, RejectReason, Rejection};
fn name(s: &str) -> GroupId {
GroupId::parse(s).unwrap()
}
fn rejected(group: &str, entry: &str, reason: RejectReason) -> Note {
Note::Rejected {
group: name(group),
rejection: Rejection {
display_name: entry.into(),
reason,
},
}
}
fn observed(scanned: &[&str], notes: Vec<Note>) -> Observed {
Observed {
members: scanned.iter().map(|g| (name(g), BTreeSet::new())).collect(),
notes,
..Observed::default()
}
}
fn summarize(events: &[NoteEvent<'_>]) -> Vec<String> {
events
.iter()
.map(|e| match e {
NoteEvent::Raised(n) => format!("raised {}", note_identity(n).0.1),
NoteEvent::Cleared { subject, .. } => format!("cleared {subject}"),
})
.collect()
}
#[test]
fn persistent_notes_are_reported_once() {
let mut log = NoteLog::default();
let symlink = || {
rejected(
"g",
"link",
RejectReason::NotRegularFile(EntryKind::Symlink),
)
};
let first = observed(&["g"], vec![symlink()]);
assert_eq!(summarize(&log.update(&first)), ["raised link"]);
let again = observed(&["g"], vec![symlink()]);
assert!(log.update(&again).is_empty());
let changed = observed(
&["g"],
vec![rejected("g", "link", RejectReason::NotEmpty(3))],
);
assert_eq!(summarize(&log.update(&changed)), ["raised link"]);
let fixed = observed(&["g"], vec![]);
assert_eq!(summarize(&log.update(&fixed)), ["cleared link"]);
assert!(log.update(&observed(&["g"], vec![])).is_empty());
}
#[test]
fn unexamined_groups_keep_their_notes() {
let mut log = NoteLog::default();
let unreadable = || Note::MembershipUnreadable {
group: name("g"),
error: "EACCES".into(),
};
assert_eq!(log.update(&observed(&[], vec![unreadable()])).len(), 1);
assert!(log.update(&observed(&[], vec![unreadable()])).is_empty());
assert!(log.update(&observed(&[], vec![])).is_empty());
assert_eq!(
summarize(&log.update(&observed(&["g"], vec![]))),
["cleared "]
);
}
#[test]
fn set_entry_rejections_clear_when_the_set_is_rescanned() {
let mut log = NoteLog::default();
let set = crate::name::Name::new("research").unwrap();
let rejected = Note::SetEntryRejected {
set: set.clone(),
rejection: Rejection {
display_name: "file".into(),
reason: RejectReason::NotDirectory(EntryKind::Regular { size: 0 }),
},
};
let mut with = observed(&[], vec![rejected]);
with.scanned_sets.insert(set.clone());
assert_eq!(summarize(&log.update(&with)), ["raised file"]);
let mut without = observed(&[], vec![]);
without.scanned_sets.insert(set);
assert_eq!(summarize(&log.update(&without)), ["cleared file"]);
}
}