Rust项目实战:配置文件读取

写在前面

在阅读本文之前，你至少要掌握 Rust 相关基础知识。 包括但不限于 struct trait 异步编程 错误处理等。
通过阅读本文,你将了解。

• tokio
• etcd
• lazy_static
• serde

这些库的使用。

以及，Rust异步编程 JOSN/YAML 序列化/反序列化 Rust编程范式 可分离设计 等思想。

抓好方向盘，准备发车了！

项目背景

在平时开发中，我们难免使用第三方工具，以及中间件。 例如 数据库 消息队列 各种中间件 等。 平时我们为了方便起见，通常将这些 配置文件 作为变量存储起来。 对于个人小的项目来说，这样做无可厚非。 但是针对企业开发场景下: 我们可能要使用很多的中间件。 例如: mongodb postgresql redis rabbitmq 等各种数据库和中间件。 如果我们将这些配置项，写入到程序中去。是一件比较危险的事情。 因此 如何合理的管理配置文件，是一件非常重要的事情。 那我们该如何管理这些配置文件呢？

在分布式架构中，我们通常有一个叫做 配置中心 的服务来管理我们这些配置文件。 在这里为了方便起见，我采用ETCD 作为 配置中心。

ETCD 是什么？ (传送门)

组织项目结构

好的设计，不仅可以提高代码的可读性，同时也提升了程序的鲁棒性。 因此如何如何设计好一个系统是一件尤为重要的事情。

回归到我们的这个问题: 需求是将这些敏感的配置文件，抽离到配置中心去。 然后我们程序加载的时候从配置中心读取，防止配置文件在代码中泄露，从而尽可能的规避风险。

那么这里有两个问题： 选择哪个配置中心？ 从哪里读？

大家要知道现有的配置中心，不止ETCD一种，当然如果可以的话，你甚至可以将配置文件写到 web 服务中。 这样在需要配置文件的时候发送http/rpc 请求。然后我们再加载。

这里就是我们的切入点，我们要“照顾”不同的配置中心，那么系统的可扩展性就显得尤为重要。

其实从不同的配置中心中获取配置文件，他们有一个共同的特性。 就是 读 那么我们该如何让我们的系统适配不同的的配置中心呢？

这里学过OOP的小伙伴举手了，通过多态不就可以解决吗

非常好！ 多态是面向对象三大特性之一， 多态:指为不同数据类型的实体提供统一的接口。 在 Rust 中通过 trait 实现。

什么是多态? （传送门）

configurable.rs

#[async_trait]
pub trait Configurable {
    async fn config(&self) -> String;
}

这里我们创建了一个Configurable trait 其中提供了 一个 config 方法，用来读取配置。 因为考虑到一些耗时场景，我们这里使用了 async_trait。 Rust trait 本身是不支持 async 的。我们这里需要添加 cargo 依赖。

async-trait = "0.1.60"

这样我们的trait 方法就成为了异步方法。

实现 ETCDConfig

我们创建一个 结构体 叫做 ETCDConfig 并为其实现 Configurable trait。

pub struct ETCDConfig {
    uri: String,
}

impl ETCDConfig {
    pub fn new<T>(uri: T) -> Self
    where
        T: Into<String>,
    {
        Self { uri: uri.into() }
    }
}

impl Default for ETCDConfig {
    fn default() -> Self {
        ETCDConfig::new(ETCD_URL)
    }
}

#[async_trait]
impl Configurable for ETCDConfig {
    async fn config(&self) -> String {
        let config_key = "/xdai-config/xdai-session.yaml";
        let mut client = Client::connect([&self.uri], None)
            .await
            .expect("连接etcd失败");
        let resp = client.get(config_key, None).await.expect("读取配置失败");
        if let Some(kv) = resp.kvs().first() {
            return kv.value_str().unwrap().into();
        }
        "".into()
    }
}

乍一看 代码好多~
不要慌 我这里将详细解释 为什么这样写，以及这样写的目的。

• 首先我们创建了结构体，因为考虑到 etcd 地址原因 这里我们添加一个 uri 字段，用来存放 etcd 地址信息。

• 紧接着我们为该结构体实现了 new 方法。

  • 注意看这里 new 方法是一个泛型方法
  • 这是为了适配不同的数据类型
  • 然后 我们使用了 where 关键字 进行类型限制。
  • 要求 T 必须实现了 Into 这个trait。
  • 也就是说 这里传递进来的T对象必须满足 可转换成String。

• 接下来我们说这样的好处

  • Rust 中 “” 和 String 是两种完全不同的类型。
  • 但是他们之间可以相互转换。
  • 借助这个特性 我们做此约束。
  • 这样我们不关心传递进来的是什么对象或者字符串,只要他能转换成字符串我就接受。

• Rust 真是灵活！

  • 我们为该结构体实现了 default 方法。
  • 这样即便不传入任何数据我们也能保证程序正常运行。

• 最后我们实现了 Configurable

• 他返回一个String 代表我们从ETCD中读取的配置。

进行单元测试

mod test {
    use crate::etcd_config::{Configurable, ETCDConfig};

