@react-native-gpui/fs 0.0.0-stage → 0.0.1-alpha.1

package/desktop/src/dirs.rs

@@ -0,0 +1,363 @@
+//! Listing, creating and removing directories, and `mkdtemp`.
+//!
+//! `readdir` returns every entry as a plain `{name, kind, parentPath}` object,
+//! which the JS layer turns into `Dirent` instances; there is no per-directory
+//! cursor to hold open because the whole listing crosses the bridge at once.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use rn_gpui_module::ModuleError;
+
+use crate::errors;
+use crate::module::kind;
+use crate::DirEntry;
+
+pub async fn readdir(path: String, recursive: bool) -> Result<Vec<DirEntry>, ModuleError> {
+    readdir_sync(path, recursive)
+}
+
+pub async fn mkdir(path: String, recursive: bool, mode: f64) -> Result<(), ModuleError> {
+    create_dir(&path, recursive, mode)
+}
+
+pub async fn rm(path: String, recursive: bool, force: bool) -> Result<(), ModuleError> {
+    remove(&path, recursive, force)
+}
+
+pub async fn mkdtemp(prefix: String) -> Result<String, ModuleError> {
+    let directory = tempfile::Builder::new()
+        .prefix(&prefix)
+        .tempdir_in(std::env::temp_dir())
+        .map_err(|error| errors::from_io(error, &prefix))?;
+    // The caller asked for a directory to keep, so it must outlive this frame;
+    // dropping the guard would delete it again.
+    Ok(path_string(directory.keep()))
+}
+
+pub fn readdir_sync(path: String, recursive: bool) -> Result<Vec<DirEntry>, ModuleError> {
+    let entries = list(Path::new(&path))?;
+    if !recursive {
+        return Ok(entries);
+    }
+    let mut collected = entries;
+    // Depth-first, appending each level as it is reached. Iterative rather than
+    // recursive: a deep tree should cost heap, not stack.
+    let mut pending: Vec<PathBuf> = collected
+        .iter()
+        .filter(|entry| entry.kind == kind::DIRECTORY)
+        .map(|entry| Path::new(&entry.parent_path).join(&entry.name))
+        .collect();
+    while let Some(directory) = pending.pop() {
+        let children = list(&directory)?;
+        pending.extend(
+            children
+                .iter()
+                .filter(|entry| entry.kind == kind::DIRECTORY)
+                .map(|entry| Path::new(&entry.parent_path).join(&entry.name)),
+        );
+        collected.extend(children);
+    }
+    Ok(collected)
+}
+
+pub fn mkdir_sync(path: String, recursive: bool, mode: f64) -> Result<bool, ModuleError> {
+    create_dir(&path, recursive, mode)?;
+    Ok(true)
+}
+
+pub fn rm_sync(path: String, recursive: bool, force: bool) -> Result<bool, ModuleError> {
+    remove(&path, recursive, force)?;
+    Ok(true)
+}
+
+/// The direct children of `path`, in the order the file system lists them.
+///
+/// `DirEntry::file_type` does not follow symbolic links, so a link is reported
+/// as a link rather than as whatever it points at.
+fn list(path: &Path) -> Result<Vec<DirEntry>, ModuleError> {
+    let name = path_string(path.to_path_buf());
+    let iterator = fs::read_dir(path).map_err(|error| errors::from_io(error, &name))?;
+    let mut entries = Vec::new();
+    for entry in iterator {
+        let entry = entry.map_err(|error| errors::from_io(error, &name))?;
+        let file_type = entry
+            .file_type()
+            .map_err(|error| errors::from_io(error, &name))?;
+        entries.push(DirEntry {
+            name: entry.file_name().to_string_lossy().into_owned(),
+            kind: entry_kind(&file_type),
+            parent_path: name.clone(),
+        });
+    }
+    Ok(entries)
+}
+
+fn entry_kind(file_type: &fs::FileType) -> f64 {
+    if file_type.is_file() {
+        kind::FILE
+    } else if file_type.is_dir() {
+        kind::DIRECTORY
+    } else if file_type.is_symlink() {
+        kind::SYMLINK
+    } else {
+        kind::OTHER
+    }
+}
+
+fn create_dir(path: &str, recursive: bool, mode: f64) -> Result<(), ModuleError> {
+    if recursive {
+        // `create_dir_all` succeeds on an existing directory, which is what
+        // Node's `{recursive: true}` promises.
+        return fs::create_dir_all(path).map_err(|error| errors::from_io(error, path));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::DirBuilderExt as _;
+        let mut builder = fs::DirBuilder::new();
+        builder.mode(crate::module::mode(mode));
+        builder
+            .create(path)
+            .map_err(|error| errors::from_io(error, path))
+    }
+    // Windows has no mode for a new directory, and `create_dir` would reject
+    // the `DirBuilder` extension that only exists on Unix.
+    #[cfg(not(unix))]
+    {
+        let _ = mode;
+        fs::create_dir(path).map_err(|error| errors::from_io(error, path))
+    }
+}
+
+fn remove(path: &str, recursive: bool, force: bool) -> Result<(), ModuleError> {
+    // `symlink_metadata`, so a link is removed as a link instead of acting on
+    // its target.
+    let metadata = match fs::symlink_metadata(path) {
+        Ok(metadata) => metadata,
+        Err(error) if force && errors::code_for(&error) == "ENOENT" => return Ok(()),
+        Err(error) => return Err(errors::from_io(error, path)),
+    };
+    if recursive && metadata.is_dir() {
+        return fs::remove_dir_all(path).map_err(|error| errors::from_io(error, path));
+    }
+    if metadata.is_dir() {
+        // `remove_dir` fails with ENOTEMPTY on Unix and a folder-not-empty error
+        // on Windows, which the mapping turns into the same code; removing a
+        // file with it reports what Node calls ENOTDIR.
+        fs::remove_dir(path).map_err(|error| errors::from_io(error, path))
+    } else {
+        fs::remove_file(path).map_err(|error| errors::from_io(error, path))
+    }
+}
+
+fn path_string(path: PathBuf) -> String {
+    path.to_string_lossy().into_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    /// The async wrappers never suspend, so polling once with a no-op waker is
+    /// enough and keeps the tests independent of a runtime.
+    fn block_on<F: std::future::Future>(future: F) -> F::Output {
+        let mut future = std::pin::pin!(future);
+        let waker = std::task::Waker::noop();
+        let mut context = std::task::Context::from_waker(waker);
+        // One poll, no loop: these helpers do their work inline, so a `Pending`
+        // would mean the helper is not synchronous after all, which the test
+        // should fail loudly on rather than spin.
+        match future.as_mut().poll(&mut context) {
+            std::task::Poll::Ready(value) => value,
+            std::task::Poll::Pending => panic!("the wrappers are synchronous"),
+        }
+    }
+
+    fn tempdir() -> TempDir {
+        TempDir::new().expect("a temporary directory")
+    }
+
+    fn text(path: &Path) -> String {
+        path.to_string_lossy().into_owned()
+    }
+
+    /// The listed paths, with separators normalised to `/`.
+    ///
+    /// The entries themselves carry the platform separator, which on Windows is
+    /// `\`; building the expected path with `/` and comparing would test the
+    /// separator rather than the listing.
+    fn names(entries: &[DirEntry]) -> Vec<String> {
+        let mut names: Vec<String> = entries
+            .iter()
+            .map(|entry| format!("{}/{}", entry.parent_path, entry.name).replace('\\', "/"))
+            .collect();
+        names.sort();
+        names
+    }
+
+    fn tree(root: &Path) {
+        fs::create_dir_all(root.join("nested").join("deep")).expect("nested");
+        fs::write(root.join("top.txt"), b"top").expect("seed");
+        fs::write(root.join("nested").join("middle.txt"), b"middle").expect("seed");
+        fs::write(root.join("nested").join("deep").join("leaf.txt"), b"leaf").expect("seed");
+    }
+
+    #[test]
+    fn readdir_lists_direct_children_only() {
+        let dir = tempdir();
+        tree(dir.path());
+
+        let entries = readdir_sync(text(dir.path()), false).expect("readdir");
+        // `names` normalises separators, so the expected paths are built from a
+        // normalised root rather than the platform one.
+        let root = text(dir.path()).replace('\\', "/");
+        assert_eq!(
+            names(&entries),
+            vec![format!("{root}/nested"), format!("{root}/top.txt")]
+        );
+
+        let top = entries
+            .iter()
+            .find(|entry| entry.name == "top.txt")
+            .expect("top.txt");
+        assert_eq!(top.kind, kind::FILE);
+        assert_eq!(top.parent_path, text(dir.path()));
+        let nested = entries
+            .iter()
+            .find(|entry| entry.name == "nested")
+            .expect("nested");
+        assert_eq!(nested.kind, kind::DIRECTORY);
+    }
+
+    #[test]
+    fn readdir_recursive_reaches_every_descendant() {
+        let dir = tempdir();
+        tree(dir.path());
+
+        let entries = block_on(readdir(text(dir.path()), true)).expect("readdir");
+        // Two entries per directory, three directories deep.
+        assert_eq!(entries.len(), 5);
+        let listed = names(&entries);
+        let root = text(dir.path()).replace('\\', "/");
+        assert!(listed.contains(&format!("{root}/nested/deep/leaf.txt")));
+        assert!(listed.contains(&format!("{root}/nested/deep")));
+
+        let deep = entries
+            .iter()
+            .find(|entry| entry.name == "deep")
+            .expect("deep");
+        assert_eq!(
+            deep.parent_path,
+            text(&dir.path().join("nested")),
+            "parentPath is the containing directory"
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn readdir_reports_a_link_as_a_link() {
+        let dir = tempdir();
+        let target = dir.path().join("target.txt");
+        fs::write(&target, b"x").expect("seed");
+        std::os::unix::fs::symlink(&target, dir.path().join("link.txt")).expect("symlink");
+
+        let entries = readdir_sync(text(dir.path()), false).expect("readdir");
+        let link = entries
+            .iter()
+            .find(|entry| entry.name == "link.txt")
+            .expect("link.txt");
+        assert_eq!(link.kind, kind::SYMLINK);
+    }
+
+    #[test]
+    fn mkdir_with_recursive_creates_the_chain_and_accepts_an_existing_dir() {
+        let dir = tempdir();
+        let nested = dir.path().join("a").join("b").join("c");
+
+        block_on(mkdir(text(&nested), true, f64::from(0o755u32))).expect("mkdir");
+        assert!(nested.is_dir());
+
+        let again = mkdir_sync(text(&nested), true, f64::from(0o755u32)).expect("mkdir again");
+        assert!(again, "recursive mkdir succeeds when the path exists");
+    }
+
+    #[test]
+    fn mkdir_without_recursive_fails_with_eexist() {
+        let dir = tempdir();
+        let path = dir.path().join("single");
+        assert!(mkdir_sync(text(&path), false, f64::from(0o755u32)).expect("mkdir"));
+        assert!(path.is_dir());
+
+        let error =
+            block_on(mkdir(text(&path), false, f64::from(0o755u32))).expect_err("mkdir twice");
+        assert_eq!(error.code.as_deref(), Some("EEXIST"));
+
+        let missing_parent = text(&dir.path().join("no").join("such").join("dir"));
+        let error =
+            mkdir_sync(missing_parent, false, f64::from(0o755u32)).expect_err("missing parent");
+        assert_eq!(error.code.as_deref(), Some("ENOENT"));
+    }
+
+    #[test]
+    fn rm_force_ignores_a_missing_path() {
+        let dir = tempdir();
+        let missing = text(&dir.path().join("absent"));
+
+        block_on(rm(missing.clone(), false, true)).expect("rm force");
+        assert!(rm_sync(missing.clone(), true, true).expect("rm sync force"));
+
+        let error = block_on(rm(missing, false, false)).expect_err("rm without force");
+        assert_eq!(error.code.as_deref(), Some("ENOENT"));
+    }
+
+    #[test]
+    fn rm_removes_a_file_and_a_tree() {
+        let dir = tempdir();
+        let file = dir.path().join("one.txt");
+        fs::write(&file, b"x").expect("seed");
+        block_on(rm(text(&file), false, false)).expect("rm file");
+        assert!(!file.exists());
+
+        let root = dir.path().join("tree");
+        tree(&root);
+        assert!(rm_sync(text(&root), true, false).expect("rm tree"));
+        assert!(!root.exists());
+    }
+
+    #[test]
+    fn rm_without_recursive_refuses_a_non_empty_directory() {
+        let dir = tempdir();
+        let root = dir.path().join("tree");
+        tree(&root);
+
+        let error = block_on(rm(text(&root), false, false)).expect_err("non-empty");
+        assert_eq!(error.code.as_deref(), Some("ENOTEMPTY"));
+        assert!(root.exists());
+    }
+
+    #[test]
+    fn mkdtemp_creates_a_random_directory_with_the_prefix() {
+        let created = block_on(mkdtemp("rn-gpui-fs-".to_string())).expect("mkdtemp");
+        let path = Path::new(&created);
+        let name = path
+            .file_name()
+            .expect("the returned path names a directory")
+            .to_string_lossy()
+            .into_owned();
+
+        assert!(name.starts_with("rn-gpui-fs-"), "name was {name}");
+        assert!(name.len() > "rn-gpui-fs-".len(), "the rest is random");
+        assert!(path.is_dir());
+        assert_eq!(path.parent(), Some(std::env::temp_dir().as_path()));
+
+        fs::remove_dir_all(path).expect("clean up");
+    }
+
+    #[test]
+    fn readdir_of_a_missing_directory_is_enoent() {
+        let dir = tempdir();
+        let error = readdir_sync(text(&dir.path().join("absent")), false).expect_err("readdir");
+        assert_eq!(error.code.as_deref(), Some("ENOENT"));
+    }
+}

package/desktop/src/download.rs

@@ -0,0 +1,329 @@
+//! `download`: an HTTP body streamed to a file.
+//!
+//! A transfer is two threads. The network thread makes the request and reads the
+//! body in chunks; the coordinator receives them, writes `<path>.part` and renames
+//! it onto `path` when the body is complete. Splitting them is what makes a cancel
+//! prompt: the coordinator polls the cancel flag between messages, so it does not
+//! wait on a socket that has gone quiet, and the network thread simply stops the
+//! next time it tries to hand over a chunk.
+//!
+//! The module's own thread is only waited on through a channel, so a slow download
+//! never blocks other file calls.
+
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::{self, RecvTimeoutError, SyncSender};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::{Duration, Instant};
+
+use rn_gpui_module::ModuleError;
+use ureq::config::Config;
+use ureq::tls::{RootCerts, TlsConfig};
+use ureq::Agent;
+
+use crate::{
+    errors, DownloadHeader, DownloadOptions, DownloadProgress, DownloadResult, RNFsModule,
+};
+
+const CHUNK: usize = 64 * 1024;
+const PROGRESS_INTERVAL: Duration = Duration::from_millis(100);
+const POLL: Duration = Duration::from_millis(25);
+/// How much of a failed response's body is kept for the error.
+const ERROR_BODY_LIMIT: u64 = 2048;
+
+pub type Downloads = Mutex<HashMap<u32, Arc<AtomicBool>>>;
+
+enum Message {
+    Head {
+        status: u16,
+        headers: Vec<DownloadHeader>,
+        total: Option<u64>,
+    },
+    Rejected {
+        status: u16,
+        headers: Vec<DownloadHeader>,
+        body: String,
+    },
+    Chunk(Vec<u8>),
+    End,
+    Failed(String),
+}
+
+fn agent() -> &'static Agent {
+    static AGENT: OnceLock<Agent> = OnceLock::new();
+    AGENT.get_or_init(|| {
+        let config = Config::builder()
+            .http_status_as_error(false)
+            .timeout_connect(Some(Duration::from_secs(30)))
+            .tls_config(
+                TlsConfig::builder()
+                    .root_certs(RootCerts::PlatformVerifier)
+                    .build(),
+            )
+            .build();
+        Agent::new_with_config(config)
+    })
+}
+
+fn aborted() -> ModuleError {
+    ModuleError::with_code("ABORT_ERR", "The download was aborted")
+}
+
+fn failed(message: impl Into<String>) -> ModuleError {
+    ModuleError::with_code("ERR_DOWNLOAD", message.into())
+}
+
+fn id_of(value: f64) -> u32 {
+    value as u32
+}
+
+pub fn cancel(module: &RNFsModule, id: f64) -> bool {
+    match module.downloads.lock().expect("downloads").get(&id_of(id)) {
+        Some(stop) => {
+            stop.store(true, Ordering::SeqCst);
+            true
+        }
+        None => false,
+    }
+}
+
+fn fetch(
+    url: &str,
+    method: &str,
+    headers: &[DownloadHeader],
+    sender: &SyncSender<Message>,
+    stop: &AtomicBool,
+) {
+    let result = (|| -> Result<(), String> {
+        let mut builder = ureq::http::Request::builder().method(method).uri(url);
+        for header in headers {
+            builder = builder.header(header.name.as_str(), header.value.as_str());
+        }
+        let request = builder.body(()).map_err(|e| e.to_string())?;
+        let mut response = agent().run(request).map_err(|e| e.to_string())?;
+        let status = response.status().as_u16();
+        let mut listed: Vec<DownloadHeader> = Vec::new();
+        for (name, value) in response.headers() {
+            let value = String::from_utf8_lossy(value.as_bytes()).into_owned();
+            match listed.iter_mut().find(|h| h.name == name.as_str()) {
+                Some(existing) => {
+                    existing.value.push_str(", ");
+                    existing.value.push_str(&value);
+                }
+                None => listed.push(DownloadHeader {
+                    name: name.as_str().to_string(),
+                    value,
+                }),
+            }
+        }
+        let total = response
+            .headers()
+            .get("content-length")
+            .and_then(|v| v.to_str().ok())
+            .and_then(|v| v.parse::<u64>().ok());
+        let mut reader = response.body_mut().as_reader();
+        if !(200..300).contains(&status) {
+            let mut body = Vec::new();
+            let _ = reader
+                .by_ref()
+                .take(ERROR_BODY_LIMIT)
+                .read_to_end(&mut body);
+            let _ = sender.send(Message::Rejected {
+                status,
+                headers: listed,
+                body: String::from_utf8_lossy(&body).into_owned(),
+            });
+            return Ok(());
+        }
+        if sender
+            .send(Message::Head {
+                status,
+                headers: listed,
+                total,
+            })
+            .is_err()
+        {
+            return Ok(());
+        }
+        loop {
+            if stop.load(Ordering::SeqCst) {
+                return Ok(());
+            }
+            let mut chunk = vec![0u8; CHUNK];
+            let read = reader.read(&mut chunk).map_err(|e| e.to_string())?;
+            if read == 0 {
+                let _ = sender.send(Message::End);
+                return Ok(());
+            }
+            chunk.truncate(read);
+            if sender.send(Message::Chunk(chunk)).is_err() {
+                return Ok(());
+            }
+        }
+    })();
+    if let Err(message) = result {
+        let _ = sender.send(Message::Failed(message));
+    }
+}
+
+fn transfer(
+    module_events: &crate::NativeFsEvents,
+    id: u32,
+    url: String,
+    dest: PathBuf,
+    method: String,
+    headers: Vec<DownloadHeader>,
+    stop: Arc<AtomicBool>,
+) -> Result<DownloadResult, ModuleError> {
+    let mut partial = dest.clone().into_os_string();
+    partial.push(".part");
+    let partial = PathBuf::from(partial);
+    let shown = dest.display().to_string();
+
+    let (sender, receiver) = mpsc::sync_channel::<Message>(8);
+    {
+        let stop = stop.clone();
+        std::thread::spawn(move || fetch(&url, &method, &headers, &sender, &stop));
+    }
+
+    let mut file: Option<File> = None;
+    let mut head: Option<(u16, Vec<DownloadHeader>, Option<u64>)> = None;
+    let mut received: u64 = 0;
+    let mut last_progress = Instant::now() - PROGRESS_INTERVAL;
+    let emit = |received: u64, total: Option<u64>| {
+        module_events.on_download_progress(DownloadProgress {
+            id: f64::from(id),
+            received: received as f64,
+            total: total.map_or(-1.0, |t| t as f64),
+        });
+    };
+
+    let outcome: Result<DownloadResult, ModuleError> = loop {
+        if stop.load(Ordering::SeqCst) {
+            break Err(aborted());
+        }
+        let message = match receiver.recv_timeout(POLL) {
+            Ok(message) => message,
+            Err(RecvTimeoutError::Timeout) => continue,
+            Err(RecvTimeoutError::Disconnected) => break Err(failed("the connection closed")),
+        };
+        match message {
+            Message::Rejected {
+                status,
+                headers,
+                body,
+            } => {
+                break Ok(DownloadResult {
+                    status: f64::from(status),
+                    headers,
+                    bytes: 0.0,
+                    body: Some(body),
+                });
+            }
+            Message::Head {
+                status,
+                headers,
+                total,
+            } => {
+                match File::create(&partial) {
+                    Ok(created) => file = Some(created),
+                    Err(e) => break Err(errors::from_io(e, &shown)),
+                }
+                head = Some((status, headers, total));
+                emit(0, total);
+            }
+            Message::Chunk(bytes) => {
+                let Some(target) = file.as_mut() else {
+                    break Err(failed("data arrived before the response"));
+                };
+                if let Err(e) = target.write_all(&bytes) {
+                    break Err(errors::from_io(e, &shown));
+                }
+                received += bytes.len() as u64;
+                if last_progress.elapsed() >= PROGRESS_INTERVAL {
+                    last_progress = Instant::now();
+                    emit(received, head.as_ref().and_then(|h| h.2));
+                }
+            }
+            Message::End => {
+                let Some((status, headers, total)) = head.take() else {
+                    break Err(failed("the response had no head"));
+                };
+                if let Some(expected) = total {
+                    if received != expected {
+                        break Err(failed(format!(
+                            "the connection closed after {received} of {expected} bytes"
+                        )));
+                    }
+                }
+                if let Some(mut target) = file.take() {
+                    if let Err(e) = target.flush() {
+                        break Err(errors::from_io(e, &shown));
+                    }
+                }
+                if let Err(e) = std::fs::rename(&partial, &dest) {
+                    break Err(errors::from_io(e, &shown));
+                }
+                emit(received, total);
+                break Ok(DownloadResult {
+                    status: f64::from(status),
+                    headers,
+                    bytes: received as f64,
+                    body: None,
+                });
+            }
+            Message::Failed(message) => break Err(failed(message)),
+        }
+    };
+
+    drop(receiver);
+    drop(file);
+    let kept = matches!(&outcome, Ok(result) if result.body.is_none());
+    if !kept {
+        let _ = std::fs::remove_file(&partial);
+    }
+    outcome
+}
+
+pub async fn download(
+    module: &RNFsModule,
+    url: String,
+    path: String,
+    options: DownloadOptions,
+) -> Result<DownloadResult, ModuleError> {
+    let id = id_of(options.id);
+    let stop = Arc::new(AtomicBool::new(false));
+    {
+        let mut running = module.downloads.lock().expect("downloads");
+        if running.contains_key(&id) {
+            return Err(failed(format!("download {id} is already running")));
+        }
+        running.insert(id, stop.clone());
+    }
+    let (sender, receiver) = futures::channel::oneshot::channel();
+    let events = module.events.clone();
+    let method = if options.method.is_empty() {
+        "GET".to_string()
+    } else {
+        options.method
+    };
+    let flag = stop.clone();
+    std::thread::spawn(move || {
+        let result = transfer(
+            &events,
+            id,
+            url,
+            PathBuf::from(path),
+            method,
+            options.headers,
+            flag,
+        );
+        let _ = sender.send(result);
+    });
+    let result = receiver.await;
+    module.downloads.lock().expect("downloads").remove(&id);
+    result.unwrap_or_else(|_| Err(failed("the download stopped unexpectedly")))
+}