Basic steam login and demo upload

backend/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "backend"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+async-trait = "0.1.82"
+axum = { version = "0.7.5", features = ["multipart"] }
+serde = { version = "1.0.210", features = ["derive"] }
+steam-openid = "0.2.0"
+time = "0.3.36"
+tokio = { version = "1.40.0", features = ["rt", "macros", "net", "mio"] }
+tower-sessions = "0.13.0"
+tower-http = { version = "0.5", features = ["fs"] }
+tracing = { version = "0.1.40", features = ["async-await"] }
+tracing-subscriber = "0.3.18"
+futures-util = "0.3"

backend/src/lib.rs

@@ -0,0 +1,76 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct UserSessionData {
+    pub steam_id: Option<u64>,
+}
+
+impl Default for UserSessionData {
+    fn default() -> Self {
+        Self { steam_id: None }
+    }
+}
+
+pub struct UserSession {
+    pub session: tower_sessions::Session,
+    data: UserSessionData,
+}
+
+impl UserSession {
+    const KEY: &'static str = "user.data";
+
+    pub fn data(&self) -> &UserSessionData {
+        &self.data
+    }
+
+    pub async fn modify_data<F>(&mut self, func: F)
+    where
+        F: FnOnce(&mut UserSessionData),
+    {
+        let mut entry = &mut self.data;
+        func(&mut entry);
+
+        self.session.insert(Self::KEY, entry).await.unwrap();
+    }
+}
+
+#[async_trait::async_trait]
+impl<S> axum::extract::FromRequestParts<S> for UserSession
+where
+    S: Send + Sync,
+{
+    type Rejection = (axum::http::StatusCode, &'static str);
+
+    async fn from_request_parts(
+        req: &mut axum::http::request::Parts,
+        state: &S,
+    ) -> Result<Self, Self::Rejection> {
+        let session = tower_sessions::Session::from_request_parts(req, state).await?;
+
+        let guest_data: UserSessionData = session.get(Self::KEY).await.unwrap().unwrap_or_default();
+
+        Ok(Self {
+            session,
+            data: guest_data,
+        })
+    }
+}
+
+pub async fn get_demo_from_upload(name: &str, mut form: axum::extract::Multipart) -> Option<axum::body::Bytes> {
+    while let Ok(field) = form.next_field().await {
+        let field = match field {
+            Some(f) => f,
+            None => continue,
+        };
+
+        if field.name().map(|n| n != name).unwrap_or(false) {
+            continue;
+        }
+
+        if let Ok(data) = field.bytes().await {
+            return Some(data);
+        }
+    }
+
+    None
+}

backend/src/main.rs

@@ -0,0 +1,105 @@
+use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
+
+static OPENID: std::sync::LazyLock<steam_openid::SteamOpenId> = std::sync::LazyLock::new(|| {
+    steam_openid::SteamOpenId::new("http://192.168.0.156:3000", "/api/steam/callback").unwrap()
+});
+static UPLOAD_FOLDER: &str = "uploads/";
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let registry = tracing_subscriber::Registry::default()
+        .with(tracing_subscriber::fmt::layer())
+        .with(tracing_subscriber::filter::filter_fn(|meta| {
+            meta.target().contains("backend")
+        }));
+    tracing::subscriber::set_global_default(registry).unwrap();
+
+    tracing::info!("Starting...");
+
+    let session_store = tower_sessions::MemoryStore::default();
+    let session_layer = tower_sessions::SessionManagerLayer::new(session_store)
+        .with_secure(false)
+        .with_expiry(tower_sessions::Expiry::OnInactivity(
+            time::Duration::minutes(15),
+        ));
+
+    if !tokio::fs::try_exists(UPLOAD_FOLDER).await.unwrap_or(false) {
+        tokio::fs::create_dir_all(UPLOAD_FOLDER).await.unwrap();
+    }
+
+    let router = axum::Router::new()
+        .nest_service(
+            "/api/",
+            axum::Router::new()
+                .route("/steam/callback", axum::routing::get(steam_callback))
+                .route("/steam/login", axum::routing::get(steam_login))
+                .route("/demos/upload", axum::routing::post(upload).layer(axum::extract::DefaultBodyLimit::max(1024*1024*500)))
+                .route("/demos/list", axum::routing::get(demos_list))
+        )
+        .layer(session_layer)
+        .nest_service("/", tower_http::services::ServeDir::new("frontend/dist/"));
+
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, router).await.unwrap();
+}
+
+async fn upload(session: backend::UserSession, form: axum::extract::Multipart) -> Result<axum::response::Redirect, (axum::http::StatusCode, &'static str)> {
+    let steam_id = session.data().steam_id.ok_or_else(|| (axum::http::StatusCode::UNAUTHORIZED, "Not logged in"))?;
+
+    tracing::info!("Upload for Session: {:?}", steam_id);
+
+    let file_content = backend::get_demo_from_upload("demo", form).await.unwrap();
+
+    let user_folder = std::path::Path::new(UPLOAD_FOLDER).join(format!("{}/", steam_id));
+    if !tokio::fs::try_exists(&user_folder).await.unwrap_or(false) {
+        tokio::fs::create_dir_all(&user_folder).await.unwrap();
+    }
+
+    let timestamp_secs = std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH).unwrap().as_secs();
+    let demo_file_path = user_folder.join(format!("{}.dem", timestamp_secs));
+
+    tokio::fs::write(demo_file_path, file_content).await.unwrap();
+
+    // TODO
+    // Insert Demo into users list of demos and possibly queue demo for analysis?
+
+    Ok(axum::response::Redirect::to("/"))
+}
+
+async fn steam_login() -> Result<axum::response::Redirect, axum::http::StatusCode> {
+    let url = OPENID.get_redirect_url();
+
+    Ok(axum::response::Redirect::to(url))
+}
+
+async fn steam_callback(
+    mut session: backend::UserSession,
+    request: axum::extract::Request,
+) -> Result<axum::response::Redirect, axum::http::StatusCode> {
+    tracing::info!("Steam Callback");
+
+    let query = request.uri().query().ok_or_else(|| {
+        tracing::error!("Missing query in parameters");
+        axum::http::StatusCode::BAD_REQUEST
+    })?;
+
+    let id = OPENID.verify(query).await.map_err(|e| {
+        tracing::error!("Verifying OpenID: {:?}", e);
+        axum::http::StatusCode::BAD_REQUEST
+    })?;
+
+    session
+        .modify_data(|data| {
+            data.steam_id = Some(id);
+        })
+        .await;
+
+    Ok(axum::response::Redirect::to("/"))
+}
+
+async fn demos_list(session: backend::UserSession) -> Result<(), axum::http::StatusCode> {
+    let steam_id = session.data().steam_id.ok_or_else(|| axum::http::StatusCode::UNAUTHORIZED)?;
+    tracing::info!("SteamID: {:?}", steam_id);
+
+    Ok(())
+}