[][src]Struct rocket::config::ConfigBuilder

pub struct ConfigBuilder {
    pub environment: Environment,
    pub address: String,
    pub port: u16,
    pub workers: u16,
    pub keep_alive: 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.

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.

Methods

impl ConfigBuilder[src]

pub fn new(environment: Environment) -> ConfigBuilder[src]

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>>(self, address: A) -> Self[src]

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(self, port: u16) -> Self[src]

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(self, workers: u16) -> Self[src]

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(self, timeout: u32) -> Self[src]

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 log_level(self, log_level: LoggingLevel) -> Self[src]

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>>(self, key: K) -> Self[src]

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(self, limits: Limits) -> Self[src]

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>(self, certs_path: C, key_path: K) -> Self where
    C: Into<String>,
    K: Into<String>, 
[src]

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(self, env: Environment) -> Self[src]

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>>(self, path: P) -> Self[src]

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>>(self, name: &str, value: V) -> Self[src]

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>[src]

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[src]

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[src]

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[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

Auto Trait Implementations

impl Send for ConfigBuilder

impl Sync for ConfigBuilder

impl Unpin for ConfigBuilder

impl UnwindSafe for ConfigBuilder

impl RefUnwindSafe for ConfigBuilder

Blanket Implementations

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> From<T> for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Typeable for T where
    T: Any

fn get_type(&self) -> TypeId

Get the TypeId of this object.

impl<T> IntoCollection<T> for T

impl<T, I> AsResult<T, I> for T where
    I: Input,