117 lines
3.2 KiB
Rust
117 lines
3.2 KiB
Rust
use core::panic;
|
|
use std::{convert::Infallible, fmt::Display};
|
|
|
|
use handlebars::{Handlebars, RenderError};
|
|
use serde::Serialize;
|
|
use warp::{hyper::StatusCode, reject::Reject, Filter, Rejection, Reply};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Server {
|
|
hb: Handlebars<'static>,
|
|
profiler: Profiler,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Profiler;
|
|
|
|
impl Profiler {
|
|
fn profile(&self, username: String) -> Result<Profile, Infallible> {
|
|
Ok(Profile { username })
|
|
}
|
|
}
|
|
|
|
impl Server {
|
|
pub fn new() -> Self {
|
|
let mut hb = Handlebars::new();
|
|
hb.register_template_string("profile", include_str!("../templates/html/profile.html"))
|
|
.expect("profile template");
|
|
let profiler = Profiler;
|
|
|
|
Self { hb, profiler }
|
|
}
|
|
|
|
pub async fn listen_and_serve(self, port: u16) -> ! {
|
|
println!("starting server on port {}", port);
|
|
warp::serve(self.html().recover(Self::handle_rejection))
|
|
.run(([127, 0, 0, 1], port))
|
|
.await;
|
|
panic!("server stopped prematurely")
|
|
}
|
|
|
|
fn html(&self) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
|
|
Self::index().or(self.profile())
|
|
}
|
|
|
|
fn index() -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
|
|
warp::get().and(warp::path::end().map(move || {
|
|
warp::reply::html(include_str!("../templates/html/index.html").to_owned())
|
|
}))
|
|
}
|
|
|
|
fn with_server(
|
|
srv: Server,
|
|
) -> impl Filter<Extract = (Server,), Error = std::convert::Infallible> + Clone {
|
|
warp::any().map(move || srv.clone())
|
|
}
|
|
|
|
fn profile(&self) -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone {
|
|
warp::get().and(
|
|
warp::path!("@" / String)
|
|
.and(Self::with_server(self.clone()))
|
|
.and_then(|username: String, srv: Server| async move {
|
|
match srv.hb.render(
|
|
"profile",
|
|
&serde_json::json!(srv.profiler.profile(username)?),
|
|
) {
|
|
Ok(html) => Ok(warp::reply::html(html)),
|
|
Err(err) => Err(InternalError::reject(err.to_string())),
|
|
}
|
|
}),
|
|
)
|
|
}
|
|
|
|
async fn handle_rejection(err: Rejection) -> Result<impl Reply, Infallible> {
|
|
if let Some(internal) = err.find::<InternalError>() {
|
|
println!("internal error: {}", internal);
|
|
return Ok(warp::reply::with_status(
|
|
"internal server error",
|
|
StatusCode::INTERNAL_SERVER_ERROR,
|
|
));
|
|
}
|
|
|
|
panic!()
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct InternalError {
|
|
inner: String,
|
|
}
|
|
|
|
impl InternalError {
|
|
fn reject(err: String) -> Rejection {
|
|
warp::reject::custom(Self { inner: err })
|
|
}
|
|
}
|
|
|
|
impl Reject for InternalError {}
|
|
|
|
impl From<RenderError> for InternalError {
|
|
fn from(r: RenderError) -> Self {
|
|
Self {
|
|
inner: r.to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for InternalError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "{}", self.inner)
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct Profile {
|
|
username: String,
|
|
}
|