Struct rocket::config::ConfigBuilder

pub struct ConfigBuilder {
    pub environment: Environment,
    pub address: String,
    pub port: u16,
    pub workers: u16,
    pub keep_alive: u32,
    pub read_timeout: u32,
    pub write_timeout: u32,
    pub log_level: LoggingLevel,
    pub secret_key: Option<String>,
    pub tls: Option<(String, String)>,
    pub limits: Limits,
    pub extras: HashMap<String, Value>,
    pub root: Option<PathBuf>,
}

Structure following the builder pattern for building Config structures.

Fields

environment: Environment

The environment that this configuration corresponds to.

address: String

The address to serve on.

port: u16

The port to serve on.

workers: u16

The number of workers to run in parallel.

keep_alive: u32

Keep-alive timeout in seconds or disabled if 0.

read_timeout: u32

Number of seconds to wait without receiving data before closing a connection; disabled when None.

write_timeout: u32

Number of seconds to wait without sending data before closing a connection; disabled when None.

log_level: LoggingLevel

How much information to log.

secret_key: Option<String>

The secret key.

tls: Option<(String, String)>

TLS configuration (path to certificates file, path to private key file).

limits: Limits

Size limits.

extras: HashMap<String, Value>

Any extra parameters that aren't part of Rocket's config.

root: Option<PathBuf>

The root directory of this config, if any.

Implementations

impl ConfigBuilder

pub fn new(environment: Environment) -> ConfigBuilder

Create a new ConfigBuilder instance using the default parameters from the given environment.

This method is typically called indirectly via Config::build().

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .address("127.0.0.1")
    .port(700)
    .workers(12)
    .finalize();

pub fn address<A: Into<String>>(mut self: Self, address: A) -> Self

Sets the address in the configuration being built.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .address("127.0.0.1")
    .unwrap();

assert_eq!(config.address.as_str(), "127.0.0.1");

pub fn port(mut self: Self, port: u16) -> Self

Sets the port in the configuration being built.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .port(1329)
    .unwrap();

assert_eq!(config.port, 1329);

pub fn workers(mut self: Self, workers: u16) -> Self

Sets workers in the configuration being built.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .workers(64)
    .unwrap();

assert_eq!(config.workers, 64);

pub fn keep_alive(mut self: Self, timeout: u32) -> Self

Sets the keep-alive timeout to timeout seconds. If timeout is 0, keep-alive is disabled.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .keep_alive(10)
    .unwrap();

assert_eq!(config.keep_alive, Some(10));

let config = Config::build(Environment::Staging)
    .keep_alive(0)
    .unwrap();

assert_eq!(config.keep_alive, None);

pub fn read_timeout(mut self: Self, timeout: u32) -> Self

Sets the read timeout to timeout seconds. If timeout is 0, read timeouts are disabled.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .read_timeout(10)
    .unwrap();

assert_eq!(config.read_timeout, Some(10));

let config = Config::build(Environment::Staging)
    .read_timeout(0)
    .unwrap();

assert_eq!(config.read_timeout, None);

pub fn write_timeout(mut self: Self, timeout: u32) -> Self

Sets the write timeout to timeout seconds. If timeout is 0, write timeouts are disabled.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .write_timeout(10)
    .unwrap();

assert_eq!(config.write_timeout, Some(10));

let config = Config::build(Environment::Staging)
    .write_timeout(0)
    .unwrap();

assert_eq!(config.write_timeout, None);

pub fn log_level(mut self: Self, log_level: LoggingLevel) -> Self

Sets the log_level in the configuration being built.

Example

use rocket::config::{Config, Environment, LoggingLevel};

let config = Config::build(Environment::Staging)
    .log_level(LoggingLevel::Critical)
    .unwrap();

assert_eq!(config.log_level, LoggingLevel::Critical);

pub fn secret_key<K: Into<String>>(mut self: Self, key: K) -> Self

Sets the secret_key in the configuration being built.

Example

use rocket::config::{Config, Environment, LoggingLevel};

let key = "8Xui8SN4mI+7egV/9dlfYYLGQJeEx4+DwmSQLwDVXJg=";
let mut config = Config::build(Environment::Staging)
    .secret_key(key)
    .unwrap();

pub fn limits(mut self: Self, limits: Limits) -> Self

Sets the limits in the configuration being built.

Example

use rocket::config::{Config, Environment, Limits};

let mut config = Config::build(Environment::Staging)
    .limits(Limits::new().limit("json", 5 * (1 << 20)))
    .unwrap();

pub fn tls<C, K>(mut self: Self, certs_path: C, key_path: K) -> Self where
    C: Into<String>,
    K: Into<String>, 

Sets the TLS configuration in the configuration being built.

Certificates are read from certs_path. The certificate chain must be in X.509 PEM format. The private key is read from key_path. The private key must be an RSA key in either PKCS#1 or PKCS#8 PEM format.

Example

use rocket::config::{Config, Environment};

let mut config = Config::build(Environment::Staging)
    .tls("/path/to/certs.pem", "/path/to/key.pem")
    .unwrap();

pub fn environment(mut self: Self, env: Environment) -> Self

Sets the environment in the configuration being built.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .environment(Environment::Production)
    .unwrap();

assert_eq!(config.environment, Environment::Production);

pub fn root<P: AsRef<Path>>(mut self: Self, path: P) -> Self

Sets the root in the configuration being built.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .root("/my_app/dir")
    .unwrap();

assert_eq!(config.root().unwrap(), Path::new("/my_app/dir"));

pub fn extra<V: Into<Value>>(mut self: Self, name: &str, value: V) -> Self

Adds an extra configuration parameter with name and value to the configuration being built. The value can be any type that implements Into<Value> including &str, String, Vec<V: Into<Value>>, HashMap<S: Into<String>, V: Into<Value>>, and most integer and float types.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .extra("pi", 3.14)
    .extra("custom_dir", "/a/b/c")
    .unwrap();

assert_eq!(config.get_float("pi"), Ok(3.14));
assert_eq!(config.get_str("custom_dir"), Ok("/a/b/c"));

pub fn finalize(self) -> Result<Config>

Return the Config structure that was being built by this builder.

Errors

If the address or secret key fail to parse, returns a BadType error.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .address("127.0.0.1")
    .port(700)
    .workers(12)
    .keep_alive(0)
    .finalize();

assert!(config.is_ok());

let config = Config::build(Environment::Staging)
    .address("123.123.123.123.123 whoops!")
    .finalize();

assert!(config.is_err());

pub fn unwrap(self) -> Config

Return the Config structure that was being built by this builder.

Panics

Panics if the supplied address, secret key, or TLS configuration fail to parse.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .address("127.0.0.1")
    .unwrap();

assert_eq!(config.address.as_str(), "127.0.0.1");

pub fn expect(self, msg: &str) -> Config

Returns the Config structure that was being built by this builder.

Panics

Panics if the supplied address, secret key, or TLS configuration fail to parse. If a panic occurs, the error message msg is printed.

Example

use rocket::config::{Config, Environment};

let config = Config::build(Environment::Staging)
    .address("127.0.0.1")
    .expect("the configuration is bad!");

assert_eq!(config.address.as_str(), "127.0.0.1");

Trait Implementations

impl Clone for ConfigBuilder

fn clone(&self) -> ConfigBuilder

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.