initial commit

.dockerignore

@@ -0,0 +1,3 @@
+.env
+db.sqlite
+.git

.gitignore

@@ -0,0 +1,3 @@
+target
+.env
+db.sqlite

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "minibookfluxmark"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+poem = "3.1.12"
+poem-openapi = { version = "5.1.16", features = ["swagger-ui"] }
+rusqlite = "0.37.0"
+tokio = { version = "1.47.1", features = ["macros", "rt-multi-thread"] }

Dockerfile

@@ -0,0 +1,74 @@
+
+# syntax=docker/dockerfile:1
+
+# Comments are provided throughout this file to help you get started.
+# If you need more help, visit the Dockerfile reference guide at
+# https://docs.docker.com/engine/reference/builder/
+
+################################################################################
+# Create a stage for building the application.
+
+ARG RUST_VERSION=1.89.0
+FROM rust:${RUST_VERSION}-slim-bullseye AS build
+ARG TARGET=release
+ARG APP_NAME
+WORKDIR /app
+
+RUN apt update && apt install -y pkg-config libssl-dev libsqlite3-dev
+
+# Build the application.
+# Leverage a cache mount to /usr/local/cargo/registry/
+# for downloaded dependencies and a cache mount to /app/target/ for 
+# compiled dependencies which will speed up subsequent builds.
+# Leverage a bind mount to the src directory to avoid having to copy the
+# source code into the container. Once built, copy the executable to an
+# output directory before the cache mounted /app/target is unmounted.
+RUN --mount=type=bind,source=src,target=src \
+    --mount=type=bind,source=Cargo.toml,target=Cargo.toml \
+    --mount=type=bind,source=Cargo.lock,target=Cargo.lock \
+    --mount=type=cache,target=/app/target/ \
+    --mount=type=cache,target=/usr/local/cargo/registry/ \
+    <<EOF
+set -e
+echo TARGET=$TARGET
+echo APP_NAME=$APP_NAME
+[ "$TARGET" = "release" ] && cargo build --locked --release || cargo build --locked
+cp ./target/$TARGET/$APP_NAME /bin/server
+EOF
+
+################################################################################
+# Create a new stage for running the application that contains the minimal
+# runtime dependencies for the application. This often uses a different base
+# image from the build stage where the necessary files are copied from the build
+# stage.
+#
+# The example below uses the debian bullseye image as the foundation for    running the app.
+# By specifying the "bullseye-slim" tag, it will also use whatever happens to    be the
+# most recent version of that tag when you build your Dockerfile. If
+# reproducability is important, consider using a digest
+# (e.g.,    debian@sha256:ac707220fbd7b67fc19b112cee8170b41a9e97f703f588b2cdbbcdcecdd8af57).
+FROM debian:bullseye-slim AS final
+
+RUN apt update && apt install -y libssl-dev openssl ca-certificates curl libsqlite3-dev
+
+# Create a non-privileged user that the app will run under.
+# See https://docs.docker.com/develop/develop-images/dockerfile_best-practices/   #user
+ARG UID=10001
+RUN adduser \
+    --disabled-password \
+    --gecos "" \
+    --home "/nonexistent" \
+    --shell "/sbin/nologin" \
+    --no-create-home \
+    --uid "${UID}" \
+    appuser
+USER appuser
+
+# Copy the executable from the "build" stage.
+COPY --from=build /bin/server /bin/
+
+# Expose the port that the application listens on.
+EXPOSE 3000
+
+# What the container should run when it is started.
+CMD ["/bin/server"]

compose.yaml

@@ -0,0 +1,14 @@
+services:
+  site:
+    build:
+      context: .
+      target: final
+      args:
+        APP_NAME: minibookfluxmark
+    ports:
+      - 3937:3000
+    env_file: ".env"
+    environment:
+      MINIBOOKFLUXMARK_DB_PATH: /db.sqlite
+    volumes:
+      - ./db.sqlite:/db.sqlite

src/main.rs

