Try litefs for db

Author: 8hantanu

Dockerfile

@@ -7,17 +7,19 @@ RUN cargo chef prepare --recipe-path recipe.json
 
 FROM chef AS builder
 COPY --from=planner /app/recipe.json recipe.json
-# Build dependencies - this is the caching Docker layer!
 RUN cargo chef cook --release --recipe-path recipe.json
-# Build application
 COPY . .
 RUN cargo build --release --bin mdow
 
-# We do not need the Rust toolchain to run the binary!
-FROM debian:bookworm-slim AS runtime
+FROM flyio/litefs:0.5 AS runtime
+# Install required packages
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
 WORKDIR /app
-RUN mkdir -p /data && \
-    chown 1000:1000 /data && \
-    chmod 755 /data
 COPY --from=builder /app/target/release/mdow /usr/local/bin
-ENTRYPOINT ["/usr/local/bin/mdow"]
+COPY litefs.yml /etc/litefs.yml
+
+ENV DATABASE_URL="sqlite:/litefs/mdow.db"
+ENTRYPOINT ["/usr/local/bin/litefs"]

fly.toml

@@ -9,8 +9,9 @@ primary_region = 'lhr'
 [build]
 
 [env]
-  PORT = '8080'
-  DATABASE_URL = "sqlite:/data/mdow.db"
+  PORT = '8081'
+  DATABASE_URL = "sqlite:/litefs/mdow.db"
+  FLY_CONSUL_URL = "consul+tls://fly-consul.fly.dev:8501"
 
 [http_service]
   internal_port = 8080
@@ -21,8 +22,8 @@ primary_region = 'lhr'
   processes = ['app']
 
 [[mounts]]
-  source = "mdow_data"
-  destination = "/data"
+  source = "mdow_litefs"
+  destination = "/var/lib/litefs"
 
 [[vm]]
   memory = '256mb'

litefs.yml

@@ -0,0 +1,20 @@
+fuse:
+  dir: "/litefs"
+
+data:
+  dir: "/var/lib/litefs"
+
+proxy:
+  addr: ":8080"
+  target: "localhost:8081"
+  db: "mdow.db"
+
+exec:
+  - cmd: "/usr/local/bin/mdow"
+    if-primary: true
+
+lease:
+  type: "consul"
+  consul:
+    url: "${FLY_CONSUL_URL}"
+    key: "litefs/${FLY_APP_NAME}" 

src/main.rs

@@ -15,9 +15,11 @@ use std::net::SocketAddr;
 use serde::Deserialize;
 use pulldown_cmark::{Parser, Options, html::push_html};
 use html_escape::encode_text;
-use sqlx::sqlite::SqlitePool;
+use sqlx::sqlite::{SqlitePool, SqlitePoolOptions, SqliteConnectOptions, SqliteJournalMode};
 use uuid::Uuid;
-use chrono::{DateTime, Utc, Duration};
+use std::str::FromStr;
+use std::time::Duration;
+use chrono::{DateTime, Utc};
 
 #[derive(Deserialize)]
 struct MarkdownInput {
@@ -149,7 +151,7 @@ async fn share_markdown(
 ) -> impl IntoResponse {
     let id = Uuid::new_v4().to_string();
     let now = Utc::now();
-    let expires_at = now + Duration::days(30);
+    let expires_at = now + chrono::Duration::days(30);
 
     // Store the document
     sqlx::query(
@@ -315,21 +317,16 @@ async fn main() {
     let db_path = std::env::var("DATABASE_URL")
         .unwrap_or_else(|_| "sqlite:data/database.db".to_string());
 
-    // If using a custom path, ensure the directory exists
-    if let Some(path) = db_path.strip_prefix("sqlite:") {
-        if let Some(parent) = std::path::Path::new(path).parent() {
-            match std::fs::create_dir_all(parent) {
-                Ok(_) => println!("Database directory created/verified at: {}", parent.display()),
-                Err(e) => {
-                    eprintln!("Failed to create database directory: {}", e);
-                    std::process::exit(1);
-                }
-            }
-        }
-    }
-
-    // Initialize the database pool
-    let pool = SqlitePool::connect(&db_path)
+    // Configure SQLite connection pool with WAL mode and busy timeout
+    let pool = SqlitePoolOptions::new()
+        .max_connections(5)
+        .connect_with(
+            SqliteConnectOptions::from_str(&db_path)
+                .unwrap()
+                .create_if_missing(true)
+                .journal_mode(SqliteJournalMode::Wal)
+                .busy_timeout(Duration::from_secs(30))
+        )
         .await
         .expect("Failed to connect to database");
 
@@ -358,7 +355,14 @@ async fn main() {
         .fallback(handle_404)
         .with_state(pool);
 
-    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
+    // Get port from environment or default to 8081
+    let port =
+        std::env::var("PORT")
+            .ok()
+            .and_then(|p| p.parse().ok())
+            .unwrap_or(8081);
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], port));
     println!("Listening on {}", addr);
     axum::Server::bind(&addr)
         .serve(app.into_make_service())