use super::*;
pub(super) const EXTRAS_FIELDS: &[&str] = &[
"max_memory",
"watch",
"ignore_watch",
"watch_delay",
"watch_options",
"cron_restart",
"cron_timezone",
"liveness_probe",
];
fn establish_env(next: &mut AppOverrides, incoming: &DeclaredApp) {
if let Some(serde_json::Value::Object(env)) = next.fields.get_mut("env") {
for key in &incoming.declared_env {
if env.get(key).is_some_and(serde_json::Value::is_null) {
continue;
}
env.remove(key);
}
if env.is_empty() {
next.fields.remove("env");
}
}
next.declared_env
.extend(incoming.declared_env.iter().cloned());
}
fn app_config_object(
config: &AppConfig,
) -> Result<serde_json::Map<String, serde_json::Value>, String> {
match serde_json::to_value(config) {
Ok(serde_json::Value::Object(map)) => Ok(map),
Ok(_) => Err("an app config must serialize as an object".to_string()),
Err(err) => Err(err.to_string()),
}
}
fn app_config_from_object(
map: serde_json::Map<String, serde_json::Value>,
) -> Result<AppConfig, String> {
serde_json::from_value(serde_json::Value::Object(map)).map_err(|err| err.to_string())
}
pub(super) fn merge_declared(
stored: &AppConfig,
incoming: &DeclaredApp,
overrides: &AppOverrides,
reset: ResetDepth,
) -> Result<(AppConfig, AppOverrides), String> {
let mut merged = app_config_object(stored)?;
let file = app_config_object(&incoming.config)?;
let defaults = app_config_object(&AppConfig::default())?;
let mut next = overrides.clone();
let established: BTreeSet<&String> = overrides
.declared
.iter()
.chain(overrides.fields.keys())
.collect();
for key in defaults.keys() {
if key == "env" {
continue;
}
let in_scope = match reset {
ResetDepth::Policy | ResetDepth::All => true,
ResetDepth::File => incoming.declared.contains(key),
_ => {
key != "instances" && incoming.declared.contains(key) && !established.contains(key)
}
};
if !in_scope {
if next.fields.contains_key(key)
&& let Some(value) = incoming
.declared
.contains(key)
.then(|| file.get(key))
.flatten()
{
next.template.insert(key.clone(), value.clone());
}
continue;
}
next.fields.remove(key);
next.template.remove(key);
if incoming.declared.contains(key) {
next.declared.insert(key.clone());
}
if let Some(value) = file.get(key) {
merged.insert(key.clone(), value.clone());
}
}
match reset {
ResetDepth::Policy | ResetDepth::File => {}
ResetDepth::All | ResetDepth::Env => {
next.fields.remove("env");
merged.insert(
"env".to_string(),
file.get("env")
.cloned()
.unwrap_or_else(|| serde_json::Value::Object(serde_json::Map::new())),
);
establish_env(&mut next, incoming);
}
_ => {
let overridden_env: BTreeSet<&String> = overrides
.fields
.get("env")
.and_then(serde_json::Value::as_object)
.map(|env| env.keys().collect())
.unwrap_or_default();
let mut env = stored.env.clone();
for key in &incoming.declared_env {
if overrides.declared_env.contains(key) || overridden_env.contains(key) {
continue;
}
if let Some(value) = incoming.config.env.get(key) {
env.insert(key.clone(), value.clone());
}
}
merged.insert(
"env".to_string(),
serde_json::to_value(env).map_err(|err| err.to_string())?,
);
establish_env(&mut next, incoming);
}
}
let merged = app_config_from_object(merged)?;
Ok((merged, next))
}
pub(super) fn reached_spec<'a>(
stored: &AppConfig,
merged: &AppConfig,
reaching: impl IntoIterator<Item = &'a String>,
instances: u32,
) -> Result<ResolvedApp, String> {
let mut next = app_config_object(stored)?;
let source = app_config_object(merged)?;
for field in reaching {
if let Some(value) = source.get(field) {
next.insert(field.clone(), value.clone());
}
}
let mut config = app_config_from_object(next)?;
config.instances = instances;
normalize(config).map_err(|err| err.to_string())
}
pub(super) fn pending_fields(entry: &ProcessEntry) -> Vec<String> {
entry.pending.as_ref().map_or_else(Vec::new, |parked| {
entry.spec.config().drifted_fields(parked.config())
})
}
pub(super) fn dog_config_refusal(name: &str) -> String {
format!(
"{name} is a dog, and a dog's config comes from `shep adopt` rather than \
from a Flockfile"
)
}
pub(super) fn env_override_map<'a>(
record: &'a mut AppOverrides,
name: &str,
) -> Result<&'a mut serde_json::Map<String, serde_json::Value>, SupervisorError> {
record
.fields
.entry("env".to_string())
.or_insert_with(|| serde_json::Value::Object(serde_json::Map::new()))
.as_object_mut()
.ok_or_else(|| {
SupervisorError::Overrides(format!("{name}'s stored `env` override is not an object"))
})
}
pub(super) fn try_with_count(
app: &ResolvedApp,
instances: u32,
) -> Result<ResolvedApp, NormalizeError> {
let mut config = app.config().clone();
config.instances = instances;
normalize(config)
}
pub(super) fn with_count(app: &ResolvedApp, instances: u32) -> Option<ResolvedApp> {
try_with_count(app, instances).ok()
}