@@ -0,0 +1,184 @@
+use std::{env, error::Error};
+
+use poem::{Route, Server, listener::TcpListener};
+use poem_openapi::{
+    ApiResponse, Object, OpenApi, OpenApiService, SecurityScheme, auth::Bearer, payload::Json,
+    payload::PlainText,
+};
+use tokio::task::spawn_blocking;
+
+struct Bookmark {
+    id: i32,
+    title: String,
+    url: String,
+    description: String,
+}
+
+#[derive(SecurityScheme)]
+#[oai(ty = "bearer", key_name = "X-Minibookfluxmark-Auth", key_in = "header")]
+struct BearerAuth(Bearer);
+
+impl BearerAuth {
+    fn check(&self) -> bool {
+        self.0.token == std::env::var("MINIBOOKFLUXMARK_ACCESS_TOKEN").unwrap()
+    }
+}
+
+#[derive(Object, Clone)]
+struct BookmarkRequest {
+    title: String,
+    url: String,
+    description: String,
+}
+
+#[derive(ApiResponse)]
+enum AddBookmarkResponse {
+    #[oai(status = 200)]
+    Ok,
+    #[oai(status = 403)]
+    NotAuthorized,
+    #[oai(status = 500)]
+    ServerError,
+}
+
+#[derive(ApiResponse)]
+enum FeedResponse {
+    #[oai(status = 200)]
+    Ok(PlainText<String>),
+    #[oai(status = 403)]
+    NotAuthorized,
+    #[oai(status = 500)]
+    ServerError,
+}
+
+struct Api;
+
+#[OpenApi]
+impl Api {
+    #[oai(path = "/add", method = "post")]
+    async fn post_bookmark(
+        &self,
+        body: Json<BookmarkRequest>,
+        auth: BearerAuth,
+    ) -> AddBookmarkResponse {
+        if !auth.check() {
+            return AddBookmarkResponse::NotAuthorized;
+        }
+
+        if let Err(e) = spawn_blocking(move || {
+            let db_conn = match rusqlite::Connection::open(
+                env::var("MINIBOOKFLUXMARK_DB_PATH").unwrap_or(String::from("db.sqlite")),
+            ) {
+                Ok(c) => c,
+                Err(e) => {
+                    println!("Failde to open db: {e}");
+                    return Err(e);
+                }
+            };
+            db_conn.execute(
+                "insert into bookmarks (title, url, description) values (?1, ?2, ?3)",
+                (&body.title, &body.url, &body.description),
+            )?;
+
+            Ok(())
+        })
+        .await
+        {
+            println!("Failed to spawn database save: {e}");
+            return AddBookmarkResponse::ServerError;
+        }
+
+        AddBookmarkResponse::Ok
+    }
+
+    #[oai(path = "/feed", method = "get")]
+    async fn get_feed(&self, auth: BearerAuth) -> FeedResponse {
+        if !auth.check() {
+            return FeedResponse::NotAuthorized;
+        }
+
+        let mut resp = String::new();
+        resp.push_str(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<rss version=\"2.0\">\n<channel>",
+        );
+
+        match spawn_blocking(move || {
+            let db_conn = match rusqlite::Connection::open(
+                env::var("MINIBOOKFLUXMARK_DB_PATH").unwrap_or(String::from("db.sqlite")),
+            ) {
+                Ok(c) => c,
+                Err(e) => {
+                    println!("Failde to open db: {e}");
+                    return Err(e);
+                }
+            };
+            let mut query = db_conn.prepare("select id, title, url, description from bookmarks")?;
+            let bookmark_iter = query.query_map([], |row| {
+                Ok(Bookmark {
+                    id: row.get(0)?,
+                    title: row.get(1)?,
+                    url: row.get(2)?,
+                    description: row.get(3)?,
+                })
+            })?;
+            let bookmarks = Vec::from_iter(bookmark_iter.flatten());
+            Ok(bookmarks)
+        })
+        .await
+        {
+            Ok(Ok(bookmarks)) => {
+                for b in bookmarks {
+                    resp.push_str(&format!("<item>\n<title>{}</title>\n<link>{}</link>\n<description>{}</description>\n</item>", b.title, b.url, b.description));
+                }
+            }
+            Ok(Err(e)) => {
+                println!("Failed to read database: {e}");
+                return FeedResponse::ServerError;
+            }
+            Err(e) => {
+                println!("Failed to spawn database read: {e}");
+                return FeedResponse::ServerError;
+            }
+        }
+
+        resp.push_str("</channel>\n</rss>");
+
+        FeedResponse::Ok(PlainText(resp))
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    match spawn_blocking(move || {
+            let db_conn = match rusqlite::Connection::open(
+                env::var("MINIBOOKFLUXMARK_DB_PATH").unwrap_or(String::from("db.sqlite")),
+            ) {
+                Ok(c) => c,
+                Err(e) => {
+                    println!("Failde to open db: {e}");
+                    return;
+                }
+            };
+            db_conn
+                .execute(
+                    "create table if not exists bookmarks (id integer primary key, title text not null, url text not null, description text not null)", ()
+                )
+                .unwrap();
+        })
+        .await
+        {
+            Ok(_) => (),
+            Err(e) => println!("Failed to spawn database save: {e}"),
+        }
+    let api_service = OpenApiService::new(Api, "minibookfluxmark", "0.1").server("/api/v1");
+    let ui = api_service.swagger_ui();
+    let app = Route::new()
+        .nest("/api/v1/", api_service)
+        .nest("/ui/v1/", ui);
+
+    Server::new(TcpListener::bind("0.0.0.0:3000"))
+        .run(app)
+        .await?;
+
+    Ok(())
+}