1use core::fmt;
8use std::collections::{BTreeMap, BTreeSet};
9
10use serde::de::DeserializeOwned;
11use shep_core::config::DogTable;
12use shep_core::dogs::manifest::Serves;
13use shep_core::protocol::{Request, Response};
14
15use super::{DogConfig, DogRuntime, SectionError};
16use crate::RequestError;
17
18#[derive(Debug, Clone, PartialEq, Eq)]
23#[non_exhaustive]
24pub enum ServedSheepError {
25 DogWide {
28 sheep: String,
30 keys: Vec<String>,
32 },
33 DoesNotFit {
36 dog: String,
38 sheep: String,
40 },
41 Unresolved {
44 sheep: String,
46 reason: String,
48 },
49}
50
51impl ServedSheepError {
52 #[must_use]
54 pub fn sheep(&self) -> &str {
55 match self {
56 Self::DogWide { sheep, .. }
57 | Self::DoesNotFit { sheep, .. }
58 | Self::Unresolved { sheep, .. } => sheep,
59 }
60 }
61}
62
63impl fmt::Display for ServedSheepError {
64 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
65 match self {
66 Self::DogWide { sheep, keys } => write!(
67 f,
68 "the table on {sheep} sets {}, which is dog-wide: set it in the dog's own section",
69 keys.join(", ")
70 ),
71 Self::DoesNotFit { dog, sheep } => write!(
72 f,
73 "the settings for {sheep}, its [app.dogs.{dog}] table over [{dog}], do not fit this dog's settings"
74 ),
75 Self::Unresolved { sheep, reason } => {
76 write!(
77 f,
78 "a secret in the table on {sheep} did not resolve: {reason}"
79 )
80 }
81 }
82 }
83}
84
85impl core::error::Error for ServedSheepError {}
86
87#[derive(Debug)]
89#[non_exhaustive]
90pub enum SheepSettingsReadError {
91 Section(SectionError),
93 Request(RequestError),
95}
96
97impl fmt::Display for SheepSettingsReadError {
98 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
99 match self {
100 Self::Section(err) => write!(f, "{err}"),
101 Self::Request(err) => write!(f, "a request to the shepherd failed: {err}"),
102 }
103 }
104}
105
106impl core::error::Error for SheepSettingsReadError {
107 fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
108 match self {
109 Self::Section(err) => Some(err),
110 Self::Request(err) => Some(err),
111 }
112 }
113}
114
115impl From<SectionError> for SheepSettingsReadError {
116 fn from(err: SectionError) -> Self {
117 Self::Section(err)
118 }
119}
120
121impl From<RequestError> for SheepSettingsReadError {
122 fn from(err: RequestError) -> Self {
123 Self::Request(err)
124 }
125}
126
127fn settings_for<T: DeserializeOwned>(
130 dog: &str,
131 dog_wide: &BTreeSet<String>,
132 section: &DogTable,
133 sheep: &str,
134 own: Option<&DogTable>,
135) -> Result<T, ServedSheepError> {
136 let set_here: Vec<String> = own
137 .into_iter()
138 .flat_map(|own| own.as_map().keys())
139 .filter(|key| dog_wide.contains(*key))
140 .cloned()
141 .collect();
142 if !set_here.is_empty() {
143 return Err(ServedSheepError::DogWide {
144 sheep: sheep.to_owned(),
145 keys: set_here,
146 });
147 }
148 let mut shared = section.as_map().clone();
149 shared.retain(|key, _| !dog_wide.contains(key));
150 let shared = DogTable::from(shared);
151 let merged = match own {
152 Some(own) => DogTable::layered(&[&shared, own]),
153 None => shared,
154 };
155 serde_json::from_value(serde_json::Value::Object(merged.into_map())).map_err(|_| {
156 ServedSheepError::DoesNotFit {
157 dog: dog.to_owned(),
158 sheep: sheep.to_owned(),
159 }
160 })
161}
162
163impl DogRuntime {
164 pub async fn sheep_settings<T>(
203 &self,
204 serves: Serves,
205 ) -> Result<BTreeMap<String, Result<T, ServedSheepError>>, SheepSettingsReadError>
206 where
207 T: DogConfig + schemars::JsonSchema + DeserializeOwned,
208 {
209 let dog = self.identity().section();
210 let dog_wide = super::dog_wide::dog_wide_keys::<T>();
211 let section = super::section::section_table(dog, self.section().as_str())?;
212 let carrying = self.sheep_with_a_table().await?;
213 let sheep = match serves {
214 Serves::EverySheep => self
215 .client()
216 .list_flock()
217 .await?
218 .into_iter()
219 .filter(|entry| entry.dog.is_none())
220 .map(|entry| entry.name)
221 .collect(),
222 _ => carrying.clone(),
223 };
224 let mut settings = BTreeMap::new();
225 for name in sheep {
226 if !carrying.contains(&name) {
227 settings.insert(
228 name.clone(),
229 settings_for(dog, &dog_wide, §ion, &name, None),
230 );
231 continue;
232 }
233 let mut own = self.own_table(&name).await?;
234 if own.as_ref().is_some_and(|own| !own.references().is_empty()) {
235 match self.client().sheep_dog_table(&name, dog).await {
236 Ok(resolved) => {
237 own = own.map(|own| resolved_like(&own, resolved.as_ref()));
238 }
239 Err(err) => {
240 let fault = ServedSheepError::Unresolved {
241 sheep: name.clone(),
242 reason: err.to_string(),
243 };
244 settings.insert(name, Err(fault));
245 continue;
246 }
247 }
248 }
249 let one = settings_for(dog, &dog_wide, §ion, &name, own.as_ref());
250 settings.insert(name, one);
251 }
252 Ok(settings)
253 }
254
255 async fn sheep_with_a_table(&self) -> Result<BTreeSet<String>, RequestError> {
260 let asked = Request::DogSheepSettings {
261 dog: self.identity().section().to_owned(),
262 };
263 match self.client().request(asked).await? {
264 Response::DogSheepSettings { tables } => Ok(tables.into_keys().collect()),
265 other => Err(RequestError::UnexpectedReply {
266 asked: "DogSheepSettings",
267 answered: other.name(),
268 }),
269 }
270 }
271
272 async fn own_table(&self, sheep: &str) -> Result<Option<DogTable>, RequestError> {
275 let asked = Request::SheepConfig {
276 name: sheep.to_owned(),
277 };
278 match self.client().request(asked).await? {
279 Response::SheepConfig(view) => {
280 Ok(view.config.dogs.get(self.identity().section()).cloned())
281 }
282 other => Err(RequestError::UnexpectedReply {
283 asked: "SheepConfig",
284 answered: other.name(),
285 }),
286 }
287 }
288}
289
290fn resolved_like(own: &DogTable, resolved: Option<&DogTable>) -> DogTable {
297 fn walk(
298 own: &serde_json::Map<String, serde_json::Value>,
299 resolved: Option<&serde_json::Map<String, serde_json::Value>>,
300 ) -> serde_json::Map<String, serde_json::Value> {
301 own.iter()
302 .map(|(key, value)| {
303 let there = resolved.and_then(|resolved| resolved.get(key));
304 let value = match value {
305 serde_json::Value::Object(inner) => {
306 serde_json::Value::Object(walk(inner, there.and_then(|v| v.as_object())))
307 }
308 other => there.cloned().unwrap_or_else(|| other.clone()),
309 };
310 (key.clone(), value)
311 })
312 .collect()
313 }
314 DogTable::from(walk(own.as_map(), resolved.map(DogTable::as_map)))
315}
316
317#[cfg(test)]
318mod tests;