356 lines
10 KiB
Rust
356 lines
10 KiB
Rust
use std::path::PathBuf;
|
|
|
|
use serde::Deserialize;
|
|
|
|
use crate::log::Level;
|
|
|
|
// 全局配置：只从 TOML 文件读，缺项回退内置默认值；
|
|
// 存储相关分区由本模块解析校验，其它层的分区一概不碰。
|
|
|
|
/// 配置文件名
|
|
pub const CONFIG_FILE_NAME: &str = "settings.toml";
|
|
/// 配置目录名（随系统惯例放在用户配置目录下）
|
|
pub const APP_DIR_NAME: &str = "ChuSQL";
|
|
/// Unix 下的数据目录名（XDG 惯例小写，跟安装脚本的默认安装目录一致）
|
|
pub const UNIX_APP_DIR_NAME: &str = "chusql";
|
|
/// 数据子目录名
|
|
pub const DATA_DIR_NAME: &str = "data";
|
|
|
|
pub const DEFAULT_POOL_SIZE: usize = 1024;
|
|
pub const DEFAULT_PAGE_SIZE: usize = 4096;
|
|
pub const DEFAULT_BTREE_ORDER: usize = 4;
|
|
pub const DEFAULT_LOG_LEVEL: &str = "info";
|
|
/// 默认日志输出目录（相对启动目录）
|
|
pub const DEFAULT_LOG_FILES: &str = "./logs";
|
|
|
|
const MIN_PAGE_SIZE: usize = 512;
|
|
const MAX_PAGE_SIZE: usize = 65536;
|
|
const MIN_BTREE_ORDER: usize = 3;
|
|
|
|
/// 默认配置文件路径（按平台惯例）
|
|
pub fn default_config_path() -> PathBuf {
|
|
#[cfg(windows)]
|
|
{
|
|
let appdata = std::env::var_os("APPDATA").filter(|v| !v.is_empty());
|
|
if let Some(appdata) = appdata {
|
|
return PathBuf::from(appdata).join(APP_DIR_NAME).join(CONFIG_FILE_NAME);
|
|
}
|
|
}
|
|
#[cfg(not(windows))]
|
|
{
|
|
let xdg = std::env::var_os("XDG_CONFIG_HOME").filter(|v| !v.is_empty());
|
|
if let Some(xdg) = xdg {
|
|
return PathBuf::from(xdg).join(APP_DIR_NAME).join(CONFIG_FILE_NAME);
|
|
}
|
|
let home = std::env::var_os("HOME").filter(|v| !v.is_empty());
|
|
if let Some(home) = home {
|
|
return PathBuf::from(home)
|
|
.join(".config")
|
|
.join(APP_DIR_NAME)
|
|
.join(CONFIG_FILE_NAME);
|
|
}
|
|
}
|
|
PathBuf::from(APP_DIR_NAME).join(CONFIG_FILE_NAME)
|
|
}
|
|
|
|
/// Windows 默认数据目录
|
|
#[cfg(windows)]
|
|
pub fn default_data_dir() -> PathBuf {
|
|
let local = std::env::var_os("LOCALAPPDATA").filter(|v| !v.is_empty());
|
|
if let Some(local) = local {
|
|
return PathBuf::from(local).join(APP_DIR_NAME).join(DATA_DIR_NAME);
|
|
}
|
|
let roaming = std::env::var_os("APPDATA").filter(|v| !v.is_empty());
|
|
if let Some(roaming) = roaming {
|
|
return PathBuf::from(roaming).join(APP_DIR_NAME).join(DATA_DIR_NAME);
|
|
}
|
|
PathBuf::from(APP_DIR_NAME).join(DATA_DIR_NAME)
|
|
}
|
|
|
|
/// Unix 默认数据目录（XDG 惯例）
|
|
#[cfg(not(windows))]
|
|
pub fn default_data_dir() -> PathBuf {
|
|
let xdg = std::env::var_os("XDG_DATA_HOME").filter(|v| !v.is_empty());
|
|
if let Some(xdg) = xdg {
|
|
return PathBuf::from(xdg)
|
|
.join(UNIX_APP_DIR_NAME)
|
|
.join(DATA_DIR_NAME);
|
|
}
|
|
let home = std::env::var_os("HOME").filter(|v| !v.is_empty());
|
|
if let Some(home) = home {
|
|
return PathBuf::from(home)
|
|
.join(".local")
|
|
.join("share")
|
|
.join(UNIX_APP_DIR_NAME)
|
|
.join(DATA_DIR_NAME);
|
|
}
|
|
PathBuf::from(UNIX_APP_DIR_NAME).join(DATA_DIR_NAME)
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct Config {
|
|
pub page_size: usize,
|
|
pub btree_order: usize,
|
|
pub pool_size: usize,
|
|
pub data_dir: PathBuf,
|
|
pub log_files: PathBuf,
|
|
pub log_level: Level,
|
|
}
|
|
|
|
impl Default for Config {
|
|
/// 内置默认配置
|
|
fn default() -> Self {
|
|
Config {
|
|
page_size: DEFAULT_PAGE_SIZE,
|
|
btree_order: DEFAULT_BTREE_ORDER,
|
|
pool_size: DEFAULT_POOL_SIZE,
|
|
data_dir: default_data_dir(),
|
|
log_files: PathBuf::from(DEFAULT_LOG_FILES),
|
|
log_level: Level::Info,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum Origin {
|
|
Default,
|
|
File(PathBuf),
|
|
}
|
|
|
|
impl Origin {
|
|
/// 来源的文案
|
|
pub fn describe(&self) -> String {
|
|
match self {
|
|
Origin::Default => "default".to_string(),
|
|
Origin::File(p) => format!("file {}", p.display()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Loaded {
|
|
pub config: Config,
|
|
pub config_path: Option<PathBuf>,
|
|
pub origins: Vec<(&'static str, String, Origin)>,
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
struct FileConfig {
|
|
page: Option<FilePage>,
|
|
btree: Option<FileBtree>,
|
|
buffer: Option<FileBuffer>,
|
|
storage: Option<FileStorage>,
|
|
log: Option<FileLog>,
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct FileBuffer {
|
|
pool_size: Option<usize>,
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct FilePage {
|
|
size: Option<usize>,
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct FileBtree {
|
|
order: Option<usize>,
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct FileStorage {
|
|
data_dir: Option<String>,
|
|
log_files: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct FileLog {
|
|
level: Option<String>,
|
|
}
|
|
|
|
/// 加载配置：显式路径优先，其次默认位置
|
|
pub fn load(explicit: Option<&str>) -> Result<Loaded, String> {
|
|
let explicit = explicit.map(str::trim).filter(|p| !p.is_empty());
|
|
let path = match explicit {
|
|
Some(p) => {
|
|
let p = PathBuf::from(p);
|
|
if !p.is_file() {
|
|
return Err(format!("config file not found: {}", p.display()));
|
|
}
|
|
Some(p)
|
|
}
|
|
None => {
|
|
let p = default_config_path();
|
|
if p.is_file() { Some(p) } else { None }
|
|
}
|
|
};
|
|
let text = match &path {
|
|
Some(p) => Some(
|
|
std::fs::read_to_string(p)
|
|
.map_err(|e| format!("cannot read config file {}: {}", p.display(), e))?,
|
|
),
|
|
None => None,
|
|
};
|
|
resolve(text.as_deref(), path)
|
|
}
|
|
|
|
/// 解析文本：文件 -> 默认
|
|
pub fn resolve(text: Option<&str>, path: Option<PathBuf>) -> Result<Loaded, String> {
|
|
let file: FileConfig = match text {
|
|
None => FileConfig::default(),
|
|
Some(t) => toml::from_str(t).map_err(|e| match &path {
|
|
Some(p) => format!("bad config file {}: {}", p.display(), e),
|
|
None => format!("bad config: {}", e),
|
|
})?,
|
|
};
|
|
|
|
let file_origin = Origin::File(
|
|
path.clone().unwrap_or_else(default_config_path),
|
|
);
|
|
|
|
let (page_size, page_origin) = pick(
|
|
file.page.and_then(|p| p.size),
|
|
DEFAULT_PAGE_SIZE,
|
|
&file_origin,
|
|
);
|
|
let (btree_order, order_origin) = pick(
|
|
file.btree.and_then(|b| b.order),
|
|
DEFAULT_BTREE_ORDER,
|
|
&file_origin,
|
|
);
|
|
let (pool_size, pool_origin) = pick(
|
|
file.buffer.and_then(|b| b.pool_size),
|
|
DEFAULT_POOL_SIZE,
|
|
&file_origin,
|
|
);
|
|
let (data_dir, dir_origin) = pick(
|
|
file.storage.as_ref().and_then(|s| s.data_dir.clone()),
|
|
default_data_dir().to_string_lossy().into_owned(),
|
|
&file_origin,
|
|
);
|
|
let (log_files, log_files_origin) = pick(
|
|
file.storage.as_ref().and_then(|s| s.log_files.clone()),
|
|
DEFAULT_LOG_FILES.to_string(),
|
|
&file_origin,
|
|
);
|
|
// 管名已经没有了：存储不再是独立进程，管道/套接字那一层随 FFI 一起删掉
|
|
let (log_level, log_origin) = pick(
|
|
file.log.and_then(|l| l.level),
|
|
DEFAULT_LOG_LEVEL.to_string(),
|
|
&file_origin,
|
|
);
|
|
|
|
let data_dir = data_dir.trim().to_string();
|
|
let log_files = log_files.trim().to_string();
|
|
let log_level = log_level.trim().to_string();
|
|
|
|
let log_level = Level::parse(&log_level)
|
|
.ok_or_else(|| format!("log.level is not one of off/error/warn/info/debug: {}", log_level))?;
|
|
|
|
if data_dir.is_empty() {
|
|
return Err("storage.data_dir must not be empty".to_string());
|
|
}
|
|
if log_files.is_empty() {
|
|
return Err("storage.log_files must not be empty".to_string());
|
|
}
|
|
validate_layout(page_size, btree_order)?;
|
|
if pool_size == 0 {
|
|
return Err("buffer.pool_size must be at least 1".to_string());
|
|
}
|
|
let origins = vec![
|
|
("page.size", page_size.to_string(), page_origin),
|
|
("btree.order", btree_order.to_string(), order_origin),
|
|
("buffer.pool_size", pool_size.to_string(), pool_origin),
|
|
("storage.data_dir", data_dir.clone(), dir_origin),
|
|
("storage.log_files", log_files.clone(), log_files_origin),
|
|
("log.level", log_level.name().to_string(), log_origin),
|
|
];
|
|
|
|
Ok(Loaded {
|
|
config: Config {
|
|
page_size,
|
|
btree_order,
|
|
pool_size,
|
|
data_dir: PathBuf::from(data_dir),
|
|
log_files: PathBuf::from(log_files),
|
|
log_level,
|
|
},
|
|
config_path: if text.is_some() { path } else { None },
|
|
origins,
|
|
})
|
|
}
|
|
|
|
/// 取一项：文件 -> 默认
|
|
fn pick<T>(file_value: Option<T>, default: T, file_origin: &Origin) -> (T, Origin) {
|
|
if let Some(value) = file_value {
|
|
return (value, file_origin.clone());
|
|
}
|
|
(default, Origin::Default)
|
|
}
|
|
|
|
/// 检查选项是否自洽
|
|
fn validate_layout(page_size: usize, btree_order: usize) -> Result<(), String> {
|
|
if !(MIN_PAGE_SIZE..=MAX_PAGE_SIZE).contains(&page_size) || !page_size.is_power_of_two() {
|
|
return Err(format!(
|
|
"page.size must be a power of two between {} and {}, got {}",
|
|
MIN_PAGE_SIZE, MAX_PAGE_SIZE, page_size
|
|
));
|
|
}
|
|
if btree_order < MIN_BTREE_ORDER {
|
|
return Err(format!(
|
|
"btree.order must be at least {}, got {}",
|
|
MIN_BTREE_ORDER, btree_order
|
|
));
|
|
}
|
|
if !crate::btree::fits_in_page(page_size, btree_order) {
|
|
return Err(format!(
|
|
"btree.order {} does not fit in a {}-byte page (max {})",
|
|
btree_order,
|
|
page_size,
|
|
crate::btree::max_order(page_size)
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
/// 别的层的分区不能被当成错误
|
|
#[test]
|
|
fn ignores_sections_owned_by_other_layers() {
|
|
let text = r#"
|
|
[page]
|
|
size = 8192
|
|
|
|
[storage]
|
|
data_dir = "../data"
|
|
|
|
[server]
|
|
listen_host = "127.0.0.1"
|
|
port = 7777
|
|
max_message = 1048576
|
|
|
|
[web]
|
|
port = 7778
|
|
"#;
|
|
let loaded = resolve(Some(text), Some(PathBuf::from("settings.toml"))).unwrap();
|
|
assert_eq!(loaded.config.page_size, 8192);
|
|
assert_eq!(loaded.config.data_dir, PathBuf::from("../data"));
|
|
}
|
|
|
|
/// 自己分区里的拼写错误仍然要报错
|
|
#[test]
|
|
fn still_rejects_typos_inside_its_own_sections() {
|
|
let text = "[page]\npage_size = 8192\n";
|
|
assert!(resolve(Some(text), None).is_err());
|
|
}
|
|
}
|