198 lines
6.4 KiB
Rust
198 lines
6.4 KiB
Rust
use std::fmt::{Display, Formatter};
|
|
use std::fs::{File, OpenOptions};
|
|
use std::io::{ErrorKind, Write};
|
|
use std::net::IpAddr;
|
|
use std::num::{NonZeroU16, NonZeroU64};
|
|
use std::path::PathBuf;
|
|
use std::str::FromStr;
|
|
use std::sync::atomic::AtomicBool;
|
|
|
|
use clap::{crate_authors, crate_description, crate_version, Clap};
|
|
use serde::{Deserialize, Serialize};
|
|
use url::Url;
|
|
|
|
use crate::units::{Kilobits, Mebibytes, Port};
|
|
|
|
// Validate tokens is an atomic because it's faster than locking on rwlock.
|
|
pub static VALIDATE_TOKENS: AtomicBool = AtomicBool::new(false);
|
|
// We use an atomic here because it's better for us to not pass the config
|
|
// everywhere.
|
|
pub static SEND_SERVER_VERSION: AtomicBool = AtomicBool::new(false);
|
|
|
|
pub static OFFLINE_MODE: AtomicBool = AtomicBool::new(false);
|
|
|
|
pub fn load_config() -> Config {
|
|
const CONFIG_PATH: &str = "./settings.yaml";
|
|
let config_file: Result<YamlArgs, _> = match File::open(CONFIG_PATH) {
|
|
Ok(file) => serde_yaml::from_reader(file),
|
|
Err(e) if e.kind() == ErrorKind::NotFound => {
|
|
let mut file = OpenOptions::new()
|
|
.write(true)
|
|
.create_new(true)
|
|
.open(CONFIG_PATH)
|
|
.unwrap();
|
|
|
|
file.write_all(include_bytes!("../settings.sample.yaml"))
|
|
.unwrap();
|
|
|
|
return load_config();
|
|
}
|
|
_ => panic!(),
|
|
};
|
|
|
|
todo!()
|
|
}
|
|
|
|
pub struct Config {}
|
|
|
|
#[derive(Deserialize)]
|
|
struct YamlArgs {
|
|
// Naming is legacy
|
|
max_cache_size_in_mebibytes: Mebibytes,
|
|
server_settings: YamlServerSettings,
|
|
// This implementation custom options
|
|
extended_options: YamlExtendedOptions,
|
|
}
|
|
|
|
// Naming is legacy
|
|
#[derive(Deserialize)]
|
|
struct YamlServerSettings {
|
|
secret: ClientSecret,
|
|
port: Port,
|
|
external_max_kilobits_per_second: Kilobits,
|
|
external_port: Option<Port>,
|
|
graceful_shutdown_wait_seconds: Option<NonZeroU16>,
|
|
hostname: Option<IpAddr>,
|
|
external_ip: Option<IpAddr>,
|
|
}
|
|
|
|
// this intentionally does not implement display or debug
|
|
#[derive(Deserialize, Serialize)]
|
|
struct ClientSecret(String);
|
|
|
|
#[derive(Deserialize)]
|
|
struct YamlExtendedOptions {
|
|
memory_quota: Option<NonZeroU64>,
|
|
#[serde(default)]
|
|
send_server_string: bool,
|
|
#[serde(default)]
|
|
cache_type: YamlCacheType,
|
|
#[serde(default)]
|
|
ephemeral_disk_encryption: bool,
|
|
#[serde(default)]
|
|
enable_metrics: bool,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
enum YamlCacheType {
|
|
OnDisk,
|
|
Lru,
|
|
Lfu,
|
|
}
|
|
|
|
impl Default for YamlCacheType {
|
|
fn default() -> Self {
|
|
Self::OnDisk
|
|
}
|
|
}
|
|
|
|
#[derive(Clap, Clone)]
|
|
#[clap(version = crate_version!(), author = crate_authors!(), about = crate_description!())]
|
|
pub struct CliArgs {
|
|
/// The port to listen on.
|
|
#[clap(short, long, default_value = "42069")]
|
|
pub port: Port,
|
|
/// How large, in bytes, the in-memory cache should be. Note that this does
|
|
/// not include runtime memory usage.
|
|
#[clap(long, conflicts_with = "low-memory")]
|
|
pub memory_quota: Option<NonZeroU64>,
|
|
/// How large, in bytes, the on-disk cache should be. Note that actual
|
|
/// values may be larger for metadata information.
|
|
#[clap(long)]
|
|
pub disk_quota: u64,
|
|
/// Sets the location of the disk cache.
|
|
#[clap(long, default_value = "./cache")]
|
|
pub cache_path: PathBuf,
|
|
/// The network speed to advertise to Mangadex@Home control server.
|
|
#[clap(long)]
|
|
pub network_speed: NonZeroU64,
|
|
/// Whether or not to provide the Server HTTP header to clients. This is
|
|
/// useful for debugging, but is generally not recommended for security
|
|
/// reasons.
|
|
#[clap(long, takes_value = false)]
|
|
pub send_server_string: bool,
|
|
/// Changes the caching behavior to avoid buffering images in memory, and
|
|
/// instead use the filesystem as the buffer backing. This is useful for
|
|
/// clients in low (< 1GB) RAM environments.
|
|
#[clap(short, long, conflicts_with("memory-quota"), takes_value = false)]
|
|
pub low_memory: bool,
|
|
/// Changes verbosity. Default verbosity is INFO, while increasing counts of
|
|
/// verbose flags increases the verbosity to DEBUG and TRACE, respectively.
|
|
#[clap(short, long, parse(from_occurrences))]
|
|
pub verbose: usize,
|
|
/// Changes verbosity. Default verbosity is INFO, while increasing counts of
|
|
/// quiet flags decreases the verbosity to WARN, ERROR, and no logs,
|
|
/// respectively.
|
|
#[clap(short, long, parse(from_occurrences), conflicts_with = "verbose")]
|
|
pub quiet: usize,
|
|
#[clap(short = 'Z', long)]
|
|
pub unstable_options: Vec<UnstableOptions>,
|
|
#[clap(long)]
|
|
pub override_upstream: Option<Url>,
|
|
/// Enables ephemeral disk encryption. Items written to disk are first
|
|
/// encrypted with a key generated at runtime. There are implications to
|
|
/// performance, privacy, and usability with this flag enabled.
|
|
#[clap(short, long)]
|
|
pub ephemeral_disk_encryption: bool,
|
|
#[clap(short, long)]
|
|
pub config_path: Option<PathBuf>,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum UnstableOptions {
|
|
/// Overrides the upstream URL to fetch images from. Don't use this unless
|
|
/// you know what you're dealing with.
|
|
OverrideUpstream,
|
|
|
|
/// Use an LFU implementation for the in-memory cache instead of the default
|
|
/// LRU implementation.
|
|
UseLfu,
|
|
|
|
/// Disables token validation. Don't use this unless you know the
|
|
/// ramifications of this command.
|
|
DisableTokenValidation,
|
|
|
|
/// Tries to run without communication to MangaDex.
|
|
OfflineMode,
|
|
|
|
/// Serves HTTP in plaintext
|
|
DisableTls,
|
|
}
|
|
|
|
impl FromStr for UnstableOptions {
|
|
type Err = String;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"override-upstream" => Ok(Self::OverrideUpstream),
|
|
"use-lfu" => Ok(Self::UseLfu),
|
|
"disable-token-validation" => Ok(Self::DisableTokenValidation),
|
|
"offline-mode" => Ok(Self::OfflineMode),
|
|
"disable-tls" => Ok(Self::DisableTls),
|
|
_ => Err(format!("Unknown unstable option '{}'", s)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for UnstableOptions {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::OverrideUpstream => write!(f, "override-upstream"),
|
|
Self::UseLfu => write!(f, "use-lfu"),
|
|
Self::DisableTokenValidation => write!(f, "disable-token-validation"),
|
|
Self::OfflineMode => write!(f, "offline-mode"),
|
|
Self::DisableTls => write!(f, "disable-tls"),
|
|
}
|
|
}
|
|
}
|