chore(backend): Update dependencies to latest

Brayan-724 · Brayan-724 · commit 491c06df55e1 · 2025-11-04T22:17:02.000-07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,7 +6,7 @@ rsground-runner = { path = "./backend/runner" }
 
 actix = "0.13"
 actix-cors = "0.7.1"
-actix_error_proc = { version = "1.1.4", features = ["thiserror"] }
+actix_failwrap = { version = "1.0.3" }
 actix-rt = { version = "2.10.0", features = ["macros"] }
 actix-web = "4"
 actix-ws = "0.3.0"
@@ -25,12 +25,12 @@ jsonwebtoken = "8"
 lazy_static = "1.4"
 log = "0.4"
 lsp-types = "0.97.0"
-nix = "0.29.0"
+nix = {version = "0.29.0", features = ["process", "signal"]}
 oauth2 = { version = "4", features = ["reqwest"] }
 once_cell = "1.17"
 operational-transform = { version = "0.6", features = ["serde"] }
 os_pipe = "1.2.1"
-reqwest = { version = "0.12.15", features = ["json", "default-tls"] }
+reqwest = { version = "0.12.15", default-features = false, features = ["json", "rustls-tls"] }
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"
 thiserror = "1.0.63"
diff --git a/backend/Cargo.toml b/backend/Cargo.toml
@@ -25,7 +25,7 @@ uuid.workspace = true
 # Http server
 actix.workspace = true
 actix-cors.workspace = true
-actix_error_proc.workspace = true
+actix_failwrap.workspace = true
 actix-web.workspace = true
 actix-ws.workspace = true
 
diff --git a/backend/runner/src/hakoniwa_ext.rs b/backend/runner/src/hakoniwa_ext.rs
@@ -33,13 +33,17 @@ impl HakoniwaChildExt for Child {
                 reason: "Life is good".to_owned(),
                 exit_code: None,
                 rusage: None,
+                proc_pid_status: None,
+                proc_pid_smaps_rollup: None,
             }),
             Ok(WaitStatus::Signaled(_, signal, _) | WaitStatus::Stopped(_, signal)) => {
                 Some(ExitStatus {
                     code: signal as i32,
                     reason: signal.as_str().to_owned(),
                     exit_code: None,
                     rusage: None,
+                    proc_pid_status: None,
+                    proc_pid_smaps_rollup: None,
                 })
             }
             Ok(WaitStatus::Continued(_)) => None,
@@ -79,14 +83,16 @@ impl HakoniwaChildExt for Child {
                         reason: "Aborted".to_owned(),
                         exit_code: None,
                         rusage: None,
+                        proc_pid_status: None,
+                        proc_pid_smaps_rollup: None,
                     };
                 },
             }
         }
     }
 }
 
-pub struct AsyncOsReader(Async<os_pipe::PipeReader>);
+pub struct AsyncOsReader(Async<io::PipeReader>);
 
 impl AsyncOsReader {
     /// N is the buffer size for reads
@@ -103,8 +109,8 @@ impl AsyncOsReader {
     }
 }
 
