fishctl/src/command/config.rs

//! `config` subcommand

mod update;
mod validate;

use crate::config::{Revision, CLIENT_CONFIG_PATH, OLD_CONFIG_PATH, SERVER_CONFIG_PATH};
use clap::Subcommand;
use serde::Deserialize;
use std::{fs, io::Read, path::Path};

#[derive(Subcommand)]
pub(crate) enum Commands {
    /// Convert old config files to the new format
    Update { revision: Option<Revision> },
    /// Validate the config files
    Validate,
}

/// Errors that can happen in `config` subcommand
#[derive(thiserror::Error, Debug)]
pub(crate) enum ConfigError {
    #[error(transparent)]
    Update(#[from] update::UpdateError),
    #[error(transparent)]
    Validate(#[from] validate::ValidationError),
}

#[derive(thiserror::Error, Debug)]
pub(crate) enum RevisionCheckError {
    #[error("failed to determine the current config revision ({0})")]
    UnknownRevision(&'static str),
    #[error(transparent)]
    InvalidConfig(#[from] toml::de::Error),
    #[error(transparent)]
    ReadFile(#[from] std::io::Error),
}

fn next_revision() -> Result<Option<Revision>, RevisionCheckError> {
    let old_config_exists = Path::new(OLD_CONFIG_PATH).is_file();
    let server_config_exists = Path::new(SERVER_CONFIG_PATH).is_file();
    let client_config_exists = Path::new(CLIENT_CONFIG_PATH).is_file();

    if server_config_exists && !client_config_exists {
        return Err(RevisionCheckError::UnknownRevision(
            "client config file does not exist",
        ));
    }
    if !server_config_exists && client_config_exists {
        return Err(RevisionCheckError::UnknownRevision(
            "server config file does not exist",
        ));
    }
    if !old_config_exists && !server_config_exists && !client_config_exists {
        return Err(RevisionCheckError::UnknownRevision(
            "config file does not exist",
        ));
    }

    if old_config_exists && !server_config_exists && !client_config_exists {
        return Ok(Some(Revision::V1));
    }

    #[derive(Deserialize)]
    struct Config {
        config_revision: Revision,
    }

    let mut buffer = String::new();

    let mut server_toml = fs::File::open(SERVER_CONFIG_PATH)?;
    server_toml.read_to_string(&mut buffer)?;

    let server_config_revision = toml::from_str::<Config>(&buffer)?.config_revision;

    let mut client_toml = fs::File::open(CLIENT_CONFIG_PATH)?;
    client_toml.read_to_string(&mut buffer)?;

    let client_config_revision = toml::from_str::<Config>(&buffer)?.config_revision;

    if server_config_revision != client_config_revision {
        return Err(RevisionCheckError::UnknownRevision(
            "server config revision and client config revision are different",
        ));
    }

    let next_revision = match server_config_revision {
        Revision::V1 => None,
    };

    Ok(next_revision)
}

pub(crate) async fn run(command: Commands) -> Result<(), ConfigError> {
    match command {
        Commands::Update { revision } => update::run(revision).await?,
        Commands::Validate => validate::run()?,
    }

    Ok(())
}