use std::collections::{HashMap, hash_map::Entry};
use super::types::{OptionCategory, OptionDef, OptionValue};
#[derive(Clone)]
pub struct OptionRegistry {
pub(super) options: HashMap<String, OptionDef>,
}
impl OptionRegistry {
pub fn new() -> Self {
let mut reg = Self {
options: HashMap::new(),
};
reg.register_general_options();
reg.register_http_ftp_options();
#[cfg(feature = "bittorrent")]
reg.register_bt_options();
reg.register_rpc_options();
reg.register_advanced_options();
reg
}
pub fn register(&mut self, def: OptionDef) {
let name = def.name().to_owned();
match self.options.entry(name) {
Entry::Vacant(entry) => {
entry.insert(def);
}
Entry::Occupied(entry) => {
panic!("duplicate configuration option '{}'", entry.key());
}
}
}
pub fn get(&self, name: &str) -> Option<&OptionDef> {
self.options.get(Self::canonical_name(name))
}
pub fn parse_rpc_value(
&self,
name: &str,
value: &serde_json::Value,
) -> Result<OptionValue, String> {
let definition = self
.get(name)
.ok_or_else(|| format!("unknown option '{}'", name))?;
if value.is_array() && definition.cumulative_delimiter.is_none() {
return Err("option value must be a string".to_string());
}
let raw = rpc_value_to_string(value)?;
definition.parse_value(&raw)
}
pub fn contains(&self, name: &str) -> bool {
self.get(name).is_some()
}
pub fn all(&self) -> &HashMap<String, OptionDef> {
&self.options
}
pub fn project_defined_global_options_for_rpc(
&self,
options: &HashMap<String, serde_json::Value>,
) -> HashMap<String, serde_json::Value> {
self.options
.iter()
.filter(|(_, definition)| definition.is_exposed_in_aria2_rpc())
.filter_map(|(name, _)| {
options
.get(name)
.cloned()
.map(|value| (name.clone(), value))
})
.collect()
}
pub fn count(&self) -> usize {
self.options.len()
}
pub fn by_category(&self, cat: OptionCategory) -> Vec<&OptionDef> {
self.options
.values()
.filter(|d| d.get_category() == cat)
.collect()
}
}
impl Default for OptionRegistry {
fn default() -> Self {
Self::new()
}
}
impl OptionRegistry {
fn canonical_name(name: &str) -> &str {
match name {
"max-retries" => "max-tries",
_ => name,
}
}
}
fn rpc_value_to_string(value: &serde_json::Value) -> Result<String, String> {
match value {
serde_json::Value::String(value) => Ok(value.clone()),
serde_json::Value::Number(value) => Ok(value.to_string()),
serde_json::Value::Bool(value) => Ok(value.to_string()),
serde_json::Value::Array(values) => values
.iter()
.map(rpc_value_to_string)
.collect::<Result<Vec<_>, _>>()
.map(|values| values.join("\n")),
serde_json::Value::Null => Err("option value must not be null".to_string()),
serde_json::Value::Object(_) => Err("option value must be scalar or array".to_string()),
}
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use super::OptionRegistry;
#[test]
fn global_rpc_projection_keeps_hidden_original_options_outside_help_and_extensions() {
let registry = OptionRegistry::new();
#[allow(unused_mut)]
let mut options = HashMap::from([
("dns-timeout".to_string(), serde_json::json!(30)),
("rpc-secret".to_string(), serde_json::json!("do-not-return")),
(
"not-a-registered-option".to_string(),
serde_json::json!("private"),
),
]);
#[cfg(feature = "bittorrent")]
{
options.insert(
"bt-tracker-source".to_string(),
serde_json::json!("https://example.test/trackers.txt"),
);
options.insert(
"bt-tracker-update-interval".to_string(),
serde_json::json!(86400),
);
options.insert(
"enable-public-trackers".to_string(),
serde_json::json!(true),
);
options.insert("enable-utp".to_string(), serde_json::json!(true));
options.insert("utp-listen-port".to_string(), serde_json::json!(6882));
}
let projected = registry.project_defined_global_options_for_rpc(&options);
assert_eq!(projected.get("dns-timeout"), Some(&serde_json::json!(30)));
assert!(!projected.contains_key("rpc-secret"));
assert!(!projected.contains_key("not-a-registered-option"));
#[cfg(feature = "bittorrent")]
{
assert!(!projected.contains_key("enable-utp"));
assert!(!projected.contains_key("utp-listen-port"));
assert!(!projected.contains_key("bt-tracker-source"));
assert!(!projected.contains_key("bt-tracker-update-interval"));
assert!(!projected.contains_key("enable-public-trackers"));
}
}
}