    #[tokio::test]
    pub async fn test_read() {
        let config = ETCDConfig::default();
        let cfg = config.config().await;
        println!("{}", cfg);
    }
}

实现 Config 配置类

#[derive(Debug, Serialize, Deserialize)]
pub struct Mongo {
    dsn: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Redis {
    dsn: String,
    password: Option<String>,
    db: usize,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Postgresql {
    dsn: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct RabbitMQ {
    dsn: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Config {
    pub mongo: Mongo,
    pub redis: Redis,
    pub postgresql: Postgresql,
    pub lapin: RabbitMQ,
}

这里就是一些简单的 结构体定义。 包含了 MongoDB Redis Postgresql Rabbitmq 这四个常用组件。

这里需要说明下结构体上面的 derive 宏。

• Debug 调试结构体参数时使用
• Serialize serde库 用于序列化结构体
• Deserialize serde库 用于反序列化结构体

这里说下 serde 是 Rust 一个 非常优秀的 序列化/反序列化库。

serde_yaml = "0.9.16"
serde = {version = "1.0.152",features=["derive"]}

实现 read 方法

impl Config {
    pub async fn read(cfg: impl Configurable) -> Result<Config, Error> {
        let buf = cfg.config().await;
        // TODO: 反序列化
        // TODO: 生成 config 实例
        return Ok(buf.into());
    }
}

这里我们 为 config 实现了一个 read 方法。注意这里的 read 方法并没有 &self。 也就是说我们需要通过 Config::read() 方式进行调用。

cfg 参数 我们做了个 静态转发。 要求这里的 cfg 必须实现 Configurable trait 这样 就能满足了我们多态的需求。
对于调用者而言：只需要实现 Configurable trait 无序关系read 内部实现。
对于read 方法而言： 只需要 调用实现了 config 的方法 无需关心这个对象是谁。

这真是一种非常巧妙的设计！！

然后我们函数返回类型是一个 Result 类型。 Result 类型是 Rust 内置的类型。他是一个枚举类型，函数签名如下。

pub enum Result<T, E> {
    /// Contains the success value
    #[lang = "Ok"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Ok(#[stable(feature = "rust1", since = "1.0.0")] T),

    /// Contains the error value
    #[lang = "Err"]
    #[stable(feature = "rust1", since = "1.0.0")]
    Err(#[stable(feature = "rust1", since = "1.0.0")] E),
}

千万不要被这一大串吓到。 其实他只是声明了两个枚举而已。 Ok 代表成功 Err 代表失败。

这里不得不提，Rust错误设计真的巧妙而又优雅。

比某些 if err != nil 语言要好太多。

hhh~ 又扯远了

回到我们的代码，函数起签名就是如果代码没有出现错误那么返回一个Ok 其中包含我们的 Config，否则返回 Error 包含错误信息。

注意看！ 这里的 into方法

我们前面知道 config 函数签名返回的是一个 String 类型 他是怎么变成 Config 类型的呢？

我们接着往下看代码

impl From<String> for Config {
    fn from(e: String) -> Self {
        serde_yaml::from_str(e.as_str()).expect("序列化失败")
    }
}

唔~ 原来如此。 不禁感叹 Rust 优美的语言哲学。 通过 From<String> trait 我们就实现了 从 String 到Config类型的转换。
然后我们通过 serde_yaml 成功将 字符串 反序列化为 我们的Config 对象。

然后我们来简单梳理下：

• 通过 Config::read 来读取配置项
• cfg 参数从何而来？
  • 实现了 Configurable trait 所有对象
  • 这里可以是 本地文件、网络配置、配置中心、数据库
  • 无需关心内部实现。只需要调用 config 方法 读取我们想要的配置文件。
• 如何反序列化对象？
  • 通过 serde derive 宏标记 要序列化的 字段
  • serde_yaml::from_str() 来讲文本反序列化成对象
• 如何将文本转换成对象？
  • 为 Config 实现 From trait 即可。

单元测试

这里我实现一个 本地配置类。

struct LocalConfig;

#[async_trait]
impl Configurable for LocalConfig{
    async fn config(&self)->String{
        fs::read_to_string("./cfg.yaml").unwrap()
    }
}

#[cfg(test)]
mod test{

    #[tokio::test]
    pub async fn test() {
        enum PropType {
            Local,
            ETCD,
        }

        let mode = PropType::Local;

        let cfg = {
            match mode {
                PropType::Local => Config::read(LocalConfig::default()).await.unwrap(),
                PropType::ETCD => Config::read(ETCDConfig::default()).await.unwrap(),
            }
        };
        dbg!(&cfg);
    }
}

最后通过一个枚举类，来选择不同的配置文件。

输出结果如下:

[src/config.rs:92] &cfg = Config {
    mongo: Mongo {
        dsn: "mongo",
    },
    redis: Redis {
        dsn: "1123213213213",
        password: Some(
            "passwd",
        ),
        db: 1,
    },
    postgresql: Postgresql {
        dsn: "host=321313lll user=postgres password=passwd dbname=xdai port=5432 sslmode=disable TimeZone=Asia/Shanghai",
    },
    lapin: RabbitMQ {
        dsn: "amqp://2424214214142141/",
    },
}