Replace rocket with axum

Cargo.toml

@@ -4,5 +4,9 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-rocket = { version = "0.5.0-rc.2", features = ["json"]}
-serde_json = "1.0.91"
+axum = "0.6.20"
+serde_json = "1.0.91"
+tokio = { version = "1.32.0", features = ["macros", "rt", "rt-multi-thread"] }
+tracing = "0.1.37"
+serde = { version = "1.0.188", features = ["derive"] }
+tracing-subscriber = "0.3.17"

src/main.rs

@@ -1,50 +1,42 @@
-#[macro_use] extern crate rocket;
-
-use std::sync::atomic::Ordering;
-use std::sync::Mutex;
-use rocket::serde::{Deserialize, Serialize, json::Json};
-use rocket::State;
-use rocket::Request;
-use rocket::Response;
-use rocket::http::Header;
+use axum::extract::{Path, State};
+use axum::{
+    routing::{get, post},
+    Json, Router,
+};
+use serde::{Deserialize, Serialize};
+use std::net::SocketAddr;
+use std::sync::{Arc, Mutex};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(crate = "rocket::serde")]
 struct Page {
     slug: String,
-    votes: i32
+    votes: i32,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(crate = "rocket::serde")]
 struct VoteRecord {
-    pages: Vec<Page>
+    pages: Vec<Page>,
 }
 
+#[derive(Clone)]
 struct AppState {
-    record: Mutex<VoteRecord>
+    record: Arc<Mutex<VoteRecord>>,
 }
 
-#[get("/votes/view/<slug>")]
-fn view_votes(slug: String, state: &State<AppState>) -> Json<Page> {
-    println!("Requesting votes for {slug}");
+async fn view_votes(State(state): State<AppState>, Path(slug): Path<String>) -> Json<Page> {
+    tracing::info!("Requesting votes for {slug}");
 
-    //Json(state.leaderboard.lock().unwrap().clone())
     for page in &state.record.lock().unwrap().pages {
         if page.slug == slug {
-            return Json(page.clone())
+            return Json(page.clone());
         }
     }
 
-    return Json(Page {
-        slug,
-        votes: 0
-    })
+    return Json(Page { slug, votes: 0 });
 }
 
-#[post("/votes/submit/<slug>")]
-fn leaderboard_submit_score(slug: String, state: &State<AppState>) {
-    println!("Submitting vote for {slug}");
+async fn leaderboard_submit_score(State(state): State<AppState>, Path(slug): Path<String>) {
+    tracing::info!("Submitting vote for {slug}");
 
     let mut found = false;
     for mut page in &mut state.record.lock().unwrap().pages {
@@ -55,61 +47,48 @@ fn leaderboard_submit_score(slug: String, state: &State<AppState>) {
     }
 
     if !found {
-        state.record.lock().unwrap().pages.push(Page {
-            slug,
-            votes: 1
-        });
-    }
-
-    println!("{:#?}", state.record.lock());
-}
-
-use rocket::fairing::{Fairing, Info, Kind};
-
-pub struct CORS;
-
-#[rocket::async_trait]
-impl Fairing for CORS {
-    fn info(&self) -> Info {
-        Info {
-            name: "Add CORS headers to responses",
-            kind: Kind::Response
-        }
-    }
-
-    async fn on_response<'r>(&self, _request: &'r Request<'_>, response: &mut Response<'r>) {
-        response.set_header(Header::new("Access-Control-Allow-Origin", "*"));
-        response.set_header(Header::new("Access-Control-Allow-Methods", "POST, GET, PATCH, OPTIONS"));
-        response.set_header(Header::new("Access-Control-Allow-Headers", "*"));
-        response.set_header(Header::new("Access-Control-Allow-Credentials", "true"));
+        state
+            .record
+            .lock()
+            .unwrap()
+            .pages
+            .push(Page { slug, votes: 1 });
     }
 }
 
-#[rocket::main]
-async fn main() -> Result<(), rocket::error::Error> {
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt::init();
+
     let initial_state = if let Ok(data) = std::fs::read_to_string("votes.json") {
         AppState {
-            record: Mutex::new(serde_json::from_str(&data).expect("Failed to parse"))
+            record: Arc::new(Mutex::new(
+                serde_json::from_str(&data).expect("Failed to parse"),
+            )),
         }
     } else {
         AppState {
-            record: Mutex::new(VoteRecord
-            {
-                pages: vec![]
-            })
+            record: Arc::new(Mutex::new(VoteRecord { pages: vec![] })),
         }
     };
 
-    let rocket = rocket::build()
-        .mount("/", routes![view_votes, leaderboard_submit_score])
-        .manage(initial_state)
-        .attach(CORS)
-        .ignite().await?
-        .launch().await?;
+    let app = Router::new()
+        .route("/votes/submit/:slug", post(leaderboard_submit_score))
+        .route("/votes/view/:slug", get(view_votes))
+        .with_state(initial_state.clone());
 
-    let state = rocket.state::<AppState>().unwrap();
+    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
+    tracing::info!("Listening on {}", addr);
+    axum::Server::bind(&addr)
+        .serve(app.into_make_service())
+        .await
+        .unwrap();
 
-    serde_json::to_writer(&std::fs::File::create("votes.json").unwrap(), &state.record).expect("TODO: panic message");
-
-    Ok(())
-}
+    let state_clone = initial_state.clone();
+    let st = state_clone.record.lock().unwrap();
+    serde_json::to_writer(
+        &std::fs::File::create("votes.json").unwrap(),
+        &st.to_owned(),
+    )
+    .expect("TODO: panic message");
+}