salak

A layered configuration loader with zero-boilerplate configuration management.

1. About
2. Features
3. Placeholder
4. Key Convension
5. Cargo Features
   1. Default features
   2. Optional features
6. Quick Example
7. Factory

About

salak is a rust version of layered configuration loader inspired by spring-boot. salak provide an [Environment] structure which load properties from various [PropertySource]s. Any structure which impmement [FromEnvironment] can get from [Environment] by a key. Feature enable_derive provide rust attributes for auto derive [FromEnvironment].

Features

Below are a few of the features which salak supports.

• Auto mapping properties into configuration struct.
  • #[salak(default="value")] set default value.
  • #[salak(name="key")] rename property key.
  • #[salak(prefix="salak.database")] set prefix.
• ** Supports load properties from various sources **
  • Support following random property key.
    • random.u8
    • random.u16
    • random.u32
    • random.i8
    • random.i16
    • random.i32
    • random.i64
  • Load properties from command line arguments.
  • Load properties from system environment.
  • Load properties from toml config file.
  • Load properties from yaml config file.
  • Easy to add a new property source.
• Supports profile(develop/production) based configuration.
• Supports placeholder resolve.
• Supports reload configurations.

Placeholder

• ${key:default} means get value of key, if not exists then return default.
• ${key} means get value of key, if not exists then return PropertyError::NotFound(_).
• \$\{key\} means escape to ${key}.

Key Convension

• a.b.c is a normal key separated by dot(.).
• a.b[0], a.b[1], a.b[2]... is a group of keys with arrays.

Cargo Features

Default features

1. enable_log, enable log record if enabled.
2. enable_toml, enable toml support.
3. enable_derive, enable auto derive [FromEnvironment] for struts.

Optional features

1. enable_pico, enable default command line arguments parsing by pico-args.
2. enable_clap, enable default command line arguments parsing by clap.
3. enable_yaml, enable yaml support.
4. enable_rand, enable random value support.

Quick Example

use salak::*;

#[derive(FromEnvironment, Debug)]
pub struct SslConfig {
    key: String,
    pem: String,
}

#[derive(FromEnvironment, Debug)]
#[salak(prefix = "database")]
pub struct DatabaseConfig {
  url: String,
  #[salak(default = "salak")]
  username: String,
  password: Option<String>,
  description: String,
  #[salak(name="ssl")]
  ssl_config: Option<SslConfig>,  
}

std::env::set_var("database.url", "localhost:5432");
std::env::set_var("database.description", "\\$\\{Hello\\}");
let env = Salak::new()
   .with_default_args(auto_read_sys_args_param!()) // This line need enable feature `enable_clap`.
   .build();

match env.load_config::<DatabaseConfig>() {
    Ok(val) => println!("{:?}", val),
    Err(e) => println!("{}", e),
}

// Output: DatabaseConfig {
//  url: "localhost:5432",
//  username: "salak",
//  password: None,
//  description: "${Hello}",
//  ssl_config: None,
// }

Salak Factory

salak_factory is out-of-box crate for using well known components, such as redis, postgresql, etc.

let env = Salak::new().build();
let redis_pool = env.build::<RedisConfig>().unwrap();
let redis_conn = redis_pool.get().unwrap();
let _: u64 = redis_conn.set("hello", 1u64).unwrap();
/// Use redis_conn.