use std::collections::{BTreeMap, BTreeSet};
use std::os::fd::AsFd;
use crate::fsops;
use crate::membership::Rejection;
use crate::mount;
use crate::name::{GroupId, Name};
use crate::reconcile::plan::{DesiredMount, Location, Observations, SourceState, TargetState};
use crate::runtime::Runtime;
use crate::state::{RecordKey, State};
use crate::template::InterpolateError;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Note {
Rejected {
group: GroupId,
rejection: Rejection,
},
InterpolationFailed {
group: GroupId,
name: Name,
field: &'static str,
error: InterpolateError,
},
SetEntryRejected {
set: Name,
rejection: Rejection,
},
SetRootDeleted {
set: Name,
},
SetRootUnreadable {
set: Name,
error: String,
},
MembershipDeleted {
group: GroupId,
},
MembershipUnreadable {
group: GroupId,
error: String,
},
}
#[derive(Debug, Default)]
pub struct Observed {
pub desired: Vec<DesiredMount>,
pub observations: Observations,
pub frozen: BTreeSet<GroupId>,
pub members: BTreeMap<GroupId, BTreeSet<Name>>,
pub scanned_sets: BTreeSet<Name>,
pub ignored: BTreeMap<GroupId, Vec<String>>,
pub notes: Vec<Note>,
}
pub fn observe(
runtime: &mut Runtime,
state: &State,
degraded: &BTreeSet<GroupId>,
unique_supported: bool,
) -> Observed {
let mut out = Observed {
frozen: degraded.clone(),
..Observed::default()
};
for (group_name, group) in &runtime.groups {
if degraded.contains(group_name) {
continue;
}
if fsops::is_deleted(group.membership_dir.as_fd()).unwrap_or(false) {
out.frozen.insert(group_name.clone());
out.notes.push(Note::MembershipDeleted {
group: group_name.clone(),
});
continue;
}
let mut membership = match fsops::scan_membership(group.membership_dir.as_fd()) {
Ok(m) => m,
Err(e) => {
out.frozen.insert(group_name.clone());
out.notes.push(Note::MembershipUnreadable {
group: group_name.clone(),
error: e.to_string(),
});
continue;
}
};
if !membership.ignored.is_empty() {
out.ignored
.insert(group_name.clone(), std::mem::take(&mut membership.ignored));
}
out.notes.extend(
membership
.rejected
.into_iter()
.map(|rejection| Note::Rejected {
group: group_name.clone(),
rejection,
}),
);
let cfg = &group.config;
for name in &membership.members {
let interpolate = |field, template: &crate::template::Template| {
template
.interpolate(name)
.map_err(|error| Note::InterpolationFailed {
group: group_name.clone(),
name: name.clone(),
field,
error,
})
};
let (source, target) = match (
interpolate("source", &cfg.source),
interpolate("target", &cfg.target),
) {
(Ok(s), Ok(t)) => (s, t),
(Err(note), _) | (_, Err(note)) => {
out.notes.push(note);
continue;
}
};
out.desired.push(DesiredMount {
key: RecordKey {
group: group_name.clone(),
name: name.clone(),
},
source: Location {
root: cfg.source_root.clone(),
path: source,
},
target: Location {
root: cfg.target_root.clone(),
path: target,
},
attrs: cfg.attrs,
});
}
out.members.insert(group_name.clone(), membership.members);
}
observe_kernel(runtime, state, unique_supported, &mut out);
out
}
fn observe_kernel(
runtime: &mut Runtime,
state: &State,
unique_supported: bool,
out: &mut Observed,
) {
for d in &out.desired {
let source = match runtime.roots.get(&d.source.root) {
Ok(root) => match fsops::resolve_dir(root, &d.source.path) {
Ok(fd) => match fsops::dev_ino(fd.as_fd()) {
Ok(id) => SourceState::Resolved(id),
Err(e) => SourceState::Unavailable(format!("{}: {e}", d.source)),
},
Err(e) => SourceState::Unavailable(format!("{}: {e}", d.source)),
},
Err(e) => SourceState::Unavailable(format!("source root {}: {e}", d.source.root)),
};
out.observations.sources.insert(d.key.clone(), source);
}
let mut targets: BTreeSet<Location> = out.desired.iter().map(|d| d.target.clone()).collect();
targets.extend(
state
.records()
.filter(|r| !out.frozen.contains(&r.group))
.map(crate::state::MountRecord::target_location),
);
for location in targets {
let observed = match runtime.roots.get(&location.root) {
Ok(root) => mount::inspect(root, &location.path, unique_supported),
Err(e) => TargetState::Unavailable(format!("target root {}: {e}", location.root)),
};
out.observations.targets.insert(location, observed);
}
}