rename appmgr

backend/src/config/action.rs

@@ -0,0 +1,103 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use color_eyre::eyre::eyre;
+use nix::sys::signal::Signal;
+use patch_db::HasModel;
+use serde::{Deserialize, Serialize};
+use tracing::instrument;
+
+use super::{Config, ConfigSpec};
+use crate::action::ActionImplementation;
+use crate::context::RpcContext;
+use crate::dependencies::Dependencies;
+use crate::s9pk::manifest::PackageId;
+use crate::status::health_check::HealthCheckId;
+use crate::util::Version;
+use crate::volume::Volumes;
+use crate::Error;
+
+#[derive(Debug, Deserialize, Serialize, HasModel)]
+#[serde(rename_all = "kebab-case")]
+pub struct ConfigRes {
+    pub config: Option<Config>,
+    pub spec: ConfigSpec,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, HasModel)]
+pub struct ConfigActions {
+    pub get: ActionImplementation,
+    pub set: ActionImplementation,
+}
+impl ConfigActions {
+    #[instrument(skip(ctx))]
+    pub async fn get(
+        &self,
+        ctx: &RpcContext,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        volumes: &Volumes,
+    ) -> Result<ConfigRes, Error> {
+        self.get
+            .execute(
+                ctx,
+                pkg_id,
+                pkg_version,
+                Some("GetConfig"),
+                volumes,
+                None::<()>,
+                false,
+                None,
+            )
+            .await
+            .and_then(|res| {
+                res.map_err(|e| Error::new(eyre!("{}", e.1), crate::ErrorKind::ConfigGen))
+            })
+    }
+
+    #[instrument(skip(ctx))]
+    pub async fn set(
+        &self,
+        ctx: &RpcContext,
+        pkg_id: &PackageId,
+        pkg_version: &Version,
+        dependencies: &Dependencies,
+        volumes: &Volumes,
+        input: &Config,
+    ) -> Result<SetResult, Error> {
+        let res: SetResult = self
+            .set
+            .execute(
+                ctx,
+                pkg_id,
+                pkg_version,
+                Some("SetConfig"),
+                volumes,
+                Some(input),
+                false,
+                None,
+            )
+            .await
+            .and_then(|res| {
+                res.map_err(|e| {
+                    Error::new(eyre!("{}", e.1), crate::ErrorKind::ConfigRulesViolation)
+                })
+            })?;
+        Ok(SetResult {
+            signal: res.signal,
+            depends_on: res
+                .depends_on
+                .into_iter()
+                .filter(|(pkg, _)| dependencies.0.contains_key(pkg))
+                .collect(),
+        })
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct SetResult {
+    #[serde(deserialize_with = "crate::util::serde::deserialize_from_str_opt")]
+    #[serde(serialize_with = "crate::util::serde::serialize_display_opt")]
+    pub signal: Option<Signal>,
+    pub depends_on: BTreeMap<PackageId, BTreeSet<HealthCheckId>>,
+}

backend/src/config/mod.rs

@@ -0,0 +1,541 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::time::Duration;
+
+use color_eyre::eyre::eyre;
+use futures::future::{BoxFuture, FutureExt};
+use indexmap::IndexSet;
+use itertools::Itertools;
+use patch_db::{DbHandle, LockType};
+use rand::SeedableRng;
+use regex::Regex;
+use rpc_toolkit::command;
+use serde_json::Value;
+use tracing::instrument;
+
+use crate::context::RpcContext;
+use crate::db::model::CurrentDependencyInfo;
+use crate::db::util::WithRevision;
+use crate::dependencies::{
+    add_dependent_to_current_dependents_lists, break_transitive, heal_all_dependents_transitive,
+    BreakageRes, DependencyError, DependencyErrors, TaggedDependencyError,
+};
+use crate::install::cleanup::remove_from_current_dependents_lists;
+use crate::s9pk::manifest::{Manifest, PackageId};
+use crate::util::display_none;
+use crate::util::serde::{display_serializable, parse_stdin_deserializable, IoFormat};
+use crate::{Error, ResultExt as _};
+
+pub mod action;
+pub mod spec;
+pub mod util;
+
+pub use spec::{ConfigSpec, Defaultable};
+use util::NumRange;
+
+use self::action::ConfigRes;
+use self::spec::{PackagePointerSpec, ValueSpecPointer};
+
+pub type Config = serde_json::Map<String, Value>;
+pub trait TypeOf {
+    fn type_of(&self) -> &'static str;
+}
+impl TypeOf for Value {
+    fn type_of(&self) -> &'static str {
+        match self {
+            Value::Array(_) => "list",
+            Value::Bool(_) => "boolean",
+            Value::Null => "null",
+            Value::Number(_) => "number",
+            Value::Object(_) => "object",
+            Value::String(_) => "string",
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ConfigurationError {
+    #[error("Timeout Error")]
+    TimeoutError(#[from] TimeoutError),
+    #[error("No Match: {0}")]
+    NoMatch(#[from] NoMatchWithPath),
+    #[error("System Error: {0}")]
+    SystemError(Error),
+    #[error("Permission Denied: {0}")]
+    PermissionDenied(ValueSpecPointer),
+}
+impl From<ConfigurationError> for Error {
+    fn from(err: ConfigurationError) -> Self {
+        let kind = match &err {
+            ConfigurationError::SystemError(e) => e.kind,
+            _ => crate::ErrorKind::ConfigGen,
+        };
+        crate::Error::new(err, kind)
+    }
+}
+
+#[derive(Clone, Copy, Debug, thiserror::Error)]
+#[error("Timeout Error")]
+pub struct TimeoutError;
+
+#[derive(Clone, Debug, thiserror::Error)]
+pub struct NoMatchWithPath {
+    pub path: Vec<String>,
+    pub error: MatchError,
+}
+impl NoMatchWithPath {
+    pub fn new(error: MatchError) -> Self {
+        NoMatchWithPath {
+            path: Vec::new(),
+            error,
+        }
+    }
+    pub fn prepend(mut self, seg: String) -> Self {
+        self.path.push(seg);
+        self
+    }
+}
+impl std::fmt::Display for NoMatchWithPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {}", self.path.iter().rev().join("."), self.error)
+    }
+}
+impl From<NoMatchWithPath> for Error {
+    fn from(e: NoMatchWithPath) -> Self {
+        ConfigurationError::from(e).into()
+    }
+}
+
+#[derive(Clone, Debug, thiserror::Error)]
+pub enum MatchError {
+    #[error("String {0:?} Does Not Match Pattern {1}")]
+    Pattern(String, Regex),
+    #[error("String {0:?} Is Not In Enum {1:?}")]
+    Enum(String, IndexSet<String>),
+    #[error("Field Is Not Nullable")]
+    NotNullable,
+    #[error("Length Mismatch: expected {0}, actual: {1}")]
+    LengthMismatch(NumRange<usize>, usize),
+    #[error("Invalid Type: expected {0}, actual: {1}")]
+    InvalidType(&'static str, &'static str),
+    #[error("Number Out Of Range: expected {0}, actual: {1}")]
+    OutOfRange(NumRange<f64>, f64),
+    #[error("Number Is Not Integral: {0}")]
+    NonIntegral(f64),
+    #[error("Variant {0:?} Is Not In Union {1:?}")]
+    Union(String, IndexSet<String>),
+    #[error("Variant Is Missing Tag {0:?}")]
+    MissingTag(String),
+    #[error("Property {0:?} Of Variant {1:?} Conflicts With Union Tag")]
+    PropertyMatchesUnionTag(String, String),
+    #[error("Name of Property {0:?} Conflicts With Map Tag Name")]
+    PropertyNameMatchesMapTag(String),
+    #[error("Pointer Is Invalid: {0}")]
+    InvalidPointer(spec::ValueSpecPointer),
+    #[error("Object Key Is Invalid: {0}")]
+    InvalidKey(String),
+    #[error("Value In List Is Not Unique")]
+    ListUniquenessViolation,
+}
+
+#[command(subcommands(get, set))]
+pub fn config(#[arg] id: PackageId) -> Result<PackageId, Error> {
+    Ok(id)
+}
+
+#[command(display(display_serializable))]
+#[instrument(skip(ctx))]
+pub async fn get(
+    #[context] ctx: RpcContext,
+    #[parent_data] id: PackageId,
+    #[allow(unused_variables)]
+    #[arg(long = "format")]
+    format: Option<IoFormat>,
+) -> Result<ConfigRes, Error> {
+    let mut db = ctx.db.handle();
+    let pkg_model = crate::db::DatabaseModel::new()
+        .package_data()
+        .idx_model(&id)
+        .and_then(|m| m.installed())
+        .expect(&mut db)
+        .await
+        .with_kind(crate::ErrorKind::NotFound)?;
+    let action = pkg_model
+        .clone()
+        .manifest()
+        .config()
+        .get(&mut db, true)
+        .await?
+        .to_owned()
+        .ok_or_else(|| Error::new(eyre!("{} has no config", id), crate::ErrorKind::NotFound))?;
+    let version = pkg_model
+        .clone()
+        .manifest()
+        .version()
+        .get(&mut db, true)
+        .await?;
+    let volumes = pkg_model.manifest().volumes().get(&mut db, true).await?;
+    action.get(&ctx, &id, &*version, &*volumes).await
+}
+
+#[command(
+    subcommands(self(set_impl(async, context(RpcContext))), set_dry),
+    display(display_none)
+)]
+#[instrument]
+pub fn set(
+    #[parent_data] id: PackageId,
+    #[allow(unused_variables)]
+    #[arg(long = "format")]
+    format: Option<IoFormat>,
+    #[arg(long = "timeout")] timeout: Option<crate::util::serde::Duration>,
+    #[arg(stdin, parse(parse_stdin_deserializable))] config: Option<Config>,
+    #[arg(rename = "expire-id", long = "expire-id")] expire_id: Option<String>,
+) -> Result<(PackageId, Option<Config>, Option<Duration>, Option<String>), Error> {
+    Ok((id, config, timeout.map(|d| *d), expire_id))
+}
+
+#[command(rename = "dry", display(display_serializable))]
+#[instrument(skip(ctx))]
+pub async fn set_dry(
+    #[context] ctx: RpcContext,
+    #[parent_data] (id, config, timeout, _): (
+        PackageId,
+        Option<Config>,
+        Option<Duration>,
+        Option<String>,
+    ),
+) -> Result<BreakageRes, Error> {
+    let mut db = ctx.db.handle();
+    let mut tx = db.begin().await?;
+    let mut breakages = BTreeMap::new();
+    configure(
+        &ctx,
+        &mut tx,
+        &id,
+        config,
+        &timeout,
+        true,
+        &mut BTreeMap::new(),
+        &mut breakages,
+    )
+    .await?;
+    crate::db::DatabaseModel::new()
+        .package_data()
+        .idx_model(&id)
+        .expect(&mut tx)
+        .await?
+        .installed()
+        .expect(&mut tx)
+        .await?
+        .status()
+        .configured()
+        .put(&mut tx, &true)
+        .await?;
+    tx.abort().await?;
+    Ok(BreakageRes(breakages))
+}
+
+#[instrument(skip(ctx))]
+pub async fn set_impl(
+    ctx: RpcContext,
+    (id, config, timeout, expire_id): (PackageId, Option<Config>, Option<Duration>, Option<String>),
+) -> Result<WithRevision<()>, Error> {
+    let mut db = ctx.db.handle();
+    let mut tx = db.begin().await?;
+    let mut breakages = BTreeMap::new();
+    configure(
+        &ctx,
+        &mut tx,
+        &id,
+        config,
+        &timeout,
+        false,
+        &mut BTreeMap::new(),
+        &mut breakages,
+    )
+    .await?;
+    Ok(WithRevision {
+        response: (),
+        revision: tx.commit(expire_id).await?,
+    })
+}
+
+#[instrument(skip(ctx, db))]
+pub async fn configure<Db: DbHandle>(
+    ctx: &RpcContext,
+    db: &mut Db,
+    id: &PackageId,
+    config: Option<Config>,
+    timeout: &Option<Duration>,
+    dry_run: bool,
+    overrides: &mut BTreeMap<PackageId, Config>,
+    breakages: &mut BTreeMap<PackageId, TaggedDependencyError>,
+) -> Result<(), Error> {
+    configure_rec(ctx, db, id, config, timeout, dry_run, overrides, breakages).await?;
+    crate::db::DatabaseModel::new()
+        .package_data()
+        .idx_model(&id)
+        .expect(db)
+        .await?
+        .installed()
+        .expect(db)
+        .await?
+        .status()
+        .configured()
+        .put(db, &true)
+        .await?;
+    Ok(())
+}
+
+#[instrument(skip(ctx, db))]
+pub fn configure_rec<'a, Db: DbHandle>(
+    ctx: &'a RpcContext,
+    db: &'a mut Db,
+    id: &'a PackageId,
+    config: Option<Config>,
+    timeout: &'a Option<Duration>,
+    dry_run: bool,
+    overrides: &'a mut BTreeMap<PackageId, Config>,
+    breakages: &'a mut BTreeMap<PackageId, TaggedDependencyError>,
+) -> BoxFuture<'a, Result<(), Error>> {
+    async move {
+        crate::db::DatabaseModel::new()
+            .package_data()
+            .lock(db, LockType::Write)
+            .await?;
+        // fetch data from db
+        let pkg_model = crate::db::DatabaseModel::new()
+            .package_data()
+            .idx_model(id)
+            .and_then(|m| m.installed())
+            .expect(db)
+            .await
+            .with_kind(crate::ErrorKind::NotFound)?;
+        let action = pkg_model
+            .clone()
+            .manifest()
+            .config()
+            .get(db, true)
+            .await?
+            .to_owned()
+            .ok_or_else(|| Error::new(eyre!("{} has no config", id), crate::ErrorKind::NotFound))?;
+        let version = pkg_model.clone().manifest().version().get(db, true).await?;
+        let dependencies = pkg_model
+            .clone()
+            .manifest()
+            .dependencies()
+            .get(db, true)
+            .await?;
+        let volumes = pkg_model.clone().manifest().volumes().get(db, true).await?;
+
+        // get current config and current spec
+        let ConfigRes {
+            config: old_config,
+            spec,
+        } = action.get(ctx, id, &*version, &*volumes).await?;
+
+        // determine new config to use
+        let mut config = if let Some(config) = config.or_else(|| old_config.clone()) {
+            config
+        } else {
+            spec.gen(&mut rand::rngs::StdRng::from_entropy(), timeout)?
+        };
+
+        let manifest = crate::db::DatabaseModel::new()
+            .package_data()
+            .idx_model(id)
+            .and_then(|m| m.installed())
+            .map::<_, Manifest>(|i| i.manifest())
+            .expect(db)
+            .await?
+            .get(db, true)
+            .await
+            .with_kind(crate::ErrorKind::NotFound)?;
+
+        spec.validate(&*manifest)?;
+        spec.matches(&config)?; // check that new config matches spec
+        spec.update(ctx, db, &*manifest, &*overrides, &mut config)
+            .await?; // dereference pointers in the new config
+
+        // create backreferences to pointers
+        let mut sys = pkg_model.clone().system_pointers().get_mut(db).await?;
+        sys.truncate(0);
+        let mut current_dependencies: BTreeMap<PackageId, CurrentDependencyInfo> = dependencies
+            .0
+            .iter()
+            .filter_map(|(id, info)| {
+                if info.requirement.required() {
+                    Some((id.clone(), CurrentDependencyInfo::default()))
+                } else {
+                    None
+                }
+            })
+            .collect();
+        for ptr in spec.pointers(&config)? {
+            match ptr {
+                ValueSpecPointer::Package(pkg_ptr) => {
+                    if let Some(current_dependency) =
+                        current_dependencies.get_mut(pkg_ptr.package_id())
+                    {
+                        current_dependency.pointers.push(pkg_ptr);
+                    } else {
+                        current_dependencies.insert(
+                            pkg_ptr.package_id().to_owned(),
+                            CurrentDependencyInfo {
+                                pointers: vec![pkg_ptr],
+                                health_checks: BTreeSet::new(),
+                            },
+                        );
+                    }
+                }
+                ValueSpecPointer::System(s) => sys.push(s),
+            }
+        }
+        sys.save(db).await?;
+
+        let signal = if !dry_run {
+            // run config action
+            let res = action
+                .set(ctx, id, &*version, &*dependencies, &*volumes, &config)
+                .await?;
+
+            // track dependencies with no pointers
+            for (package_id, health_checks) in res.depends_on.into_iter() {
+                if let Some(current_dependency) = current_dependencies.get_mut(&package_id) {
+                    current_dependency.health_checks.extend(health_checks);
+                } else {
+                    current_dependencies.insert(
+                        package_id,
+                        CurrentDependencyInfo {
+                            pointers: Vec::new(),
+                            health_checks,
+                        },
+                    );
+                }
+            }
+
+            // track dependency health checks
+            current_dependencies = current_dependencies
+                .into_iter()
+                .filter(|(dep_id, _)| {
+                    if dep_id != id && !manifest.dependencies.0.contains_key(dep_id) {
+                        tracing::warn!("Illegal dependency specified: {}", dep_id);
+                        false
+                    } else {
+                        true
+                    }
+                })
+                .collect();
+            res.signal
+        } else {
+            None
+        };
+
+        // update dependencies
+        let mut deps = pkg_model.clone().current_dependencies().get_mut(db).await?;
+        remove_from_current_dependents_lists(db, id, deps.keys()).await?; // remove previous
+        add_dependent_to_current_dependents_lists(db, id, &current_dependencies).await?; // add new
+        current_dependencies.remove(id);
+        *deps = current_dependencies.clone();
+        deps.save(db).await?;
+        let mut errs = pkg_model
+            .clone()
+            .status()
+            .dependency_errors()
+            .get_mut(db)
+            .await?;
+        *errs = DependencyErrors::init(ctx, db, &*manifest, &current_dependencies).await?;
+        errs.save(db).await?;
+
+        // cache current config for dependents
+        overrides.insert(id.clone(), config.clone());
+
+        // handle dependents
+        let dependents = pkg_model.clone().current_dependents().get(db, true).await?;
+        let prev = old_config.map(Value::Object).unwrap_or_default();
+        let next = Value::Object(config.clone());
+        for (dependent, dep_info) in dependents.iter().filter(|(dep_id, _)| dep_id != &id) {
+            // check if config passes dependent check
+            let dependent_model = crate::db::DatabaseModel::new()
+                .package_data()
+                .idx_model(dependent)
+                .and_then(|pkg| pkg.installed())
+                .expect(db)
+                .await?;
+            if let Some(cfg) = &*dependent_model
+                .clone()
+                .manifest()
+                .dependencies()
+                .idx_model(id)
+                .expect(db)
+                .await?
+                .config()
+                .get(db, true)
+                .await?
+            {
+                let manifest = dependent_model.clone().manifest().get(db, true).await?;
+                if let Err(error) = cfg
+                    .check(
+                        ctx,
+                        dependent,
+                        &manifest.version,
+                        &manifest.volumes,
+                        &config,
+                    )
+                    .await?
+                {
+                    let dep_err = DependencyError::ConfigUnsatisfied { error };
+                    break_transitive(db, dependent, id, dep_err, breakages).await?;
+                }
+
+                // handle backreferences
+                for ptr in &dep_info.pointers {
+                    if let PackagePointerSpec::Config(cfg_ptr) = ptr {
+                        if cfg_ptr.select(&next) != cfg_ptr.select(&prev) {
+                            if let Err(e) = configure_rec(
+                                ctx, db, dependent, None, timeout, dry_run, overrides, breakages,
+                            )
+                            .await
+                            {
+                                if e.kind == crate::ErrorKind::ConfigRulesViolation {
+                                    break_transitive(
+                                        db,
+                                        dependent,
+                                        id,
+                                        DependencyError::ConfigUnsatisfied {
+                                            error: format!("{}", e),
+                                        },
+                                        breakages,
+                                    )
+                                    .await?;
+                                } else {
+                                    return Err(e);
+                                }
+                            }
+                        }
+                    }
+                }
+                heal_all_dependents_transitive(ctx, db, id).await?;
+            }
+        }
+
+        if let Some(signal) = signal {
+            match ctx.managers.get(&(id.clone(), version.clone())).await {
+                None => {
+                    // in theory this should never happen, which indicates this function should be moved behind the
+                    // Manager interface
+                    return Err(Error::new(
+                        eyre!("Manager Not Found for package being configured"),
+                        crate::ErrorKind::Incoherent,
+                    ));
+                }
+                Some(m) => {
+                    m.signal(&signal).await?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+    .boxed()
+}

backend/src/config/util.rs

@@ -0,0 +1,368 @@
+use std::borrow::Cow;
+use std::ops::{Bound, RangeBounds, RangeInclusive};
+
+use rand::distributions::Distribution;
+use rand::Rng;
+use serde_json::Value;
+
+use super::Config;
+
+pub const STATIC_NULL: Value = Value::Null;
+
+#[derive(Clone, Debug)]
+pub struct CharSet(pub Vec<(RangeInclusive<char>, usize)>, usize);
+impl CharSet {
+    pub fn contains(&self, c: &char) -> bool {
+        self.0.iter().any(|r| r.0.contains(c))
+    }
+    pub fn gen<R: Rng>(&self, rng: &mut R) -> char {
+        let mut idx = rng.gen_range(0, self.1);
+        for r in &self.0 {
+            if idx < r.1 {
+                return std::convert::TryFrom::try_from(
+                    rand::distributions::Uniform::new_inclusive(
+                        u32::from(*r.0.start()),
+                        u32::from(*r.0.end()),
+                    )
+                    .sample(rng),
+                )
+                .unwrap();
+            } else {
+                idx -= r.1;
+            }
+        }
+        unreachable!()
+    }
+}
+impl Default for CharSet {
+    fn default() -> Self {
+        CharSet(vec![('!'..='~', 94)], 94)
+    }
+}
+impl<'de> serde::de::Deserialize<'de> for CharSet {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        let mut res = Vec::new();
+        let mut len = 0;
+        let mut a: Option<char> = None;
+        let mut b: Option<char> = None;
+        let mut in_range = false;
+        for c in s.chars() {
+            match c {
+                ',' => match (a, b, in_range) {
+                    (Some(start), Some(end), _) => {
+                        if !end.is_ascii() {
+                            return Err(serde::de::Error::custom("Invalid Character"));
+                        }
+                        if start >= end {
+                            return Err(serde::de::Error::custom("Invalid Bounds"));
+                        }
+                        let l = u32::from(end) - u32::from(start) + 1;
+                        res.push((start..=end, l as usize));
+                        len += l as usize;
+                        a = None;
+                        b = None;
+                        in_range = false;
+                    }
+                    (Some(start), None, false) => {
+                        len += 1;
+                        res.push((start..=start, 1));
+                        a = None;
+                    }
+                    (Some(_), None, true) => {
+                        b = Some(',');
+                    }
+                    (None, None, false) => {
+                        a = Some(',');
+                    }
+                    _ => {
+                        return Err(serde::de::Error::custom("Syntax Error"));
+                    }
+                },
+                '-' => {
+                    if a.is_none() {
+                        a = Some('-');
+                    } else if !in_range {
+                        in_range = true;
+                    } else if b.is_none() {
+                        b = Some('-')
+                    } else {
+                        return Err(serde::de::Error::custom("Syntax Error"));
+                    }
+                }
+                _ => {
+                    if a.is_none() {
+                        a = Some(c);
+                    } else if in_range && b.is_none() {
+                        b = Some(c);
+                    } else {
+                        return Err(serde::de::Error::custom("Syntax Error"));
+                    }
+                }
+            }
+        }
+        match (a, b) {
+            (Some(start), Some(end)) => {
+                if !end.is_ascii() {
+                    return Err(serde::de::Error::custom("Invalid Character"));
+                }
+                if start >= end {
+                    return Err(serde::de::Error::custom("Invalid Bounds"));
+                }
+                let l = u32::from(end) - u32::from(start) + 1;
+                res.push((start..=end, l as usize));
+                len += l as usize;
+            }
+            (Some(c), None) => {
+                len += 1;
+                res.push((c..=c, 1));
+            }
+            _ => (),
+        }
+
+        Ok(CharSet(res, len))
+    }
+}
+impl serde::ser::Serialize for CharSet {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        <&str>::serialize(
+            &self
+                .0
+                .iter()
+                .map(|r| match r.1 {
+                    1 => format!("{}", r.0.start()),
+                    _ => format!("{}-{}", r.0.start(), r.0.end()),
+                })
+                .collect::<Vec<_>>()
+                .join(",")
+                .as_str(),
+            serializer,
+        )
+    }
+}
+
+pub mod serde_regex {
+    use regex::Regex;
+    use serde::*;
+
+    pub fn serialize<S>(regex: &Regex, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        <&str>::serialize(&regex.as_str(), serializer)
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Regex, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        Regex::new(&s).map_err(|e| de::Error::custom(e))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct NumRange<T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd>(
+    pub (Bound<T>, Bound<T>),
+);
+impl<T> std::ops::Deref for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+{
+    type Target = (Bound<T>, Bound<T>);
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<'de, T> serde::de::Deserialize<'de> for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+    <T as std::str::FromStr>::Err: std::fmt::Display,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        let mut split = s.split(",");
+        let start = split
+            .next()
+            .map(|s| match s.get(..1) {
+                Some("(") => match s.get(1..2) {
+                    Some("*") => Ok(Bound::Unbounded),
+                    _ => s[1..]
+                        .trim()
+                        .parse()
+                        .map(Bound::Excluded)
+                        .map_err(|e| serde::de::Error::custom(e)),
+                },
+                Some("[") => s[1..]
+                    .trim()
+                    .parse()
+                    .map(Bound::Included)
+                    .map_err(|e| serde::de::Error::custom(e)),
+                _ => Err(serde::de::Error::custom(format!(
+                    "Could not parse left bound: {}",
+                    s
+                ))),
+            })
+            .transpose()?
+            .unwrap();
+        let end = split
+            .next()
+            .map(|s| match s.get(s.len() - 1..) {
+                Some(")") => match s.get(s.len() - 2..s.len() - 1) {
+                    Some("*") => Ok(Bound::Unbounded),
+                    _ => s[..s.len() - 1]
+                        .trim()
+                        .parse()
+                        .map(Bound::Excluded)
+                        .map_err(|e| serde::de::Error::custom(e)),
+                },
+                Some("]") => s[..s.len() - 1]
+                    .trim()
+                    .parse()
+                    .map(Bound::Included)
+                    .map_err(|e| serde::de::Error::custom(e)),
+                _ => Err(serde::de::Error::custom(format!(
+                    "Could not parse right bound: {}",
+                    s
+                ))),
+            })
+            .transpose()?
+            .unwrap_or(Bound::Unbounded);
+
+        Ok(NumRange((start, end)))
+    }
+}
+impl<T> std::fmt::Display for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.start_bound() {
+            Bound::Excluded(n) => write!(f, "({},", n)?,
+            Bound::Included(n) => write!(f, "[{},", n)?,
+            Bound::Unbounded => write!(f, "(*,")?,
+        };
+        match self.end_bound() {
+            Bound::Excluded(n) => write!(f, "{})", n),
+            Bound::Included(n) => write!(f, "{}]", n),
+            Bound::Unbounded => write!(f, "*)"),
+        }
+    }
+}
+impl<T> serde::ser::Serialize for NumRange<T>
+where
+    T: std::str::FromStr + std::fmt::Display + std::cmp::PartialOrd,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        <&str>::serialize(&format!("{}", self).as_str(), serializer)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum UniqueBy {
+    Any(Vec<UniqueBy>),
+    All(Vec<UniqueBy>),
+    Exactly(String),
+    NotUnique,
+}
+impl UniqueBy {
+    pub fn eq(&self, lhs: &Config, rhs: &Config) -> bool {
+        match self {
+            UniqueBy::Any(any) => any.iter().any(|u| u.eq(lhs, rhs)),
+            UniqueBy::All(all) => all.iter().all(|u| u.eq(lhs, rhs)),
+            UniqueBy::Exactly(key) => lhs.get(key) == rhs.get(key),
+            UniqueBy::NotUnique => false,
+        }
+    }
+}
+impl Default for UniqueBy {
+    fn default() -> Self {
+        UniqueBy::NotUnique
+    }
+}
+impl<'de> serde::de::Deserialize<'de> for UniqueBy {
+    fn deserialize<D: serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = UniqueBy;
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "a key, an \"any\" object, or an \"all\" object")
+            }
+            fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
+                Ok(UniqueBy::Exactly(v.to_owned()))
+            }
+            fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
+                Ok(UniqueBy::Exactly(v))
+            }
+            fn visit_map<A: serde::de::MapAccess<'de>>(
+                self,
+                mut map: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut variant = None;
+                while let Some(key) = map.next_key::<Cow<str>>()? {
+                    match key.as_ref() {
+                        "any" => {
+                            return Ok(UniqueBy::Any(map.next_value()?));
+                        }
+                        "all" => {
+                            return Ok(UniqueBy::All(map.next_value()?));
+                        }
+                        _ => {
+                            variant = Some(key);
+                        }
+                    }
+                }
+                Err(serde::de::Error::unknown_variant(
+                    variant.unwrap_or_default().as_ref(),
+                    &["any", "all"],
+                ))
+            }
+            fn visit_unit<E: serde::de::Error>(self) -> Result<Self::Value, E> {
+                Ok(UniqueBy::NotUnique)
+            }
+            fn visit_none<E: serde::de::Error>(self) -> Result<Self::Value, E> {
+                Ok(UniqueBy::NotUnique)
+            }
+        }
+        deserializer.deserialize_any(Visitor)
+    }
+}
+
+impl serde::ser::Serialize for UniqueBy {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        use serde::ser::SerializeMap;
+
+        match self {
+            UniqueBy::Any(any) => {
+                let mut map = serializer.serialize_map(Some(1))?;
+                map.serialize_key("any")?;
+                map.serialize_value(any)?;
+                map.end()
+            }
+            UniqueBy::All(all) => {
+                let mut map = serializer.serialize_map(Some(1))?;
+                map.serialize_key("all")?;
+                map.serialize_value(all)?;
+                map.end()
+            }
+            UniqueBy::Exactly(key) => serializer.serialize_str(key),
+            UniqueBy::NotUnique => serializer.serialize_unit(),
+        }
+    }
+}