Optimize path handling to eliminate getcwd() syscalls in async operations

This commit adds path canonicalization at all database and storage initialization
points to eliminate repeated getcwd() syscalls during async file operations.

Path canonicalization changes:
- main.rs: Canonicalize fs_root and meta_root at server startup
- cas/fs.rs: Canonicalize paths in CasFS::new() and new_multi_user()
- cas/shared_block_store.rs: Canonicalize path in SharedBlockStore::new()

These changes ensure all paths are absolute before being passed to fjall/async-fs,
avoiding ~95ns getcwd() overhead per file operation in async context.

Additional improvements:
- inspect.rs: Enhanced multi-user support with user stats, bucket stats, and listing
- http_ui: Improved pagination and admin user support
- metastore: Added helper methods for user statistics

Author: delandtj

src/cas/fs.rs

@@ -132,6 +132,15 @@ impl CasFS {
     ) -> Self {
         meta_path.push("db");
         root.push("blocks");
+
+        // Canonicalize both paths to eliminate getcwd() syscalls in async operations
+        // This is critical for performance as it avoids repeated getcwd() on every file op
+        std::fs::create_dir_all(&root).ok();
+        root = root.canonicalize().unwrap_or(root);
+
+        std::fs::create_dir_all(&meta_path).ok();
+        meta_path = meta_path.canonicalize().unwrap_or(meta_path);
+
         let meta_store = match storage_engine {
             StorageEngine::Fjall => {
                 let store = FjallStore::new(meta_path, inlined_metadata_size, durability);
@@ -190,6 +199,14 @@ impl CasFS {
         user_meta_path.push("db");
         root.push("blocks");
 
+        // Canonicalize both paths to eliminate getcwd() syscalls in async operations
+        // This is critical for performance as it avoids repeated getcwd() on every file op
+        std::fs::create_dir_all(&root).ok();
+        root = root.canonicalize().unwrap_or(root);
+
+        std::fs::create_dir_all(&user_meta_path).ok();
+        user_meta_path = user_meta_path.canonicalize().unwrap_or(user_meta_path);
+
         let user_meta_store = match storage_engine {
             StorageEngine::Fjall => {
                 let store = FjallStore::new(user_meta_path, inlined_metadata_size, durability);

src/cas/shared_block_store.rs

@@ -34,6 +34,11 @@ impl SharedBlockStore {
     ) -> Result<Self, MetaError> {
         path.push("db");
 
+        // Canonicalize path to eliminate getcwd() syscalls in async operations
+        // This is critical for performance as it avoids repeated getcwd() on every file op
+        std::fs::create_dir_all(&path).ok();
+        path = path.canonicalize().unwrap_or(path);
+
         let meta_store = match storage_engine {
             StorageEngine::Fjall => {
                 let store = FjallStore::new(path, inlined_metadata_size, durability);

src/http_ui/handlers.rs

@@ -48,6 +48,8 @@ pub struct ObjectListResponse {
     pub directories: Vec<DirectoryInfo>,
     pub objects: Vec<ObjectInfo>,
     pub total_count: usize,
+    pub has_more: bool,
+    pub next_token: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -115,26 +117,46 @@ pub async fn list_objects(
         Ok(true) => {}
     }
 
-    // Parse prefix from query parameters
-    let prefix = req
-        .uri()
-        .query()
-        .and_then(|q| {
-            q.split('&')
-                .find(|p| p.starts_with("prefix="))
-                .and_then(|p| p.strip_prefix("prefix="))
-                .map(|p| urlencoding::decode(p).unwrap_or_default().to_string())
-        })
+    // Parse query parameters
+    let query_params = req.uri().query().unwrap_or("");
+
+    let prefix = query_params
+        .split('&')
+        .find(|p| p.starts_with("prefix="))
+        .and_then(|p| p.strip_prefix("prefix="))
+        .map(|p| urlencoding::decode(p).unwrap_or_default().to_string())
         .unwrap_or_default();
 
+    let limit: usize = query_params
+        .split('&')
+        .find(|p| p.starts_with("limit="))
+        .and_then(|p| p.strip_prefix("limit="))
+        .and_then(|p| p.parse().ok())
+        .unwrap_or(100); // Default limit of 100 items
+
+    let start_after = query_params
+        .split('&')
+        .find(|p| p.starts_with("token="))
+        .and_then(|p| p.strip_prefix("token="))
+        .map(|p| urlencoding::decode(p).unwrap_or_default().to_string());
+
     // Get bucket tree and list objects
     match casfs.get_bucket(bucket) {
         Ok(tree) => {
             let mut directories = HashSet::new();
             let mut objects = Vec::new();
+            let mut last_key: Option<String> = None;
+            let mut item_count = 0;
+            let mut has_more = false;
 
             // Use range_filter to get objects with the given prefix
-            for (key, obj) in tree.range_filter(None, Some(prefix.clone()), None) {
+            for (key, obj) in tree.range_filter(start_after.clone(), Some(prefix.clone()), None) {
+                // Check if we've hit the limit
+                if item_count >= limit {
+                    has_more = true;
+                    break;
+                }
+
                 // Check if this key has subdirectories after the prefix
                 let relative_key = if prefix.is_empty() {
                     key.as_str()
@@ -146,10 +168,16 @@ pub async fn list_objects(
                     // This is a subdirectory
                     let dir_name = &relative_key[..slash_pos + 1];
                     let full_prefix = format!("{}{}", prefix, dir_name);
-                    directories.insert(DirectoryInfo {
+                    let dir_info = DirectoryInfo {
                         name: dir_name.to_string(),
                         prefix: full_prefix,
-                    });
+                    };
+
+                    // Only count unique directories toward the limit
+                    if directories.insert(dir_info) {
+                        item_count += 1;
+                        last_key = Some(key.clone());
+                    }
                 } else {
                     // This is a file at the current level
                     objects.push(ObjectInfo {
@@ -160,6 +188,8 @@ pub async fn list_objects(
                         is_inlined: obj.is_inlined(),
                         block_count: obj.blocks().len(),
                     });
+                    item_count += 1;
+                    last_key = Some(key.clone());
                 }
             }
 
@@ -170,12 +200,16 @@ pub async fn list_objects(
 
             let total_count = directories.len() + objects.len();
 
+            let next_token = if has_more { last_key } else { None };
+
             let response = ObjectListResponse {
                 bucket: bucket.to_string(),
                 prefix,
                 directories,
                 objects,
                 total_count,
+                has_more,
+                next_token,
             };
 
             if wants_html {

src/http_ui/templates.rs

@@ -213,6 +213,23 @@ pub fn objects_page(response: &ObjectListResponse) -> String {
                     }
                 }
             }
+
+            // Pagination controls
+            @if response.has_more {
+                @if let Some(ref token) = response.next_token {
+                    div class="pagination" {
+                        @if response.prefix.is_empty() {
+                            a href={ "/buckets/" (response.bucket) "?token=" (urlencoding::encode(token)) } class="btn btn-primary" {
+                                "Load More (Next 100)"
+                            }
+                        } @else {
+                            a href={ "/buckets/" (response.bucket) "?prefix=" (urlencoding::encode(&response.prefix)) "&token=" (urlencoding::encode(token)) } class="btn btn-primary" {
+                                "Load More (Next 100)"
+                            }
+                        }
+                    }
+                }
+            }
         }
     };
 
@@ -1270,6 +1287,18 @@ code {
     color: #666;
 }
 
+/* Pagination */
+.pagination {
+    margin-top: 2rem;
+    padding-top: 1rem;
+    border-top: 1px solid #ddd;
+    text-align: center;
+}
+
+.pagination .btn {
+    min-width: 150px;
+}
+
 @media (prefers-color-scheme: dark) {
     body {
         background: #1a1a1a;
@@ -1365,5 +1394,9 @@ code {
         border-top-color: #444;
         color: #a0a0a0;
     }
+
+    .pagination {
+        border-top-color: #444;
+    }
 }
 "#;