Struct Application 

pub struct Application { /* private fields */ }

The application: a Container with a boot lifecycle, an environment, and a filesystem layout.

Implementations

impl Application

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

A new application rooted at base_path, in the production environment until told otherwise.

pub fn with_environment(self, environment: impl Into<String>) -> Self

Builder form of set_environment.

pub fn container(&self) -> &Arc<Container>

The shared container. Hand this to anything that needs to resolve services without holding the whole application.

pub fn register(&self, provider: impl ServiceProvider) -> Result<()>

Register a provider, running its register pass immediately.

Booting is deliberately not done here: a provider’s boot may resolve services that a later-registered provider binds, so booting has to wait until every provider has registered. Register everything, then call boot.

pub fn register_arc(&self, provider: Arc<dyn ServiceProvider>) -> Result<()>

register for a provider that is already shared.

pub fn provider_names(&self) -> Vec<&'static str>

The names of every registered provider, in registration order.

pub async fn boot(&self) -> Result<()>

Boot every provider that has not booted yet, running the booting hooks first and the booted hooks after.

Idempotent, and safe to call again after registering more providers — only the new ones boot.

pub fn is_booted(&self) -> bool

Whether boot has completed at least once.

pub fn booting(&self, hook: impl Fn(&Application) + Send + Sync + 'static)

Run hook immediately before providers boot.

Ignored if the application has already booted — “before boot” has passed, and silently running it late would be worse than not running it.

pub fn booted(&self, hook: impl Fn(&Application) + Send + Sync + 'static)

Run hook once the application has booted — or immediately, if it already has. The immediate call is what makes this usable from code that cannot know whether boot has happened yet.

pub fn terminating(&self, hook: impl Fn(&Application) + Send + Sync + 'static)

Run hook when terminate is called — after a response has been sent, for work that should not delay it.

pub fn terminate(&self)

Run the terminating hooks. The HTTP kernel calls this after flushing a response; a console command calls it before exiting.

pub fn environment(&self) -> String

The current environment name (local, testing, production, …).

pub fn set_environment(&self, environment: impl Into<String>)

Set the environment name.

pub fn environment_is(&self, names: &[&str]) -> bool

Whether the environment is any of names.

pub fn is_local(&self) -> bool

Whether the environment is local.

pub fn is_testing(&self) -> bool

Whether the environment is testing.

pub fn is_production(&self) -> bool

Whether the environment is production.

pub fn base_path(&self) -> &Path

The application root.

pub fn path(&self, relative: impl AsRef<Path>) -> PathBuf

A path relative to the application root.

pub fn config_path(&self) -> PathBuf

<base>/config.

pub fn storage_path(&self) -> PathBuf

<base>/storage.

pub fn resource_path(&self) -> PathBuf

<base>/resources — where views live.

pub fn database_path(&self) -> PathBuf

<base>/database.

Methods from Deref<Target = Container>

pub fn bind<T, F>(&self, factory: F)

where T: Send + Sync + 'static, F: Fn(&Container) -> Result<T> + Send + Sync + 'static,

Bind a factory that runs on every resolution.

pub fn singleton<T, F>(&self, factory: F)

where T: Send + Sync + 'static, F: Fn(&Container) -> Result<T> + Send + Sync + 'static,

Bind a factory that runs once; every resolution afterwards hands back the same Arc.

pub fn scoped<T, F>(&self, factory: F)

where T: Send + Sync + 'static, F: Fn(&Container) -> Result<T> + Send + Sync + 'static,

Like singleton, but flush_scoped drops the memoised instance so the next resolution rebuilds it.

This is the binding a long-running worker wants for per-job state: the queue worker flushes scoped bindings between jobs so one job cannot leak state into the next.

pub fn instance<T: Send + Sync + 'static>(&self, value: T)

Register an already-built value. The container never constructs it.

pub fn instance_arc<T: Send + Sync + 'static>(&self, value: Arc<T>)

Register an already-built value that is already behind an Arc — useful when the caller must keep a handle to it too.

pub fn resolve<T: Send + Sync + 'static>(&self) -> Result<Arc<T>>

Resolve T, building it if necessary.

Fails when T was never bound, when its factory fails, or when resolving it re-enters itself (a dependency cycle).

pub fn try_resolve<T: Send + Sync + 'static>(&self) -> Option<Arc<T>>

Resolve T, or None if it is unbound or its factory failed.

pub fn expect_resolve<T: Send + Sync + 'static>(&self) -> Arc<T>

Resolve T, panicking with the resolution error if it is not available. For bootstrap code and facades, where an unbound service is a configuration bug rather than a runtime condition.

pub fn bound<T: 'static>(&self) -> bool

Whether anything is bound for T.

pub fn forget<T: 'static>(&self)

Drop the binding for T, if any.

pub fn flush_scoped(&self)

Drop the memoised instance of every scoped binding. The bindings survive; only the built values are discarded.

pub fn len(&self) -> usize

How many types are bound.

pub fn is_empty(&self) -> bool

Whether nothing is bound.

Trait Implementations

impl Debug for Application

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

Formats the value using the given formatter.

impl Deref for Application

type Target = Container

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.