Struct rowdy::Configuration

pub struct Configuration<B> {
    pub token: Configuration,
    pub basic_authenticator: B,
}

Application configuration. Usually deserialized from JSON for use.

The type parameter B is the auth::AuthenticatorConfiguration and by its associated type, the Authenticator that is going to be used for HTTP Basic Authentication.

Examples

extern crate rowdy;
extern crate serde_json;

use rowdy::Configuration;
use rowdy::auth::NoOpConfiguration;

// We are using the `NoOp` authenticator
let json = r#"{
    "token" : {
        "issuer": "https://www.acme.com",
        "allowed_origins": { "Some": ["https://www.example.com", "https://www.foobar.com"] },
        "audience": ["https://www.example.com", "https://www.foobar.com"],
        "signature_algorithm": "RS256",
        "secret": {
                    "rsa_private": "test/fixtures/rsa_private_key.der",
                    "rsa_public": "test/fixtures/rsa_public_key.der"
                   },
        "expiry_duration": 86400
       },
       "basic_authenticator": {}
}"#;
let config: Configuration<NoOpConfiguration> = serde_json::from_str(json).unwrap();
let rocket = config.ignite().unwrap().mount("/", rowdy::routes());
// then `rocket.launch()`!

Fields

token: Configuration

Token configuration. See the type documentation for deserialization examples

basic_authenticator: B

The configuration for the authenticator that will handle HTTP Basic Authentication.

Methods

impl<B: AuthenticatorConfiguration<Basic>> Configuration<B>

pub fn ignite(&self) -> Result<Rocket, Error>

Ignites the rocket with various configuration objects, but does not mount any routes. Remember to mount routes and call launch on the returned Rocket object. See the struct documentation for an example.

Trait Implementations

impl<B: Clone> Clone for Configuration<B>

fn clone(&self) -> Configuration<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug> Debug for Configuration<B>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<B> Serialize for Configuration<B> where
    B: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de, B> Deserialize<'de> for Configuration<B> where
    B: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.