use serde_json::Value;
pub type DeprecationMapper = fn(&Value) -> Result<Value, String>;
#[derive(Debug, Clone, Copy)]
pub struct Deprecation {
pub key: &'static str,
pub since_version: &'static str,
pub new_key: &'static str,
pub auto_map: bool,
pub map_fn: Option<DeprecationMapper>,
}
impl Deprecation {
pub fn is_mappable(&self) -> bool {
self.auto_map || self.map_fn.is_some()
}
}
pub const fn deprecations() -> &'static [Deprecation] {
&[Deprecation {
key: "waf_config",
since_version: "0.9.0",
new_key: "",
auto_map: false,
map_fn: None,
}]
}
pub fn apply_deprecations(
tree: &mut Value,
registry: &[Deprecation],
current_version: &str,
new_key_defaults: &Value,
) -> Result<(), Vec<String>> {
if registry.is_empty() {
return Ok(());
}
let mut errors: Vec<String> = Vec::new();
for dep in registry {
let segments: Vec<&str> = dep.key.split('.').collect();
let Some(old_value) = value_at_path(tree, &segments).cloned() else {
continue;
};
match parsed_version(current_version) {
Err(reason) => {
errors.push(format!(
"config key \"{}\" deprecated since {}: cannot determine current version \"{}\" ({}); \
migrate the key manually before retrying",
dep.key, dep.since_version, current_version, reason
));
},
Ok(version) if is_at_least_1_0_0(&version) => {
errors.push(unmigrated_error_message(dep));
},
Ok(_) if dep.is_mappable() => {
let mapped = match dep.map_fn {
Some(map_fn) => map_fn(&old_value),
None => Ok(old_value.clone()),
};
match mapped {
Ok(new_value) => {
remove_value_at_path(tree, &segments);
if dep.new_key.is_empty() {
warn_migrated(dep, "removed without replacement");
continue;
}
let new_segments: Vec<&str> = dep.new_key.split('.').collect();
if new_key_is_explicit(&new_segments, tree, new_key_defaults) {
warn_migrated(
dep,
"new key already explicitly configured; legacy value discarded",
);
continue;
}
insert_value_at_path(tree, &new_segments, new_value);
warn_migrated(dep, "value migrated");
},
Err(reason) => {
errors.push(format!(
"config key \"{}\" deprecated since {}: value cannot be auto-migrated: {}",
dep.key, dep.since_version, reason
));
},
}
},
Ok(_) => warn_unmigrated(dep),
}
}
if errors.is_empty() {
Ok(())
} else {
Err(errors)
}
}
fn new_key_is_explicit(new_segments: &[&str], tree: &Value, defaults: &Value) -> bool {
let Some(current) = value_at_path(tree, new_segments) else {
return false;
};
match value_at_path(defaults, new_segments) {
Some(default_value) => current != default_value,
None => true,
}
}
fn unmigrated_error_message(dep: &Deprecation) -> String {
let guidance = if dep.new_key.is_empty() {
"this key has been removed; delete it from your configuration".to_string()
} else {
format!("rename it to \"{}\" in your configuration", dep.new_key)
};
format!(
"config key \"{}\" deprecated since {}: support ended at 1.0.0; {}",
dep.key, dep.since_version, guidance
)
}
fn warn_migrated(dep: &Deprecation, outcome: &str) {
tracing::warn!(
deprecated_key = dep.key,
since = dep.since_version,
new_key = dep.new_key,
"{}",
crate::i18n::translate_detail(
"logs-config-deprecated-key-migrated",
&[
("key", dep.key),
("since", dep.since_version),
("outcome", outcome),
]
)
);
}
fn warn_unmigrated(dep: &Deprecation) {
let guidance = if dep.new_key.is_empty() {
crate::i18n::translate_detail("config-deprecation-guidance-delete", &[])
} else {
crate::i18n::translate_detail("config-deprecation-guidance-rename", &[])
};
tracing::warn!(
deprecated_key = dep.key,
since = dep.since_version,
new_key = dep.new_key,
"{}",
crate::i18n::translate_detail(
"logs-config-deprecated-key-unmigratable",
&[
("key", dep.key),
("since", dep.since_version),
("guidance", guidance.as_str()),
]
)
);
}
type SemVer = ((u64, u64, u64), Option<String>);
fn parsed_version(version: &str) -> Result<SemVer, String> {
let (core, pre) = match version.split_once('-') {
Some((core, pre)) => (core, Some(pre.to_string())),
None => (version, None),
};
let mut numbers = [0u64; 3];
for (idx, part) in core.split('.').enumerate() {
if idx >= 3 {
return Err(format!("too many components in version \"{}\"", version));
}
numbers[idx] = part
.parse()
.map_err(|_| format!("invalid version component \"{}\"", part))?;
}
Ok(((numbers[0], numbers[1], numbers[2]), pre))
}
fn is_at_least_1_0_0(version: &SemVer) -> bool {
let ((major, minor, patch), pre) = version;
match (*major, *minor, *patch).cmp(&(1, 0, 0)) {
std::cmp::Ordering::Less => false,
std::cmp::Ordering::Greater => true,
std::cmp::Ordering::Equal => pre.is_none(),
}
}
fn value_at_path<'a>(tree: &'a Value, segments: &[&str]) -> Option<&'a Value> {
let (head, tail) = segments.split_first()?;
if tail.is_empty() {
return tree.get(*head);
}
value_at_path(tree.get(*head)?, tail)
}
fn remove_value_at_path(tree: &mut Value, segments: &[&str]) -> Option<Value> {
let (head, tail) = segments.split_first()?;
let object = tree.as_object_mut()?;
if tail.is_empty() {
return object.remove(*head);
}
remove_value_at_path(object.get_mut(*head)?, tail)
}
fn insert_value_at_path(tree: &mut Value, segments: &[&str], value: Value) {
let Some((head, tail)) = segments.split_first() else {
return;
};
if !tree.is_object() {
*tree = serde_json::Map::new().into();
}
let object = tree.as_object_mut().expect("上一步已确保为对象");
if tail.is_empty() {
object.insert((*head).to_string(), value);
return;
}
let child = object
.entry((*head).to_string())
.or_insert_with(|| serde_json::Map::new().into());
insert_value_at_path(child, tail, value);
}