-impl From<os_pipe::PipeReader> for AsyncOsReader {
-    fn from(value: os_pipe::PipeReader) -> Self {
+impl From<io::PipeReader> for AsyncOsReader {
+    fn from(value: io::PipeReader) -> Self {
         Self(Async::new(value).expect("Cannot create async wrapper"))
     }
 }
@@ -116,7 +122,7 @@ impl AsFd for AsyncOsReader {
 }
 
 impl ops::Deref for AsyncOsReader {
-    type Target = os_pipe::PipeReader;
+    type Target = io::PipeReader;
 
     fn deref(&self) -> &Self::Target {
         &self.0.get_ref()
@@ -163,19 +169,19 @@ impl<const N: usize> Stream for AsyncOsReaderStream<N> {
 }
 
 pub struct LspStdoutReader {
-    inner: Async<os_pipe::PipeReader>,
+    inner: Async<io::PipeReader>,
     filled: usize,
     buf: Option<Vec<u8>>,
 }
 
 impl LspStdoutReader {
-    fn inner(&self) -> &Async<os_pipe::PipeReader> {
+    fn inner(&self) -> &Async<io::PipeReader> {
         &self.inner
     }
 }
 
-impl From<os_pipe::PipeReader> for LspStdoutReader {
-    fn from(value: os_pipe::PipeReader) -> Self {
+impl From<io::PipeReader> for LspStdoutReader {
+    fn from(value: io::PipeReader) -> Self {
         Self {
             inner: Async::new(value).expect("Cannot create async wrapper"),
             filled: 0,
@@ -191,7 +197,7 @@ impl AsFd for LspStdoutReader {
 }
 
 impl ops::Deref for LspStdoutReader {
-    type Target = os_pipe::PipeReader;
+    type Target = io::PipeReader;
 
     fn deref(&self) -> &Self::Target {
         &self.inner().get_ref()
diff --git a/backend/runner/src/lib.rs b/backend/runner/src/lib.rs
@@ -9,8 +9,8 @@ use futures::TryStreamExt;
 use futures_ext::{FutureExt, OptionalFuture};
 use hakoniwa::{Child, Command, Container, ExitStatus, Output};
 use hakoniwa_ext::{AsyncOsReader, HakoniwaChildExt};
-pub use os_pipe::{PipeReader, PipeWriter};
 use std::future::Future;
+pub use std::io::{PipeReader, PipeWriter};
 use std::path::{Path, PathBuf};
 use tokio::sync::oneshot;
 use tokio::{fs, io};
@@ -46,6 +46,7 @@ impl Runner {
         Container::new()
             .hostname("rsground")
             .rootfs(concat!(env!("CARGO_MANIFEST_DIR"), "/lxc_rootfs"))
+            .expect("Cannot create container")
             .tmpfsmount("/tmp")
             .devfsmount("/dev")
             .procfsmount("/proc")
@@ -171,9 +172,12 @@ impl Runner {
         };
 
         let (status, stdout, stderr) =
-            tokio::try_join!(status, stdout, stderr).map_err(|join_error| {
-                return hakoniwa::Error::Unexpected(format!("Join error: {join_error}"));
-            })?;
+            tokio::try_join!(status, stdout, stderr).unwrap_or_else(|join_error| {
+                eprintln!("Join error: {join_error}");
+                // FIXME: hakoniwa errors are obscured. see https://github.com/souk4711/hakoniwa/issues/107
+                // Wait until next release.
+                panic!("tokio task panicked. see https://github.com/souk4711/hakoniwa/issues/107")
+            });
 
         Ok((status, stdout, stderr))
     }
diff --git a/backend/src/auth/routes.rs b/backend/src/auth/routes.rs
@@ -1,5 +1,5 @@
-use actix_error_proc::{proof_route, HttpResult};
-use actix_web::{get, web, HttpRequest, HttpResponse, Responder};
+use actix_failwrap::proof_route;
+use actix_web::{HttpRequest, HttpResponse, get, web};
 use oauth2::{AuthorizationCode, CsrfToken, Scope, TokenResponse};
 use serde::Deserialize;
 use uuid::Uuid;
@@ -22,7 +22,7 @@ pub struct AuthRequest {
 }
 
 #[get("/auth")]
-pub async fn auth(oauth: web::Data<OAuthData>) -> impl Responder {
+pub async fn auth(oauth: web::Data<OAuthData>) -> HttpResponse {
     let (auth_url, _csrf_token) = oauth
         .client
         .authorize_url(CsrfToken::new_random)
@@ -34,19 +34,19 @@ pub async fn auth(oauth: web::Data<OAuthData>) -> impl Responder {
         .finish()
 }
 
-#[get("/auth/me")]
-pub async fn me(req: HttpRequest) -> HttpResult<HttpErrors> {
+#[proof_route("GET /auth/me")]
+pub async fn me(req: HttpRequest) -> Result<HttpResponse, HttpErrors> {
     let user_info = jwt::get_user_info(&req)?;
 
     Ok(HttpResponse::Ok().json(user_info))
 }
 
-#[get("/auth/callback")]
+#[proof_route("GET /auth/callback")]
 async fn callback(
     state: web::Data<AppState>,
     query: web::Query<AuthRequest>,
     oauth_data: web::Data<OAuthData>,
-) -> HttpResult<HttpErrors> {
+) -> Result<HttpResponse, HttpErrors> {
     let code = AuthorizationCode::new(query.code.clone());
 
     let token = oauth_data
@@ -90,11 +90,11 @@ struct GuestLoginRequest {
     guest_name: String,
 }
 
-#[proof_route(post("/auth/guest"))]
+#[proof_route("POST /auth/guest")]
 async fn login_guest(
     state: web::Data<AppState>,
     body: web::Json<GuestLoginRequest>,
-) -> HttpResult<HttpErrors> {
+) -> Result<HttpResponse, HttpErrors> {
     let guest_name = &body.guest_name;
     let guest_uuid = Uuid::new_v4().to_string();
 
@@ -122,12 +122,12 @@ struct UpdateNameRequest {
     new_name: ArcStr,
 }
 
-#[proof_route(post("/auth/update"))]
+#[proof_route("POST /auth/update")]
 async fn update_name(
     state: web::Data<AppState>,
     body: web::Json<UpdateNameRequest>,
     req: actix_web::HttpRequest,
-) -> HttpResult<HttpErrors> {
+) -> Result<HttpResponse, HttpErrors> {
     let token_data = jwt::get_user_info(&req)?;
 
     if !token_data.is_guest {
diff --git a/backend/src/collab/document.rs b/backend/src/collab/document.rs
@@ -5,7 +5,7 @@ use serde::Serialize;
 use tokio::sync::{Notify, RwLock, RwLockWriteGuard};
 
 use crate::collab::ot::transform_index;
-use crate::utils::{define_local_logger, ArcStr, AsyncInto};
+use crate::utils::{ArcStr, AsyncInto, define_local_logger};
 
 use super::UserOperation;
 
diff --git a/backend/src/health.rs b/backend/src/health.rs
@@ -1,4 +1,4 @@
-use actix_web::{get, HttpResponse};
+use actix_web::{HttpResponse, get};
 
 #[get("/health")]
 pub async fn health() -> HttpResponse {
diff --git a/backend/src/http_errors.rs b/backend/src/http_errors.rs
@@ -1,7 +1,7 @@
-use actix_error_proc::ActixError;
+use actix_failwrap::ErrorResponse;
 use thiserror::Error;
 
-#[derive(ActixError, Error, Debug)]
+#[derive(ErrorResponse, Error, Debug)]
 pub enum HttpErrors {
     // -- JWT/Auth related -- //
     #[error("Error encoding JWT: {0}")]
@@ -12,31 +12,31 @@ pub enum HttpErrors {
     CodeExchange(String),
 
     #[error("Only guest users can change their name")]
-    #[http_status(Forbidden)]
+    #[status_code(Forbidden)]
     GithubNameChange,
 
     #[error("Error fetching github user: {0}")]
     GithubUserFetch(reqwest::Error),
 
     #[error("Invalid token")]
-    #[http_status(Unauthorized)]
+    #[status_code(Unauthorized)]
     InvalidJWT,
 
     #[error("No token provided")]
-    #[http_status(Unauthorized)]
+    #[status_code(Unauthorized)]
     NoTokenProvided,
 
     // -- Websockets related -- //
     #[error("Project doesn't exist")]
-    #[http_status(NotFound)]
+    #[status_code(NotFound)]
     ProjectDoesNotExist,
 
     #[error("Do not have access to project")]
-    #[http_status(Unauthorized)]
+    #[status_code(Unauthorized)]
     NotAccessible,
 
     #[error("Invalid password for private project")]
-    #[http_status(Unauthorized)]
+    #[status_code(Unauthorized)]
     InvalidPassword,
 
     #[error("Error at websocket start: {0}")]
diff --git a/backend/src/main.rs b/backend/src/main.rs
@@ -11,7 +11,7 @@ use std::collections::HashMap;
 use std::sync::LazyLock;
 
 use actix_cors::Cors;
-use actix_web::{web, App, HttpServer};
+use actix_web::{App, HttpServer, web};
 
 use auth::github;
 use auth::jwt::JWT_SECRET;
diff --git a/backend/src/project/project.rs b/backend/src/project/project.rs
@@ -4,23 +4,23 @@ use std::sync::Arc;
 
 use actix::Addr;
 use futures::StreamExt;
+use rsground_runner::Runner;
 use rsground_runner::lsp::notification::{DidChangeTextDocument, DidOpenTextDocument};
 use rsground_runner::lsp::{
     DidChangeTextDocumentParams, DidOpenTextDocumentParams, TextDocumentContentChangeEvent,
     TextDocumentItem, Uri, VersionedTextDocumentIdentifier,
 };
-use rsground_runner::Runner;
 use tokio::sync::broadcast;
 use uuid::Uuid;
 
 use crate::auth::jwt::RgUserData;
 use crate::collab::{Document, DocumentInfo};
 use crate::http_errors::HttpErrors;
 use crate::project::project_lsp::ProjectLspActor;
-use crate::utils::{ArcStr, AsyncDefault, AsyncInto, ToStream, EMPTY_STR};
+use crate::utils::{ArcStr, AsyncDefault, AsyncInto, EMPTY_STR, ToStream};
 use crate::ws::messages::{InternalMessage, ServerMessage};
 
-use super::{lsp, producer, project_log, AccessLevel};
+use super::{AccessLevel, lsp, producer, project_log};
 
 pub struct Project {
     pub id: Uuid,
@@ -152,7 +152,9 @@ impl Project {
             .await
             .inspect_err(|err| project_log::error!("{err}"));
 
-        if let Ok(uri) = Uri::from_str(&format!("file:///home/{path}")) {
+        if path.ends_with("rs")
+            && let Ok(uri) = Uri::from_str(&format!("file:///home/{path}"))
+        {
             self.lsp
                 .send_notify::<DidOpenTextDocument, true>(&DidOpenTextDocumentParams {
                     text_document: TextDocumentItem {
diff --git a/backend/src/project/project_lsp.rs b/backend/src/project/project_lsp.rs
@@ -18,10 +18,10 @@ use rsground_runner::{PipeWriter, Runner};
 use tokio::sync::broadcast;
 use uuid::Uuid;
 
-use crate::utils::{define_local_logger, ArcStr, Truncate};
+use crate::utils::{ArcStr, Truncate, define_local_logger};
 use crate::ws::messages::InternalMessage;
 
-use super::project_runner::{start_job, AbortSender};
+use super::project_runner::{AbortSender, start_job};
 
 define_local_logger!(local_log as "backend::lsp" {
     client_stdin,
@@ -216,7 +216,7 @@ impl Handler<ClientStdin> for ProjectLsp {
                 return;
             }
             LspOutput::Notify(LspNotify { ref method, .. }) if method == Initialized::METHOD => {
-                return
+                return;
             }
             _ => {}
         }
diff --git a/backend/src/project/project_producer.rs b/backend/src/project/project_producer.rs
@@ -9,7 +9,7 @@ use uuid::Uuid;
 use crate::ws::messages::{OutputChannel, ServerMessage};
 
 use super::define_local_logger;
-use super::project_runner::{start_job, AbortSender};
+use super::project_runner::{AbortSender, start_job};
 
 define_local_logger! {local_log as "backend::producer" {
     compile,
diff --git a/backend/src/project/project_runner.rs b/backend/src/project/project_runner.rs
@@ -1,27 +1,9 @@
-use std::sync::Arc;
-
 use actix::{Actor, ActorFutureExt, AsyncContext, WrapFuture};
-use tokio::sync::{oneshot, Mutex};
+use tokio::sync::oneshot;
 
 pub type AbortSender = oneshot::Sender<()>;
 pub type AbortReceiver = oneshot::Receiver<()>;
 
-#[derive(Debug)]
-#[repr(transparent)]
-pub struct SharedExport<T>(Arc<Mutex<Option<T>>>);
-
-impl<T> Clone for SharedExport<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<T> Default for SharedExport<T> {
-    fn default() -> Self {
-        Self(Mutex::new(None).into())
-    }
-}
-
 pub fn create_abort() -> (AbortSender, AbortReceiver) {
     oneshot::channel::<()>()
 }
diff --git a/backend/src/project/routes.rs b/backend/src/project/routes.rs
diff --git a/backend/src/ws/handlers.rs b/backend/src/ws/handlers.rs
diff --git a/backend/src/ws/messages.rs b/backend/src/ws/messages.rs
diff --git a/backend/src/ws/routes.rs b/backend/src/ws/routes.rs
diff --git a/flake.nix b/flake.nix

Original file line number	Diff line number	Diff line change
`@@ -33,13 +33,17 @@ impl HakoniwaChildExt for Child {`
`33`	`33`	`reason: "Life is good".to_owned(),`
`34`	`34`	`exit_code: None,`
`35`	`35`	`rusage: None,`
	`36`	`+ proc_pid_status: None,`
	`37`	`+ proc_pid_smaps_rollup: None,`
`36`	`38`	`}),`
`37`	`39`	`Ok(WaitStatus::Signaled(_, signal, _) \| WaitStatus::Stopped(_, signal)) => {`
`38`	`40`	`Some(ExitStatus {`
`39`	`41`	`code: signal as i32,`
`40`	`42`	`reason: signal.as_str().to_owned(),`
`41`	`43`	`exit_code: None,`
`42`	`44`	`rusage: None,`
	`45`	`+ proc_pid_status: None,`
	`46`	`+ proc_pid_smaps_rollup: None,`
`43`	`47`	`})`
`44`	`48`	`}`
`45`	`49`	`Ok(WaitStatus::Continued(_)) => None,`
`@@ -79,14 +83,16 @@ impl HakoniwaChildExt for Child {`
`79`	`83`	`reason: "Aborted".to_owned(),`
`80`	`84`	`exit_code: None,`
`81`	`85`	`rusage: None,`
	`86`	`+ proc_pid_status: None,`
	`87`	`+ proc_pid_smaps_rollup: None,`
`82`	`88`	`};`
`83`	`89`	`},`
`84`	`90`	`}`
`85`	`91`	`}`
`86`	`92`	`}`
`87`	`93`	`}`
`88`	`94`
`89`		`-pub struct AsyncOsReader(Async<os_pipe::PipeReader>);`
	`95`	`+pub struct AsyncOsReader(Async<io::PipeReader>);`
`90`	`96`
`91`	`97`	`impl AsyncOsReader {`
`92`	`98`	`/// N is the buffer size for reads`
`@@ -103,8 +109,8 @@ impl AsyncOsReader {`
`103`	`109`	`}`
`104`	`110`	`}`
`105`	`111`
`106`		`-impl From<os_pipe::PipeReader> for AsyncOsReader {`
`107`		`- fn from(value: os_pipe::PipeReader) -> Self {`
	`112`	`+impl From<io::PipeReader> for AsyncOsReader {`
	`113`	`+ fn from(value: io::PipeReader) -> Self {`
`108`	`114`	`Self(Async::new(value).expect("Cannot create async wrapper"))`
`109`	`115`	`}`
`110`	`116`	`}`
`@@ -116,7 +122,7 @@ impl AsFd for AsyncOsReader {`
`116`	`122`	`}`
`117`	`123`
`118`	`124`	`impl ops::Deref for AsyncOsReader {`
`119`		`- type Target = os_pipe::PipeReader;`
	`125`	`+ type Target = io::PipeReader;`
`120`	`126`
`121`	`127`	`fn deref(&self) -> &Self::Target {`
`122`	`128`	`&self.0.get_ref()`
`@@ -163,19 +169,19 @@ impl<const N: usize> Stream for AsyncOsReaderStream<N> {`
`163`	`169`	`}`
`164`	`170`
`165`	`171`	`pub struct LspStdoutReader {`
`166`		`- inner: Async<os_pipe::PipeReader>,`
	`172`	`+ inner: Async<io::PipeReader>,`
`167`	`173`	`filled: usize,`
`168`	`174`	`buf: Option<Vec<u8>>,`
`169`	`175`	`}`
`170`	`176`
`171`	`177`	`impl LspStdoutReader {`
`172`		`- fn inner(&self) -> &Async<os_pipe::PipeReader> {`
	`178`	`+ fn inner(&self) -> &Async<io::PipeReader> {`
`173`	`179`	`&self.inner`
`174`	`180`	`}`
`175`	`181`	`}`
`176`	`182`
`177`		`-impl From<os_pipe::PipeReader> for LspStdoutReader {`
`178`		`- fn from(value: os_pipe::PipeReader) -> Self {`
	`183`	`+impl From<io::PipeReader> for LspStdoutReader {`
	`184`	`+ fn from(value: io::PipeReader) -> Self {`
`179`	`185`	`Self {`
`180`	`186`	`inner: Async::new(value).expect("Cannot create async wrapper"),`
`181`	`187`	`filled: 0,`
`@@ -191,7 +197,7 @@ impl AsFd for LspStdoutReader {`
`191`	`197`	`}`
`192`	`198`
`193`	`199`	`impl ops::Deref for LspStdoutReader {`
`194`		`- type Target = os_pipe::PipeReader;`
	`200`	`+ type Target = io::PipeReader;`
`195`	`201`
`196`	`202`	`fn deref(&self) -> &Self::Target {`
`197`	`203`	`&self.inner().get_ref()`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use actix_web::{get, HttpResponse};`
	`1`	`+use actix_web::{HttpResponse, get};`
`2`	`2`
`3`	`3`	`#[get("/health")]`
`4`	`4`	`pub async fn health() -> HttpResponse {`