8 files changed, 69 insertions, 23 deletions

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index c1bfdf7..90a5fea 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -12,7 +12,6 @@ env:
   RUSTC_WRAPPER: "sccache"
   SQLX_OFFLINE: "true"
   CARGO_TERM_COLOR: always
-  CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER: arm-linux-gnueabihf-gcc
 
 jobs:
   build:
@@ -21,23 +20,25 @@ jobs:
       - name: Run sccache-cache
         uses: mozilla-actions/[email protected]
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
-          target: armv7-unknown-linux-gnueabihf
           components: rustfmt, clippy
           override: true
 
-      - name: Install arm linker
-        run: sudo apt update && sudo apt install gcc-arm-linux-gnueabihf -y
+      - name: Run cargo check
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
 
-      - name: Cargo build
+      - name: Run Clippy
         uses: actions-rs/cargo@v1
         with:
-          command: build
-          args: --release --target armv7-unknown-linux-gnueabihf
+          command: clippy
 
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
       - name: Login to DockerHub
@@ -50,8 +51,10 @@ jobs:
         id: docker_build
         uses: docker/build-push-action@v3
         with:
-          file: Dockerfile
           push: true
+          platforms: linux/amd64,linux/arm64
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
           tags: |
             ghcr.io/fxqnlr/webol:dev-latest
-            ghcr.io/fxqnlr/webol:dev-${{ github.run_number }}
\ No newline at end of file
+            ghcr.io/fxqnlr/webol:dev-${{ github.run_number }}
diff --git a/Dockerfile b/Dockerfile
index 0a7db3f..d4473e9 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,7 +1,26 @@
-FROM --platform=arm64 debian:12-slim
+FROM debian:bookworm AS deb_extractor
+RUN cd /tmp && \
+    apt-get update && apt-get download \
+        libc6 && \
+    mkdir /dpkg && \
+    for deb in *.deb; do dpkg --extract $deb /dpkg || exit 10; done
 
-WORKDIR /usr/local/webol
-COPY ./target/armv7-unknown-linux-gnueabihf/release/webol /usr/local/bin/webol
+FROM lukemathwalker/cargo-chef:latest-rust-1.73.0 as chef
+WORKDIR app
+
+FROM chef AS planner
+COPY . .
+RUN cargo chef prepare --recipe-path recipe.json
+
+FROM chef as builder
+COPY --from=planner /app/recipe.json recipe.json
+RUN cargo chef cook --release --recipe-path recipe.json
+COPY . .
+RUN cargo build --release
+
+FROM gcr.io/distroless/cc
+COPY --from=builder /app/target/release/webol /
+COPY --from=deb_extractor /dpkg /
 
 EXPOSE 7229
-CMD ["webol"]
+ENTRYPOINT ["./webol"]
\ No newline at end of file
diff --git a/README.md b/README.md
index f062819..fdc7ad2 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,9 @@
-# webol
\ No newline at end of file
+# webol
+
+DATABASE_URL: `String`
+
+WEBOL_APIKEY: `String`
+
+WEBOL_SERVERADDR: `Option<String>`
+
+WEBOL_BINDADDR: `Option<String>`
diff --git a/docker-compose.yml b/docker-compose.yml
index 1980356..9d73e9b 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -3,6 +3,7 @@ version: '3.1'
 services:
   db:
     image: postgres
+    container_name: webol_dev_postgres
     restart: no
     environment:
       POSTGRES_PASSWORD: postgres
diff --git a/src/auth.rs b/src/auth.rs
index b7693a0..81e798f 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -1,21 +1,26 @@
 use std::error::Error;
 use axum::headers::HeaderValue;
 use axum::http::StatusCode;
-use tracing::error;
+use tracing::{debug, error, trace};
 use crate::auth::AuthError::{MissingSecret, ServerError, WrongSecret};
 use crate::config::SETTINGS;
 
 pub fn auth(secret: Option<&HeaderValue>) -> Result<bool, AuthError> {
+    debug!("auth request with secret {:?}", secret);
     if let Some(value) = secret {
+        trace!("value exists");
         let key = SETTINGS
             .get_string("apikey")
             .map_err(|err| ServerError(Box::new(err)))?;
         if value.to_str().map_err(|err| ServerError(Box::new(err)))? == key.as_str() {
+            debug!("successful auth");
             Ok(true)
         } else {
+            debug!("unsuccessful auth (wrong secret)");
             Err(WrongSecret)
         }
     } else {
+        debug!("unsuccessful auth (no secret)");
         Err(MissingSecret)
     }
 }
