Struct Rainier 

pub struct Rainier { /* private fields */ }

Assembles an Application.

use rainier_framework::Rainier;

let app = Rainier::new(".")
    .with_routes(|router| {
        router.get("/", || async { "Hello from Rainier" });
    })
    .boot()
    .await?;

Implementations

impl Rainier

pub fn new(base_path: impl Into<PathBuf>) -> Self

Start from base_path, reading .env from it if there is one.

Infallible so the builder chain reads as one expression. A driver name the environment got wrong is held in deferred and returned from boot — the error still stops the application, it just does not force a ? into the middle of the chain.

pub fn env(&self) -> &Env

The environment, for reading deployment values while building.

pub fn config(&self) -> &Config

The configuration, for adding to it while building.

pub fn configure(self, adjust: impl FnOnce(&Config)) -> Self

Adjust the configuration.

pub fn with_events(self, register: impl FnOnce(&Dispatcher)) -> Self

Register event listeners.

pub fn with_middleware(self, register: impl FnOnce(&MiddlewareRegistry)) -> Self

Register middleware aliases and groups.

pub fn with_routes(self, declare: impl FnOnce(&mut Router)) -> Self

Declare routes.

pub fn with_views(self, engine: Arc<dyn ViewEngine>) -> Self

Use a specific view engine. Defaults to a TemplateEngine over <base>/resources/views.

pub fn with_database(self, database: Database) -> Self

Use this database.

pub fn with_queue(self, queue: QueueManager) -> Self

Use this queue.

pub fn with_mailer(self, mailer: Mailer) -> Self

Use this mailer.

pub fn with_sessions(self, sessions: SessionManager) -> Self

Use this session store, and register the session middleware alias.

Without this, sessions default to an in-process store — right for development and wrong the moment there are two instances. See SessionManager.

pub fn with_cache(self, cache: CacheManager) -> Self

Use this cache.

Defaults to an in-process one, which is right for development and wrong the moment a second instance exists — see CacheManager.

pub fn with_notifier(self, notifier: Notifier) -> Self

Use these notification channels.

Without it, notifications go to the log — which delivers nothing, and is the right thing to have by accident: a misconfigured deployment logs them rather than emailing real people from a copy of production data.

Rainier::new(".").with_notifier(
    Notifier::new()
        .with(MailChannel::new(mailer))
        .with(DatabaseChannel::new(database)),
)

pub fn with_broadcasting(self, broadcasting: Broadcasting) -> Self

Use this broadcast driver.

Without it, broadcasts go to the log — they reach no browser, which is the right accident to have: an application that has not configured a relay logs what it would have published instead of failing requests.

The channel table is not set here, because it is generic over your user model. Bind a ChannelRegistry<User> in a provider; until you do, every private channel is denied.

Rainier::new(".").with_broadcasting(Broadcasting::new(Arc::new(
    RedisBroadcaster::connect(&connector).await?.with_pusher_auth(auth),
)))

pub fn with_websockets(self, routes: WebSocketRoutes) -> Self

Serve these WebSocket routes.

On the same port as HTTP: a socket connection begins as a GET asking to upgrade, so there is no second listener to start and nothing to run alongside anything.

Rainier::new(".").with_websockets(
    WebSocketRoutes::new().add("/ws/rooms/{room}", Chat::new(rooms)),
)

pub fn with_instance<T: Send + Sync + 'static>(self, value: T) -> Self

Bind a value you already have.

The gap the typed with_* methods leave: an application often holds something the framework has never heard of — a Rooms registry, a feature-flag client, an HTTP client with a pool — and it needs to be resolvable without a provider whose whole body is one instance call.

A provider is still the right answer when the value has to be built from other bound services; this is for one that already exists.

pub fn with_instance_arc<T: Send + Sync + 'static>(self, value: Arc<T>) -> Self

Bind something already shared, keeping your handle to it.

pub fn with_schedule(self, declare: impl FnOnce(&mut Schedule)) -> Self

Declare the scheduled tasks.

Rainier::new(".").with_schedule(routes::console::schedule)

Bound in the container, so schedule:run and schedule:list find it.

pub fn with_storage(self, storage: Storage) -> Self

Use this file storage.

Defaults to <base>/storage/app, so Storage::instance() works on a fresh clone without configuration.

pub fn with_encryption(self, crypt: Encryption) -> Self

Use these keys for encryption and signing.

Defaults to APP_KEY from the environment. With neither, a random key is generated per boot — which works, and silently invalidates every encrypted value the last boot produced, so it warns.

pub fn with_provider(self, provider: impl ServiceProvider) -> Self

Register a service provider.

pub fn without_facades(self) -> Self

Do not install the facades’ global application.

Two applications in one process would otherwise fight over it — which is exactly what a test suite building an app per test does.

pub fn without_tracing(self) -> Self

Do not install a tracing subscriber.

pub async fn boot(self) -> Result<Arc<Application>>

Build and boot the application.

Compiling the router here is what makes an unknown middleware alias or a duplicate route name a boot failure rather than a surprise on the first request that hits it.