136 lines
3.8 KiB
Rust
136 lines
3.8 KiB
Rust
#![doc = include_str!("../README.md")]
|
|
mod config;
|
|
mod database;
|
|
mod markdown;
|
|
mod model;
|
|
mod routes;
|
|
|
|
use crate::database::DataManager;
|
|
use axum::{Extension, Router};
|
|
use config::Config;
|
|
use nanoneo::core::element::Render;
|
|
use std::{collections::HashMap, env::var, net::SocketAddr, process::exit, sync::Arc};
|
|
use tera::{Tera, Value};
|
|
use tetratto_core::html;
|
|
use tetratto_shared::hash::salt;
|
|
use tokio::sync::RwLock;
|
|
use tower_http::{
|
|
catch_panic::CatchPanicLayer,
|
|
trace::{self, TraceLayer},
|
|
};
|
|
use tracing::{Level, info};
|
|
|
|
pub(crate) type InnerState = (DataManager, Tera, String);
|
|
pub(crate) type State = Arc<RwLock<InnerState>>;
|
|
|
|
fn render_markdown(value: &Value, _: &HashMap<String, Value>) -> tera::Result<Value> {
|
|
Ok(markdown::render_markdown(value.as_str().unwrap())
|
|
.replace("\\@", "@")
|
|
.replace("%5C@", "@")
|
|
.into())
|
|
}
|
|
|
|
fn remove_script_tags(value: &Value, _: &HashMap<String, Value>) -> tera::Result<Value> {
|
|
Ok(value
|
|
.as_str()
|
|
.unwrap()
|
|
.replace("</script>", "</script>")
|
|
.into())
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! create_dir_if_not_exists {
|
|
($dir_path:expr) => {
|
|
if !std::fs::exists(&$dir_path).unwrap() {
|
|
std::fs::create_dir($dir_path).unwrap();
|
|
}
|
|
};
|
|
}
|
|
|
|
#[tokio::main(flavor = "multi_thread")]
|
|
async fn main() {
|
|
dotenv::dotenv().ok();
|
|
tracing_subscriber::fmt()
|
|
.with_target(false)
|
|
.compact()
|
|
.init();
|
|
|
|
let port = match var("PORT") {
|
|
Ok(port) => port.parse::<u16>().expect("port should be a u16"),
|
|
Err(_) => 9119,
|
|
};
|
|
|
|
// ...
|
|
let database = DataManager::new(Config::read())
|
|
.await
|
|
.expect("failed to connect to database");
|
|
database.init().await.expect("failed to init database");
|
|
|
|
// build lisp
|
|
create_dir_if_not_exists!("./templates_build");
|
|
create_dir_if_not_exists!("./icons");
|
|
|
|
for x in glob::glob("./templates_src/**/*").expect("failed to read pattern") {
|
|
match x {
|
|
Ok(x) => std::fs::write(
|
|
x.to_str()
|
|
.unwrap()
|
|
.replace("templates_src/", "templates_build/"),
|
|
html::pull_icons(
|
|
nanoneo::parse(&std::fs::read_to_string(x).expect("failed to read template"))
|
|
.render(&mut HashMap::new()),
|
|
"./icons",
|
|
)
|
|
.await,
|
|
)
|
|
.expect("failed to write template"),
|
|
Err(e) => panic!("{e}"),
|
|
}
|
|
}
|
|
|
|
// create docs dir
|
|
create_dir_if_not_exists!("./docs");
|
|
|
|
// ...
|
|
let mut tera = match Tera::new(&format!("./templates_build/**/*")) {
|
|
Ok(t) => t,
|
|
Err(e) => {
|
|
println!("{e}");
|
|
exit(1);
|
|
}
|
|
};
|
|
|
|
tera.register_filter("markdown", render_markdown);
|
|
tera.register_filter("remove_script_tags", remove_script_tags);
|
|
|
|
// create app
|
|
let app = Router::new()
|
|
.merge(routes::routes())
|
|
.layer(Extension(Arc::new(RwLock::new((database, tera, salt())))))
|
|
.layer(axum::extract::DefaultBodyLimit::max(
|
|
var("BODY_LIMIT")
|
|
.unwrap_or("8388608".to_string())
|
|
.parse::<usize>()
|
|
.unwrap(),
|
|
))
|
|
.layer(
|
|
TraceLayer::new_for_http()
|
|
.make_span_with(trace::DefaultMakeSpan::new().level(Level::INFO))
|
|
.on_response(trace::DefaultOnResponse::new().level(Level::INFO)),
|
|
)
|
|
.layer(CatchPanicLayer::new());
|
|
|
|
// ...
|
|
let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
|
|
.await
|
|
.unwrap();
|
|
|
|
info!("🪨 malachite.");
|
|
info!("listening on http://0.0.0.0:{}", port);
|
|
axum::serve(
|
|
listener,
|
|
app.into_make_service_with_connect_info::<SocketAddr>(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
}
|