diff --git a/src/main.rs b/src/main.rs
index bb37dc2..b7306ea 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,6 +7,7 @@ use sqlx::postgres::PgPoolOptions;
 use time::util::local_offset;
 use tracing::{debug, info, level_filters::LevelFilter};
 use tracing_subscriber::{EnvFilter, fmt::{self, time::LocalTime}, prelude::*};
+use crate::config::SETTINGS;
 use crate::routes::device::{get_device, post_device, put_device};
 use crate::routes::start::start;
 
@@ -37,13 +38,12 @@ async fn main() {
 
     let version = env!("CARGO_PKG_VERSION");
 
-    info!("starting webol v{}", version);
+    info!("start webol v{}", version);
 
     let db = init_db_pool().await;
 
     let shared_state = Arc::new(AppState { db });
 
-    // build our application with a single route
     let app = Router::new()
         .route("/start", post(start))
         .route("/device", get(get_device))
@@ -51,8 +51,9 @@ async fn main() {
         .route("/device", post(post_device))
         .with_state(shared_state);
 
-    // run it with hyper on localhost:3000
-    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
+    let addr = SETTINGS.get_string("serveraddr").unwrap_or("0.0.0.0:7229".to_string());
+    info!("start server on {}", addr);
+    axum::Server::bind(&addr.parse().unwrap())
         .serve(app.into_make_service())
         .await
         .unwrap();
@@ -63,9 +64,13 @@ pub struct AppState {
 }
 
 async fn init_db_pool() -> PgPool {
+    #[cfg(not(debug_assertions))]
+    let db_url = SETTINGS.get_string("database.url").unwrap();
+
+    #[cfg(debug_assertions)]
     let db_url = env::var("DATABASE_URL").unwrap();
 
-    debug!("attempting to connect dbPool to '{}'", db_url);
+    debug!("attempt to connect dbPool to '{}'", db_url);
 
     let pool = PgPoolOptions::new()
         .max_connections(5)
@@ -76,4 +81,4 @@ async fn init_db_pool() -> PgPool {
     info!("dbPool successfully connected to '{}'", db_url);
 
     pool
-}
\ No newline at end of file
+}
diff --git a/src/routes/device.rs b/src/routes/device.rs
index d5d7144..025c7d0 100644
--- a/src/routes/device.rs
+++ b/src/routes/device.rs
@@ -4,11 +4,13 @@ use axum::headers::HeaderMap;
 use axum::Json;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
+use tracing::info;
 use crate::auth::auth;
 use crate::db::Device;
 use crate::error::WebolError;
 
 pub async fn get_device(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<GetDevicePayload>) -> Result<Json<Value>, WebolError> {
+    info!("GET request");
     let secret = headers.get("authorization");
     if auth(secret).map_err(WebolError::Auth)? {
         let device = sqlx::query_as!(
@@ -33,6 +35,7 @@ pub struct GetDevicePayload {
 }
 
 pub async fn put_device(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<PutDevicePayload>) -> Result<Json<Value>, WebolError> {
+    info!("PUT request");
     let secret = headers.get("authorization");
     if auth(secret).map_err(WebolError::Auth)? {
         sqlx::query!(
@@ -64,6 +67,7 @@ pub struct PutDeviceResponse {
 }
 
 pub async fn post_device(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<PostDevicePayload>) -> Result<Json<Value>, WebolError> {
+    info!("POST request");
     let secret = headers.get("authorization");
     if auth(secret).map_err(WebolError::Auth)? {
         let device = sqlx::query_as!(
diff --git a/src/routes/start.rs b/src/routes/start.rs
index d16ea4e..163d58c 100644
--- a/src/routes/start.rs
+++ b/src/routes/start.rs
@@ -12,6 +12,7 @@ use crate::db::Device;
 use crate::error::WebolError;
 
 pub async fn start(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<StartPayload>) -> Result<Json<Value>, WebolError> {
+    info!("POST request");
     let secret = headers.get("authorization");
     if auth(secret).map_err(WebolError::Auth)? {
         let device = sqlx::query_as!(
@@ -28,7 +29,7 @@ pub async fn start(State(state): State<Arc<crate::AppState>>, headers: HeaderMap
 
         let bind_addr = SETTINGS
             .get_string("bindaddr")
-            .map_err(|err| WebolError::Server(Box::new(err)))?;
+            .unwrap_or("0.0.0.0:1111".to_string());
 
         let _ = send_packet(
             &bind_addr.parse().map_err(|err| WebolError::Server(Box::new(err)))?,