Increase default stack size to 16, and use enable_time and enable_io

Author: xmonader

src/fungi/meta.rs

@@ -12,31 +12,31 @@ use crate::store;
 
 const ID_LEN: usize = 32;
 const KEY_LEN: usize = 32;
-const TYPE_MASK: u32 = libc::S_IFMT;
+const TYPE_MASK: u32 = libc::S_IFMT as u32;
 
 #[repr(u32)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum FileType {
-    Regular = libc::S_IFREG,
-    Dir = libc::S_IFDIR,
-    Link = libc::S_IFLNK,
-    Block = libc::S_IFBLK,
-    Char = libc::S_IFCHR,
-    Socket = libc::S_IFSOCK,
-    FIFO = libc::S_IFIFO,
+    Regular = libc::S_IFREG as u32,
+    Dir = libc::S_IFDIR as u32,
+    Link = libc::S_IFLNK as u32,
+    Block = libc::S_IFBLK as u32,
+    Char = libc::S_IFCHR as u32,
+    Socket = libc::S_IFSOCK as u32,
+    FIFO = libc::S_IFIFO as u32,
     Unknown = 0xFFFFFFFF, // Use a different value to avoid conflict
 }
 
 impl From<u32> for FileType {
     fn from(value: u32) -> Self {
         match value {
-            libc::S_IFREG => Self::Regular,
-            libc::S_IFDIR => Self::Dir,
-            libc::S_IFLNK => Self::Link,
-            libc::S_IFBLK => Self::Block,
-            libc::S_IFCHR => Self::Char,
-            libc::S_IFSOCK => Self::Socket,
-            libc::S_IFIFO => Self::FIFO,
+            x if x == libc::S_IFREG as u32 => Self::Regular,
+            x if x == libc::S_IFDIR as u32 => Self::Dir,
+            x if x == libc::S_IFLNK as u32 => Self::Link,
+            x if x == libc::S_IFBLK as u32 => Self::Block,
+            x if x == libc::S_IFCHR as u32 => Self::Char,
+            x if x == libc::S_IFSOCK as u32 => Self::Socket,
+            x if x == libc::S_IFIFO as u32 => Self::FIFO,
             _ => Self::Unknown,
         }
     }

src/server/block_handlers.rs

@@ -66,12 +66,10 @@ pub async fn upload_block_handler(
 
     // Get the username from the extension (set by the authorize middleware)
     let username = extension.0;
-    if username.is_empty() {
+	if username.is_empty() {
         log::error!("Username is required but not provided");
-        return Err(ResponseError::BadRequest(
-            "Username is required".to_string(),
-        ));
-    }
+        return Err(ResponseError::BadRequest("Username is required".to_string()));
+	}
     let user_id = auth::get_user_id_from_token(&*state.db, &username).await?;
 
     // Store the block data in the database
@@ -431,9 +429,7 @@ pub async fn get_user_blocks_handler(
     let username = extension.0;
     if username.is_empty() {
         log::error!("Username is required but not provided");
-        return Err(ResponseError::BadRequest(
-            "Username is required".to_string(),
-        ));
+        return Err(ResponseError::BadRequest("Username is required".to_string()));
     }
     let user_id = auth::get_user_id_from_token(&*state.db, &username).await?;
 

src/server/file_handlers.rs

@@ -62,9 +62,7 @@ pub async fn upload_file_handler(
     let username = extension.0;
     if username.is_empty() {
         log::error!("Username is required but not provided");
-        return Err(ResponseError::BadRequest(
-            "Username is required".to_string(),
-        ));
+        return Err(ResponseError::BadRequest("Username is required".to_string()));
     }
     let user_id = auth::get_user_id_from_token(&*state.db, &username).await?;
 

tests/docker_test.rs

@@ -3,11 +3,10 @@ mod docker_tests {
     use anyhow::Result;
     use std::path::Path;
     use tempdir::TempDir;
-    use tokio::runtime::Runtime;
     use uuid::Uuid;
 
     use rfs::fungi;
-    use rfs::store::{self, dir::DirStore};
+    use rfs::store::dir::DirStore;
     use rfs::DockerImageToFlist;
 
     #[test]
@@ -18,42 +17,55 @@ mod docker_tests {
             return Ok(());
         }
 
-        // Create a runtime for async operations
-        let rt = Runtime::new()?;
+        // Run the test on a thread with larger stack size to avoid stack overflow
+        let handle = std::thread::Builder::new()
+            .stack_size(16 * 1024 * 1024) // 16MB stack size
+            .spawn(move || -> Result<()> {
+                // Create a custom runtime with timers and IO enabled
+                let rt = tokio::runtime::Builder::new_multi_thread()
+                    .worker_threads(2)
+                    .enable_time()
+                    .enable_io()
+                    .build()
+                    .unwrap();
 
-        rt.block_on(async {
-            // Create temporary directories
-            let temp_dir = TempDir::new("docker-test")?;
-            let store_dir = temp_dir.path().join("store");
-            std::fs::create_dir_all(&store_dir)?;
+                rt.block_on(async {
+                    // Create temporary directories
+                    let temp_dir = TempDir::new("docker-test")?;
+                    let store_dir = temp_dir.path().join("store");
+                    std::fs::create_dir_all(&store_dir)?;
 
-            // Create a store
-            let store = DirStore::new(&store_dir).await?;
+                    // Create a store
+                    let store = DirStore::new(&store_dir).await?;
 
-            // Create a flist writer
-            let fl_path = temp_dir.path().join("alpine-test.fl");
-            let meta = fungi::Writer::new(&fl_path, true).await?;
+                    // Create a flist writer
+                    let fl_path = temp_dir.path().join("alpine-test.fl");
+                    let meta = fungi::Writer::new(&fl_path, true).await?;
 
-            // Create a temporary directory for docker extraction
-            let container_name = Uuid::new_v4().to_string();
-            let docker_tmp_dir = TempDir::new(&container_name)?;
+                    // Create a temporary directory for docker extraction
+                    let container_name = Uuid::new_v4().to_string();
+                    let docker_tmp_dir = TempDir::new(&container_name)?;
 
-            // Create DockerImageToFlist instance
-            let mut docker_to_fl = DockerImageToFlist::new(
-                meta,
-                "alpine:latest".to_string(),
-                None, // No credentials for public image
-                docker_tmp_dir,
-            );
+                    // Create DockerImageToFlist instance
+                    let mut docker_to_fl = DockerImageToFlist::new(
+                        meta,
+                        "alpine:latest".to_string(),
+                        None, // No credentials for public image
+                        docker_tmp_dir,
+                    );
 
-            // Convert docker image to flist
-            docker_to_fl.convert(store, None).await?;
+                    // Convert docker image to flist
+                    docker_to_fl.convert(store, None).await?;
 
-            // Verify the flist was created
-            assert!(Path::new(&fl_path).exists(), "Flist file was not created");
+                    // Verify the flist was created
+                    assert!(Path::new(&fl_path).exists(), "Flist file was not created");
 
-            Ok(())
-        })
+                    Ok(())
+                })
+            })
+            .unwrap();
+
+        handle.join().unwrap()
     }
 
     // Helper function to check if docker is available