terracotta 0.4.2

Boilerplate webserver application based on Axum
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#![allow(clippy::unused_async, reason = "Middleware functions need to be async")]

//! Error-handling middleware.



//		Packages																										

use axum::{
	body::Body,
	http::{Request, StatusCode},
	middleware::Next,
	response::{Html, IntoResponse, Response},
};
use rubedo::http::UnpackedResponseBody;
use tracing::error;

#[cfg(feature = "tera")]
use crate::app::{
	errors::AppError,
	state::StateProvider as AppStateProvider,
};
#[cfg(feature = "tera")]
use ::{
	axum::{
		extract::State,
		http::HeaderValue,
	},
	std::sync::Arc,
	tera::Context as Template,
};



//		Functions																										

//		no_route																
/// Handles non-existent routes.
/// 
/// This function is called as a fallback when a route is not found. It returns
/// a 404 status code.
/// 
pub async fn no_route() -> impl IntoResponse {
	(
		StatusCode::NOT_FOUND,
		[
			("protected", "protected"),
		],
	).into_response()
}

//		graceful_error_layer													
/// Handles errors gracefully.
/// 
/// This function is called when an error occurs. It returns a 500 status code
/// and a page with the error message.
/// 
/// If the error is a 404, it returns a 404 status code and a 404 page.
/// 
/// # Parameters
/// 
/// * `state`   - The application state.
/// * `request` - The request.
/// * `next`    - The next middleware.
/// 
/// # Errors
/// 
/// If there is an error rendering the error page, an error will be returned.
/// 
#[cfg(feature = "tera")]
pub async fn graceful_error_layer<SP>(
	State(state): State<Arc<SP>>,
	request:      Request<Body>,
	next:         Next,
) -> Result<Response, AppError>
where
	SP: AppStateProvider,
{
	let response          = next.run(request).await;
	let (mut parts, body) = response.into_parts();
	Ok(match parts.status {
		//		404: Not Found													
		StatusCode::NOT_FOUND => {
			drop(parts.headers.remove("content-length"));
			drop(parts.headers.remove("content-type"));
			let mut template = Template::new();
			template.insert("Title", &state.title());
			(
				parts,
				Html(state.render("404-notfound", &template).await?),
			).into_response()
		},
		//		500: Internal Server Error										
		StatusCode::INTERNAL_SERVER_ERROR => {
			error!("Internal server error: {}", UnpackedResponseBody::from(body));
			let mut template = Template::new();
			template.insert("Title", &state.title());
			drop(parts.headers.remove("content-length"));
			drop(parts.headers.remove("content-type"));
			drop(parts.headers.insert("error-handled", HeaderValue::from_static("gracefully")));
			(
				parts,
				Html(state.render("500-error", &template).await?),
			).into_response()
		},
		//		Everything else													
		_ => {
			(
				parts,
				body,
			).into_response()
		},
	})
}

//		final_error_layer														
/// Catches unhandled errors.
/// 
/// This function is called when an error occurs in the
/// [`graceful_error_layer()`] handler. It returns a 500 status code and an
/// error message.
/// 
/// # Parameters
/// 
/// * `request` - The request.
/// * `next`    - The next middleware.
/// 
pub async fn final_error_layer(
	request: Request<Body>,
	next:    Next,
) -> Response {
	let response = next.run(request).await;
	match response.status() {
		//		500: Internal Server Error										
		StatusCode::INTERNAL_SERVER_ERROR => {
			let (mut parts, body) = response.into_parts();
			if parts.headers.contains_key("error-handled") {
				drop(parts.headers.remove("error-handled"));
				return (parts, body).into_response();
			}
			error!("Internal server error: {}", UnpackedResponseBody::from(body));
			drop(parts.headers.remove("content-length"));
			drop(parts.headers.remove("content-type"));
			(
				parts,
				Html(r"<h1>Internal server error</h1>"),
			).into_response()
		},
		//		Everything else													
		_ => response,
	}
}