大改，整理项目结构，完成rust ffi调用，写好tcp接口

chusql-core/storage/src/config.rs

@@ -0,0 +1,340 @@
+use std::path::PathBuf;
+
+use serde::Deserialize;
+
+use crate::log::Level;
+
+// 全局配置：只从 TOML 文件读，缺项回退内置默认值；
+// 存储相关分区由本模块解析校验，其它层的分区一概不碰。
+
+/// 配置文件名
+pub const CONFIG_FILE_NAME: &str = "chusql.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";
+
+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_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_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>,
+}
+
+#[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,
+    );
+    // 管名已经没有了：存储不再是独立进程，管道/套接字那一层随 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_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());
+    }
+    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),
+        ("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_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]
+host = "127.0.0.1"
+port = 7777
+max_message = 1048576
+
+[web]
+port = 7778
+user = "root"
+"#;
+        let loaded = resolve(Some(text), Some(PathBuf::from("chusql.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());
+    }
+}