static template context for errors

Reviewed-on: #3

.drone.yml

@@ -0,0 +1,13 @@
+kind: pipeline
+type: docker
+name: default
+
+steps:
+- name: build
+  image: rust:1-alpine
+  commands:
+  - apk add --no-cache musl-dev
+  - cargo fetch
+  - cargo build --all
+  environment:
+    CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse

.gitignore

@@ -1,4 +1,4 @@
 /target
 **/*.rs.bk
-
+db.dat
 /db

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "qchgk_web"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["Dmitry <b4tm4n@mail.ru>"]
 edition = "2021"
 license = "MIT"
@@ -11,21 +11,15 @@ readme = "README.md"
 
 [dependencies]
 rand="0.8"
-serde="1.0"
+rocket = { version = "=0.5.0-rc.3", features = ["json"] }
-serde_json="1.0"
+rocket_dyn_templates = { version = "=0.1.0-rc.3", features = ["tera"] }
-ledb = {git = "https://github.com/b4tman/ledb.git", rev="a646b90e", package="ledb"}
+chgk_ledb_lib = {git = "https://gitea.b4tman.ru/b4tman/chgk_ledb.git", rev="699478f85e", package="chgk_ledb_lib", features=["async"]}
-rocket="0.4"
+mini-moka = "0.10.0"
-chgk_ledb_lib = {git = "https://gitea.b4tman.ru/b4tman/chgk_ledb.git", rev="e521e39f5e", package="chgk_ledb_lib"}
+lazy_static = "1.4.0"
-
-# lmdb-zero="0.4"
-
-[dependencies.rocket_contrib]
-version = "0.4"
-default-features = false
-features = ["serve", "tera_templates"]
 
 [profile.release]
 opt-level = 3
 debug = false
 lto = true
 strip = true
+

src/main.rs

@@ -1,25 +1,36 @@
-#![feature(proc_macro_hygiene, decl_macro)]
-
-extern crate ledb;
-extern crate serde;
-extern crate serde_json;
-
 #[macro_use]
 extern crate rocket;
-extern crate rocket_contrib;
 
+use rocket::fs::FileServer;
+use rocket::fs::Options;
+use rocket::http::ContentType;
+use rocket::request::Request;
 use rocket::response::Redirect;
-use rocket::{Rocket, State};
+use rocket::response::{self, Responder, Response};
-use rocket_contrib::serve::StaticFiles;
+use rocket::State;
-use rocket_contrib::templates::Template;
+use rocket_dyn_templates::tera;
+use rocket_dyn_templates::Template;
 
 use rand::distributions::Uniform;
 use rand::Rng;
 
-use ledb::{Options, Storage};
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+use std::ops::Deref;
+use std::sync::Arc;
 
+use chgk_ledb_lib::async_db;
 use chgk_ledb_lib::questions::Question;
 
+use mini_moka::sync::Cache;
+use std::time::Duration;
+
+const DB_FILENAME: &str = "db.dat";
+
+lazy_static! {
+    static ref EMPTY_MAP: HashMap<String, String> = HashMap::new();
+}
+
 trait ErrorEmpty {
     type Output;
     fn err_empty(self) -> Result<Self::Output, ()>;
@@ -32,60 +43,149 @@ impl<T, E> ErrorEmpty for Result<T, E> {
     }
 }
 
-struct AppState {
+#[derive(Debug, Responder)]
-    storage: Storage,
+enum WebError {
-    database_distribution: Uniform<u32>,
+    #[response(status = 404)]
+    NotFound(Template),
+    #[response(status = 500)]
+    ServerError(Template),
 }
 
-fn get_database_distribution(storage: &Storage) -> Uniform<u32> {
+impl WebError {
-    let collection = storage
+    fn not_found() -> Self {
-        .collection("questions")
+        WebError::NotFound(Template::render("404", EMPTY_MAP.deref()))
-        .expect("collection \"questions\"");
+    }
-    let last_id = collection.last_id().expect("\"questions\" last_id");
+    fn server_error() -> Self {
-
+        WebError::ServerError(Template::render("500", EMPTY_MAP.deref()))
-    rand::distributions::Uniform::new_inclusive(1u32, last_id)
+    }
 }
 
-fn random_question_id(database_distribution: &Uniform<u32>) -> u32 {
+/// wrapper for terra:Value (json, context), to cache values by ref
-    let mut rng = rand::thread_rng();
+/// implements Responder as json content type
-    rng.sample(database_distribution)
+#[derive(Clone)]
+struct ArcTemplateData {
+    value: Arc<tera::Value>,
 }
 
-fn get_question(storage: &Storage, id: u32) -> Result<Question, ()> {
+impl Deref for ArcTemplateData {
-    storage
+    type Target = tera::Value;
-        .collection("questions")
+
-        .err_empty()?
+    fn deref(&self) -> &Self::Target {
-        .get::<Question>(id)
+        self.value.deref()
-        .err_empty()?
+    }
-        .ok_or(())
 }
 
-fn show_question_details(template_name: &'static str, data: &AppState, id: u32) -> Template {
+impl ArcTemplateData {
-    match get_question(&data.storage, id) {
+    fn new(value: tera::Value) -> ArcTemplateData {
-        Ok(question) => {
+        ArcTemplateData {
-            let mut context = serde_json::to_value(question).expect("question serialize");
+            value: Arc::new(value),
-            if context.is_object() {
-                let next_id = random_question_id(&data.database_distribution);
-                context["next"] = serde_json::to_value(next_id).expect("question id serialize");
-            }
-            Template::render(template_name, &context)
         }
-        Err(_) => {
+    }
-            use std::collections::HashMap;
+    fn render(&self, name: &'static str) -> Template {
-            let context: HashMap<String, String> = HashMap::new();
+        Template::render(name, self.deref())
-            Template::render("404", &context)
+    }
+}
+
+impl<'r> Responder<'r, 'static> for ArcTemplateData {
+    fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
+        Response::build_from(self.to_string().respond_to(req)?)
+            .header(ContentType::JSON)
+            .ok()
+    }
+}
+
+type TemplateCache = mini_moka::sync::Cache<usize, ArcTemplateData>;
+
+type DataBaseInner = async_db::Reader<Question>;
+type DataBase = Arc<DataBaseInner>;
+struct AppState {
+    db: DataBase,
+    database_distribution: Uniform<usize>,
+}
+
+impl From<DataBaseInner> for AppState {
+    fn from(db: DataBaseInner) -> Self {
+        let last_id = db.len();
+        let database_distribution = rand::distributions::Uniform::new_inclusive(1usize, last_id);
+        let db = Arc::new(db);
+
+        Self {
+            db,
+            database_distribution,
         }
     }
 }
 
+fn random_question_id(database_distribution: &Uniform<usize>) -> usize {
+    let mut rng = rand::thread_rng();
+    rng.sample(database_distribution)
+}
+
+async fn get_question(db: &DataBase, id: usize) -> Result<Question, ()> {
+    db.get(id - 1).await.err_empty()
+}
+
+async fn get_question_data(
+    data: &AppState,
+    cache: &TemplateCache,
+    id: usize,
+) -> Option<ArcTemplateData> {
+    if let Some(value) = cache.get(&id) {
+        return Some(value);
+    }
+
+    match get_question(&data.db, id).await {
+        Ok(question) => {
+            let mut context = tera::to_value(question).expect("question serialize");
+            if context.is_object() {
+                let next_id = random_question_id(&data.database_distribution);
+                context["next"] = tera::to_value(next_id).expect("question id serialize");
+            }
+
+            let data = ArcTemplateData::new(context);
+            cache.insert(id, data.clone());
+            Some(data)
+        }
+        Err(_) => None,
+    }
+}
+
+async fn show_question_details(
+    template_name: &'static str,
+    data: &AppState,
+    cache: &TemplateCache,
+    id: usize,
+) -> Option<Template> {
+    get_question_data(data, cache, id)
+        .await
+        .map(|data| data.render(template_name))
+}
+
+#[get("/q/<id>/json")]
+async fn json_question(
+    data: &State<AppState>,
+    cache: &State<TemplateCache>,
+    id: usize,
+) -> Option<ArcTemplateData> {
+    get_question_data(data.inner(), cache.inner(), id).await
+}
+
 #[get("/q/<id>")]
-fn show_question(data: State<AppState>, id: u32) -> Template {
+async fn show_question(
-    show_question_details("question", data.inner(), id)
+    data: &State<AppState>,
+    cache: &State<TemplateCache>,
+    id: usize,
+) -> Option<Template> {
+    show_question_details("question", data.inner(), cache.inner(), id).await
 }
 
 #[get("/q/<id>/a")]
-fn show_answer(data: State<AppState>, id: u32) -> Template {
+async fn show_answer(
-    show_question_details("answer", data.inner(), id)
+    data: &State<AppState>,
+    cache: &State<TemplateCache>,
+    id: usize,
+) -> Option<Template> {
+    show_question_details("answer", data.inner(), cache.inner(), id).await
 }
 
 #[get("/q/0")]
@@ -98,46 +198,56 @@ fn answer0() -> Redirect {
     Redirect::to("/")
 }
 
+#[get("/q/0/json")]
+fn json0(data: &State<AppState>) -> Redirect {
+    let id = random_question_id(&data.database_distribution);
+    Redirect::temporary(format!("/q/{}/json", id))
+}
+
 #[get("/")]
-fn index(data: State<AppState>) -> Redirect {
+fn index(data: &State<AppState>) -> Redirect {
     let id = random_question_id(&data.database_distribution);
     Redirect::temporary(format!("/q/{}", id))
 }
 
 #[catch(404)]
-fn not_found(_req: &rocket::Request) -> Template {
+fn not_found(_req: &rocket::Request) -> WebError {
-    use std::collections::HashMap;
+    WebError::not_found()
-    let context: HashMap<String, String> = HashMap::new();
-    Template::render("404", &context)
 }
 
-fn rocket() -> Rocket {
+#[catch(500)]
-    let options: Options = serde_json::from_value(serde_json::json!({
+fn server_error(_req: &rocket::Request) -> WebError {
-    "read_only": true,
+    WebError::server_error()
-    "no_lock": true,
+}
-    }))
-    .unwrap();
 
-    let mut state = AppState {
+#[launch]
-        storage: Storage::new("db", options).expect("open db"),
+async fn rocket() -> _ {
-        database_distribution: Uniform::new(1, 3),
+    let state: AppState = async_db::Reader::new(DB_FILENAME)
-    };
+        .await
-    state.database_distribution = get_database_distribution(&state.storage);
+        .expect("open db")
+        .into();
+    let cache: TemplateCache = Cache::builder()
+        .time_to_idle(Duration::from_secs(15 * 60))
+        .max_capacity(300)
+        .build();
 
-    let state = state;
+    rocket::build()
-
-    rocket::ignite()
         .manage(state)
-        .register(catchers![not_found])
+        .manage(cache)
+        .register("/", catchers![not_found, server_error])
         .mount(
             "/",
-            routes![index, show_question, show_answer, question0, answer0],
+            routes![
+                index,
+                json_question,
+                show_question,
+                show_answer,
+                question0,
+                answer0,
+                json0
+            ],
         )
         .mount("/q", routes![index])
-        .mount("/q/static", StaticFiles::from("static/"))
+        .mount("/q/static", FileServer::new("static/", Options::None))
         .attach(Template::fairing())
 }
-
-fn main() {
-    rocket().launch();
-}

templates/404.html.tera

@@ -1,5 +1,13 @@
 {% extends "base" %}
 {% block title %}404{% endblock title %}
+{% block nav %} 
+{% endblock nav %}
 {% block content %}
-  <h1>404 - Could not find that page</h1>
+  <div class="content-block">
+    <div class="content-block-inner mt-4 px-4 py-2 fs-1 top-50 start-50 translate-middle">
+  <h1 class="display-4 d-flex justify-content-center text-center fw-bold">404</h1>
+  <br/>
+  <p>Нет такой страницы &#128532;</p>
+  </div>
+  </div>
 {% endblock content %}

templates/500.html.tera

@@ -0,0 +1,13 @@
+{% extends "base" %}
+{% block title %}404{% endblock title %}
+{% block nav %} 
+{% endblock nav %}
+{% block content %}
+  <div class="content-block">
+    <div class="content-block-inner mt-4 px-4 py-2 fs-1 top-50 start-50 translate-middle">
+  <h1 class="display-4 d-flex justify-content-center text-center fw-bold">500</h1>
+  <br/>
+  <p>&#128558; Ой, кажется у нас тут что то сломалось...</p>
+  </div>
+  </div>
+{% endblock content %}

templates/answer.html.tera

@@ -42,7 +42,7 @@
             <p><span>Тема: </span> {{ theme }}</p>
             {% endif %}
             {% if rating | length %}
-            <p><span>Рейтинг: </span> {{ author }}</p>
+            <p><span>Рейтинг: </span> {{ rating }}</p>
             {% endif %}
             {% if batch_info.description | length %}
             <p><span>Чемпионат: </span> {{ batch_info.description }}</p>