use core::fmt;
use std::collections::{BTreeMap, BTreeSet};
use serde::de::DeserializeOwned;
use shep_core::config::DogTable;
use shep_core::dogs::manifest::Serves;
use shep_core::protocol::{Request, Response};
use super::{DogConfig, DogRuntime, SectionError};
use crate::RequestError;
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum ServedSheepError {
DogWide {
sheep: String,
keys: Vec<String>,
},
DoesNotFit {
dog: String,
sheep: String,
},
Unresolved {
sheep: String,
reason: String,
},
}
impl ServedSheepError {
#[must_use]
pub fn sheep(&self) -> &str {
match self {
Self::DogWide { sheep, .. }
| Self::DoesNotFit { sheep, .. }
| Self::Unresolved { sheep, .. } => sheep,
}
}
}
impl fmt::Display for ServedSheepError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::DogWide { sheep, keys } => write!(
f,
"the table on {sheep} sets {}, which is dog-wide: set it in the dog's own section",
keys.join(", ")
),
Self::DoesNotFit { dog, sheep } => write!(
f,
"the settings for {sheep}, its [app.dogs.{dog}] table over [{dog}], do not fit this dog's settings"
),
Self::Unresolved { sheep, reason } => {
write!(
f,
"a secret in the table on {sheep} did not resolve: {reason}"
)
}
}
}
}
impl core::error::Error for ServedSheepError {}
#[derive(Debug)]
#[non_exhaustive]
pub enum SheepSettingsReadError {
Section(SectionError),
Request(RequestError),
}
impl fmt::Display for SheepSettingsReadError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Section(err) => write!(f, "{err}"),
Self::Request(err) => write!(f, "a request to the shepherd failed: {err}"),
}
}
}
impl core::error::Error for SheepSettingsReadError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Section(err) => Some(err),
Self::Request(err) => Some(err),
}
}
}
impl From<SectionError> for SheepSettingsReadError {
fn from(err: SectionError) -> Self {
Self::Section(err)
}
}
impl From<RequestError> for SheepSettingsReadError {
fn from(err: RequestError) -> Self {
Self::Request(err)
}
}
fn settings_for<T: DeserializeOwned>(
dog: &str,
dog_wide: &BTreeSet<String>,
section: &DogTable,
sheep: &str,
own: Option<&DogTable>,
) -> Result<T, ServedSheepError> {
let set_here: Vec<String> = own
.into_iter()
.flat_map(|own| own.as_map().keys())
.filter(|key| dog_wide.contains(*key))
.cloned()
.collect();
if !set_here.is_empty() {
return Err(ServedSheepError::DogWide {
sheep: sheep.to_owned(),
keys: set_here,
});
}
let mut shared = section.as_map().clone();
shared.retain(|key, _| !dog_wide.contains(key));
let shared = DogTable::from(shared);
let merged = match own {
Some(own) => DogTable::layered(&[&shared, own]),
None => shared,
};
serde_json::from_value(serde_json::Value::Object(merged.into_map())).map_err(|_| {
ServedSheepError::DoesNotFit {
dog: dog.to_owned(),
sheep: sheep.to_owned(),
}
})
}
impl DogRuntime {
pub async fn sheep_settings<T>(
&self,
serves: Serves,
) -> Result<BTreeMap<String, Result<T, ServedSheepError>>, SheepSettingsReadError>
where
T: DogConfig + schemars::JsonSchema + DeserializeOwned,
{
let dog = self.identity().section();
let dog_wide = super::dog_wide::dog_wide_keys::<T>();
let section = super::section::section_table(dog, self.section().as_str())?;
let carrying = self.sheep_with_a_table().await?;
let sheep = match serves {
Serves::EverySheep => self
.client()
.list_flock()
.await?
.into_iter()
.filter(|entry| entry.dog.is_none())
.map(|entry| entry.name)
.collect(),
_ => carrying.clone(),
};
let mut settings = BTreeMap::new();
for name in sheep {
if !carrying.contains(&name) {
settings.insert(
name.clone(),
settings_for(dog, &dog_wide, §ion, &name, None),
);
continue;
}
let mut own = self.own_table(&name).await?;
if own.as_ref().is_some_and(|own| !own.references().is_empty()) {
match self.client().sheep_dog_table(&name, dog).await {
Ok(resolved) => {
own = own.map(|own| resolved_like(&own, resolved.as_ref()));
}
Err(err) => {
let fault = ServedSheepError::Unresolved {
sheep: name.clone(),
reason: err.to_string(),
};
settings.insert(name, Err(fault));
continue;
}
}
}
let one = settings_for(dog, &dog_wide, §ion, &name, own.as_ref());
settings.insert(name, one);
}
Ok(settings)
}
async fn sheep_with_a_table(&self) -> Result<BTreeSet<String>, RequestError> {
let asked = Request::DogSheepSettings {
dog: self.identity().section().to_owned(),
};
match self.client().request(asked).await? {
Response::DogSheepSettings { tables } => Ok(tables.into_keys().collect()),
other => Err(RequestError::UnexpectedReply {
asked: "DogSheepSettings",
answered: other.name(),
}),
}
}
async fn own_table(&self, sheep: &str) -> Result<Option<DogTable>, RequestError> {
let asked = Request::SheepConfig {
name: sheep.to_owned(),
};
match self.client().request(asked).await? {
Response::SheepConfig(view) => {
Ok(view.config.dogs.get(self.identity().section()).cloned())
}
other => Err(RequestError::UnexpectedReply {
asked: "SheepConfig",
answered: other.name(),
}),
}
}
}
fn resolved_like(own: &DogTable, resolved: Option<&DogTable>) -> DogTable {
fn walk(
own: &serde_json::Map<String, serde_json::Value>,
resolved: Option<&serde_json::Map<String, serde_json::Value>>,
) -> serde_json::Map<String, serde_json::Value> {
own.iter()
.map(|(key, value)| {
let there = resolved.and_then(|resolved| resolved.get(key));
let value = match value {
serde_json::Value::Object(inner) => {
serde_json::Value::Object(walk(inner, there.and_then(|v| v.as_object())))
}
other => there.cloned().unwrap_or_else(|| other.clone()),
};
(key.clone(), value)
})
.collect()
}
DogTable::from(walk(own.as_map(), resolved.map(DogTable::as_map)))
}
#[cfg(test)]
mod tests;