mini_moka

b4tman/qchgk_web#1
using moka

.drone.yml

@@ -0,0 +1,12 @@
+kind: pipeline
+name: default
+
+steps:
+- name: build
+  image: rustlang/rust:nightly-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
+db.dat
+/db

Cargo.toml

@@ -13,11 +13,9 @@ readme = "README.md"
 rand="0.8"
 serde="1.0"
 serde_json="1.0"
-ledb = {git = "https://github.com/b4tman/ledb.git", rev="a646b90e", package="ledb"}
 rocket="0.4"
-chgk_ledb_lib = {git = "https://gitea.b4tman.ru/b4tman/chgk_ledb.git", rev="e521e39f5e", package="chgk_ledb_lib"}
-
-# lmdb-zero="0.4"
+chgk_ledb_lib = {git = "https://gitea.b4tman.ru/b4tman/chgk_ledb.git", rev="27260695f7", package="chgk_ledb_lib"}
+mini-moka = "0.10.0"
 
 [dependencies.rocket_contrib]
 version = "0.4"

src/main.rs

@@ -1,6 +1,5 @@
 #![feature(proc_macro_hygiene, decl_macro)]
 
-extern crate ledb;
 extern crate serde;
 extern crate serde_json;
 
@@ -16,10 +15,17 @@ use rocket_contrib::templates::Template;
 use rand::distributions::Uniform;
 use rand::Rng;
 
-use ledb::{Options, Storage};
+use std::ops::Deref;
+use std::sync::Arc;
 
+use chgk_ledb_lib::db;
 use chgk_ledb_lib::questions::Question;
 
+use mini_moka::sync::Cache;
+use std::time::Duration;
+
+const DB_FILENAME: &str = "db.dat";
+
 trait ErrorEmpty {
     type Output;
     fn err_empty(self) -> Result<Self::Output, ()>;
@@ -32,60 +38,93 @@ impl<T, E> ErrorEmpty for Result<T, E> {
     }
 }
 
+#[derive(Clone)]
+struct ArcTemplateData {
+    value: Arc<serde_json::Value>,
+}
+
+impl ArcTemplateData {
+    fn new(value: serde_json::Value) -> ArcTemplateData {
+        ArcTemplateData {
+            value: Arc::new(value),
+        }
+    }
+    fn render(&self, name: &'static str) -> Template {
+        Template::render(name, self.value.deref())
+    }
+}
+
+type TemplateCache = mini_moka::sync::Cache<usize, ArcTemplateData>;
+
+type DataBaseInner = db::Reader<Question>;
+type DataBase = Arc<DataBaseInner>;
 struct AppState {
-    storage: Storage,
-    database_distribution: Uniform<u32>,
+    db: DataBase,
+    database_distribution: Uniform<usize>,
 }
 
-fn get_database_distribution(storage: &Storage) -> Uniform<u32> {
-    let collection = storage
-        .collection("questions")
-        .expect("collection \"questions\"");
-    let last_id = collection.last_id().expect("\"questions\" last_id");
+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);
 
-    rand::distributions::Uniform::new_inclusive(1u32, last_id)
+        Self {
+            db,
+            database_distribution,
+        }
+    }
 }
 
-fn random_question_id(database_distribution: &Uniform<u32>) -> u32 {
+fn random_question_id(database_distribution: &Uniform<usize>) -> usize {
     let mut rng = rand::thread_rng();
     rng.sample(database_distribution)
 }
 
-fn get_question(storage: &Storage, id: u32) -> Result<Question, ()> {
-    storage
-        .collection("questions")
-        .err_empty()?
-        .get::<Question>(id)
-        .err_empty()?
-        .ok_or(())
+fn get_question(db: &DataBase, id: usize) -> Result<Question, ()> {
+    db.get(id - 1).err_empty()
 }
 
-fn show_question_details(template_name: &'static str, data: &AppState, id: u32) -> Template {
-    match get_question(&data.storage, id) {
+fn show_question_details(
+    template_name: &'static str,
+    data: &AppState,
+    cache: &TemplateCache,
+    id: usize,
+) -> Template {
+    if let Some(value) = cache.get(&id) {
+        return value.render(template_name);
+    }
+
+    match get_question(&data.db, id) {
         Ok(question) => {
             let mut context = serde_json::to_value(question).expect("question serialize");
             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)
+
+            let value = ArcTemplateData::new(context);
+            let result = value.render(template_name);
+            cache.insert(id, value);
+
+            result
         }
         Err(_) => {
             use std::collections::HashMap;
             let context: HashMap<String, String> = HashMap::new();
-            Template::render("404", &context)
+            Template::render("404", context)
         }
     }
 }
 
 #[get("/q/<id>")]
-fn show_question(data: State<AppState>, id: u32) -> Template {
-    show_question_details("question", data.inner(), id)
+fn show_question(data: State<AppState>, cache: State<TemplateCache>, id: usize) -> Template {
+    show_question_details("question", data.inner(), cache.inner(), id)
 }
 
 #[get("/q/<id>/a")]
-fn show_answer(data: State<AppState>, id: u32) -> Template {
-    show_question_details("answer", data.inner(), id)
+fn show_answer(data: State<AppState>, cache: State<TemplateCache>, id: usize) -> Template {
+    show_question_details("answer", data.inner(), cache.inner(), id)
 }
 
 #[get("/q/0")]
@@ -108,26 +147,19 @@ fn index(data: State<AppState>) -> Redirect {
 fn not_found(_req: &rocket::Request) -> Template {
     use std::collections::HashMap;
     let context: HashMap<String, String> = HashMap::new();
-    Template::render("404", &context)
+    Template::render("404", context)
 }
 
 fn rocket() -> Rocket {
-    let options: Options = serde_json::from_value(serde_json::json!({
-    "read_only": true,
-    "no_lock": true,
-    }))
-    .unwrap();
-
-    let mut state = AppState {
-        storage: Storage::new("db", options).expect("open db"),
-        database_distribution: Uniform::new(1, 3),
-    };
-    state.database_distribution = get_database_distribution(&state.storage);
-
-    let state = state;
+    let state: AppState = db::Reader::new(DB_FILENAME, 2048).expect("open db").into();
+    let cache: TemplateCache = Cache::builder()
+        .time_to_idle(Duration::from_secs(15 * 60))
+        .max_capacity(300)
+        .build();
 
     rocket::ignite()
         .manage(state)
+        .manage(cache)
         .register(catchers![not_found])
         .mount(
             "/",