pub struct App<R: ThrusterRequest, T: 'static + Context + Clone + Send + Sync, S: Send> {
pub delete_root: Node<T>,
pub get_root: Node<T>,
pub options_root: Node<T>,
pub post_root: Node<T>,
pub put_root: Node<T>,
pub patch_root: Node<T>,
pub context_generator: fn(_: R, _: &S, _: &str) -> T,
pub state: Arc<S>,
pub connection_timeout: u64,
}
Expand description
App, the main component of Thruster. The App is the entry point for your application
and handles all incomming requests. Apps are also composeable, that is, via the subapp
method, you can use all of the methods and middlewares contained within an app as a subset
of your app’s routes.
There are three main parts to creating a thruster app:
- Use
App.create
to create a new app with a custom context generator - Add routes and middleware via
.get
,.post
, etc. - Build the app future with
App.build
and spawn it on the executor
Examples
Subapp
let mut app1 = App::<Request, BasicContext>::new();
fn test_fn_1(context: BasicContext, next: impl Fn(BasicContext) -> MiddlewareReturnValue<BasicContext> + Send) -> MiddlewareReturnValue<BasicContext> {
Box::new(future::ok(BasicContext {
body: context.params.get("id").unwrap().to_owned(),
params: context.params,
query_params: context.query_params
}))
};
app1.get("/:id", middleware![BasicContext => test_fn_1]);
let mut app2 = App::<Request, BasicContext>::new();
app2.use_sub_app("/test", app1);
In the above example, the route /test/some-id
will return some-id
in the body of the response.
The provided start methods are great places to start, but you can also simply use Thruster as a router
and create your own version of an HTTP server by directly calling App.resolve
with a Request object.
It will then return a future with the Response object that corresponds to the request. This can be
useful if trying to integrate with a different type of load balancing system within the threads of the
application.
Fields
delete_root: Node<T>
get_root: Node<T>
options_root: Node<T>
post_root: Node<T>
put_root: Node<T>
patch_root: Node<T>
context_generator: fn(_: R, _: &S, _: &str) -> T
Generate context is common to all App
s. It’s the function that’s called upon receiving a request
that translates an acutal Request
struct to your custom Context type. It should be noted that
the context_generator should be as fast as possible as this is called with every request, including
404s.
state: Arc<S>
connection_timeout: u64
The connection timeout for the app in milliseconds. Defaults to 3600000ms (1 hour)
Implementations
sourceimpl<R: 'static + ThrusterRequest, T: Context + Clone + Send + Sync, S: 'static + Send> App<R, T, S>
impl<R: 'static + ThrusterRequest, T: Context + Clone + Send + Sync, S: 'static + Send> App<R, T, S>
sourcepub fn new_basic() -> App<Request, BasicContext, ()>
pub fn new_basic() -> App<Request, BasicContext, ()>
Creates a new instance of app with the library supplied BasicContext
. Useful for trivial
examples, likely not a good solution for real code bases. The advantage is that the
context_generator is already supplied for the developer.
sourcepub fn create(generate_context: fn(_: R, _: &S, _: &str) -> T, state: S) -> Self
pub fn create(generate_context: fn(_: R, _: &S, _: &str) -> T, state: S) -> Self
Create a new app with the given context generator. The app does not begin listening until start is called.
sourcepub fn use_middleware(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self where
T: Clone,
pub fn use_middleware(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self where
T: Clone,
Add method-agnostic middleware for a route. This is useful for applying headers, logging, and anything else that might not be sensitive to the HTTP method for the endpoint.
sourcepub fn use_sub_app(self, prefix: &str, app: App<R, T, S>) -> Self
pub fn use_sub_app(self, prefix: &str, app: App<R, T, S>) -> Self
Add an app as a predetermined set of routes and middleware. Will prefix whatever string is passed in to all of the routes. This is a main feature of Thruster, as it allows projects to be extermely modular and composeable in nature.
sourcepub fn get(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
pub fn get(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
Add a route that responds to GET
s to a given path
sourcepub fn options(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
pub fn options(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
Add a route that responds to OPTION
s to a given path
sourcepub fn post(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
pub fn post(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
Add a route that responds to POST
s to a given path
sourcepub fn put(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
pub fn put(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
Add a route that responds to PUT
s to a given path
sourcepub fn delete(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
pub fn delete(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
Add a route that responds to DELETE
s to a given path
sourcepub fn patch(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
pub fn patch(self, path: &str, middlewares: MiddlewareTuple<T>) -> Self
Add a route that responds to PATCH
s to a given path
sourcepub fn set404(self, middlewares: MiddlewareTuple<T>) -> Self where
T: Clone,
pub fn set404(self, middlewares: MiddlewareTuple<T>) -> Self where
T: Clone,
Sets the middleware if no route is successfully matched. Note, that due to type restrictions, we Context needs to implement Clone in order to call this function, even though clone will never be called.
sourcepub fn set_strict_mode(self, strict_mode: bool) -> Self where
T: Clone,
pub fn set_strict_mode(self, strict_mode: bool) -> Self where
T: Clone,
Sets whether this app router uses strict mode for route parsing or not. Strict mode considers
/a
to be distinct from /a/
.
pub fn resolve_from_method_and_path<'m>(
&'m self,
method: &str,
path: String
) -> NodeOutput<'m, T>
pub fn match_and_resolve<'m>(
&'m self,
request: R
) -> ReusableBoxFuture<Result<T::Response, Error>>ⓘNotable traits for ReusableBoxFuture<T>impl<T> Future for ReusableBoxFuture<T> type Output = T;
pub async fn resolve<'m>(
&self,
request: R,
matched_route: NodeOutput<'m, T>
) -> Result<T::Response, Error>
Auto Trait Implementations
impl<R, T, S> !RefUnwindSafe for App<R, T, S>
impl<R, T, S> Send for App<R, T, S> where
S: Sync,
impl<R, T, S> Sync for App<R, T, S> where
S: Sync,
impl<R, T, S> Unpin for App<R, T, S>
impl<R, T, S> !UnwindSafe for App<R, T, S>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more