merge: main -> feat/runners

Author: Brayan-724

Cargo.lock

@@ -1,6 +1,10 @@
 [workspace]
-members = ["backend", "backend/runner"]
+members = ["backend", "backend/runner", "frontend-wasm"]
 
 [workspace.dependencies]
+bytecount = "0.6"
+operational-transform = { version = "0.6", features = ["serde"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = "1.0"
 thiserror = "1.0.63"
 tokio = { version = "1", features = ["full"] }

Cargo.toml

@@ -6,28 +6,37 @@ edition = "2021"
 [dependencies]
 rsground-runner = { path = "./runner" }
 
-actix = "0.13"
-actix-cors = "0.7.1"
-actix_error_proc = { version = "1.1.4", features = ["thiserror"] }
-actix-web = "4"
-actix-ws = "0.3.0"
 chrono = "0.4"
 dotenv = "0.15.0"
 env_logger = "0.11.7"
 futures = "0.3"
-jsonwebtoken = "8"
 log = "0.4"
-oauth2 = { version = "4", features = ["reqwest"] }
-reqwest = { version = "0.12.15", features = ["json", "default-tls"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
 thiserror.workspace = true
 tokio.workspace = true
+
+# Auth
+jsonwebtoken = "8"
+oauth2 = { version = "4", features = ["reqwest"] }
+reqwest = { version = "0.12.15", features = ["json", "default-tls"] }
 uuid = { version = "1.3", features = ["serde", "v4"] }
 
-# Para los tests de integracion
+# Http server
+actix = "0.13"
+actix-cors = "0.7.1"
+actix_error_proc = { version = "1.1.4", features = ["thiserror"] }
+actix-web = "4"
+actix-ws = "0.3.0"
+
+# OT
+bytecount.workspace = true
+operational-transform.workspace = true
+
+# Serialization
+serde.workspace = true
+serde_json.workspace = true
+
 [dev-dependencies]
-awc = "3" # Cliente HTTP y WebSocket para Actix
+awc = "3" # Http & WebSocket Client for Actix
 actix-rt = { version = "2.10.0", features = ["macros"] }
 futures-util = "0.3"
 lazy_static = "1.4"

backend/Cargo.toml

@@ -1,16 +1,14 @@
 pub mod error;
 
-use std::future::Future;
-use std::io::Read;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-
 use hakoniwa::{Child, Command, Container, ExitStatus, Output};
 use nix::libc::pid_t;
 use nix::sys::signal::{self, Signal};
 use nix::unistd::Pid;
 pub use os_pipe::{PipeReader, PipeWriter};
-use tokio::sync::{oneshot, Notify};
+use std::future::Future;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use tokio::sync::oneshot;
 use tokio::{fs, io};
 
 pub const BASE_ENV: [(&str, &str); 3] = [
@@ -36,7 +34,7 @@ impl Runner {
         temp_home
     }
 
-    fn create_container(temp_home: &PathBuf) -> Container {
+    fn create_container(temp_home: &str) -> Container {
         Container::new()
             .hostname("rsground")
             .rootfs(concat!(env!("CARGO_MANIFEST_DIR"), "/lxc_rootfs"))
@@ -45,15 +43,15 @@ impl Runner {
             .procfsmount("/proc")
             .uidmap(1001)
             .gidmap(100)
-            .bindmount_rw(temp_home.to_str().unwrap(), "/home")
+            .bindmount_rw(temp_home, "/home")
             // FIXME: This needs to set resource limit
             // .setrlimit(hakoniwa::Rlimit::*, soft_limit, hard_limit)
             .clone()
     }
 
     pub async fn new() -> Result<Self, ()> {
         let temp_home = Self::create_home().await;
-        let container = Self::create_container(&temp_home);
+        let container = Self::create_container(temp_home.to_str().unwrap());
 
         Ok(Self {
             container,

backend/runner/src/lib.rs

@@ -6,20 +6,21 @@ use serde::{Deserialize, Serialize};
 
 use crate::expect_var;
 use crate::http_errors::HttpErrors;
+use crate::utils::ArcStr;
 
 pub static JWT_SECRET: LazyLock<String> = LazyLock::new(|| expect_var!("JWT_SECRET"));
 const JWT_EXP: TimeDelta = Duration::hours(12);
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct RgUserData {
-    pub id: String,
-    pub name: String,
+    pub id: ArcStr,
+    pub name: ArcStr,
     pub is_guest: bool,
     pub exp: i64,
 }
 
 impl RgUserData {
-    pub fn new(id: String, name: String, is_guest: bool) -> Self {
+    pub fn new(id: ArcStr, name: ArcStr, is_guest: bool) -> Self {
         let exp = Utc::now() + JWT_EXP;
 
         Self {
@@ -70,6 +71,6 @@ pub fn get_auth_token(req: &HttpRequest) -> Option<&str> {
 }
 
 pub fn get_user_info(req: &HttpRequest) -> Result<RgUserData, HttpErrors> {
-    let token = get_auth_token(&req).ok_or_else(|| HttpErrors::NoTokenProvided)?;
+    let token = get_auth_token(req).ok_or_else(|| HttpErrors::NoTokenProvided)?;
     decode(token).ok_or(HttpErrors::InvalidJWT)
 }

backend/src/auth/jwt.rs

@@ -8,6 +8,7 @@ use crate::auth::jwt::RgUserData;
 use crate::auth::{github, jwt};
 use crate::http_errors::HttpErrors;
 use crate::state::AppState;
+use crate::utils::ArcStr;
 
 pub struct OAuthData {
     pub client: oauth2::basic::BasicClient,
@@ -61,10 +62,17 @@ async fn callback(
         .map_err(HttpErrors::GithubUserFetch)
         .inspect_err(|err| log::error!("{err}"))?;
 
-    let jwt =
-        RgUserData::new(github_user.login.clone(), github_user.login.clone(), false).encode()?;
+    let user_data = RgUserData::new(
+        github_user.login.as_str().into(),
+        github_user.login.as_str().into(),
+        false,
+    );
 
-    state.add_username(github_user.login.clone(), github_user.login.clone());
+    state
+        .add_username(user_data.id.clone(), user_data.name.clone())
+        .await;
+
+    let jwt = user_data.encode()?;
 
     Ok(HttpResponse::Ok().json(serde_json::json!({
         "jwt": jwt,
@@ -87,9 +95,18 @@ async fn login_guest(
 ) -> HttpResult<HttpErrors> {
     let guest_name = &body.guest_name;
     let guest_uuid = Uuid::new_v4().to_string();
-    let jwt = RgUserData::new(guest_uuid.clone(), guest_name.clone(), true).encode()?;
 
-    state.add_username(guest_uuid.clone(), guest_name.clone());
+    let user_data = RgUserData::new(
+        guest_uuid.as_str().into(),
+        guest_name.as_str().into(),
+        false,
+    );
+
+    state
+        .add_username(user_data.id.clone(), user_data.name.clone())
+        .await;
+
+    let jwt = user_data.encode()?;
 
     Ok(HttpResponse::Ok().json(serde_json::json!({
         "jwt": jwt,
@@ -100,7 +117,7 @@ async fn login_guest(
 }
 #[derive(Deserialize)]
 struct UpdateNameRequest {
-    new_name: String,
+    new_name: ArcStr,
 }
 
 #[proof_route(post("/auth/update"))]
@@ -118,9 +135,13 @@ async fn update_name(
     let uuid = token_data.id;
     let new_name = body.into_inner().new_name;
 
-    let jwt = RgUserData::new(uuid.clone(), new_name.clone(), true).encode()?;
+    let user_data = RgUserData::new(uuid.clone(), new_name.clone(), false);
+
+    state
+        .add_username(user_data.id.clone(), user_data.name.clone())
+        .await;
 
-    state.add_username(uuid.clone(), new_name.clone());
+    let jwt = user_data.encode()?;
 
     Ok(HttpResponse::Ok().json(serde_json::json!({
         "jwt": jwt,

backend/src/auth/routes.rs

@@ -1,16 +1,10 @@
+use std::sync::Arc;
+
+use operational_transform::OperationSeq;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
-#[serde(tag = "kind", rename_all = "snake_case")]
-pub enum Action {
-    Insertion {
-        from: usize,
-        text: String,
-        owner: String,
-    },
-    Deletion {
-        from: usize,
-        to: usize,
-        owner: String,
-    },
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct UserOperation {
+    pub user_id: Arc<str>,
+    pub operation: OperationSeq,
 }