feat: derive per-mount export/volume name from the mounted target

Multiple concurrent mq-mount instances all exposed the same fixed
"mq-mount" NFS export name / WinFSP filesystem-service name, making
them indistinguishable in `mount`/`df` output or the Windows volume
list. Derive a sanitized name like `mq-notes` from the mounted
file/directory instead, falling back to `mq-mount` when nothing
ASCII-safe can be derived.

Author: harehare

src/backend/nfs.rs

@@ -213,25 +213,25 @@ fn nfs_mount_opts(nolock_flag: &str, port: u16, readonly: bool) -> String {
 }
 
 #[cfg(target_os = "macos")]
-fn mount_nfs(mountpoint: &Path, port: u16, readonly: bool) -> miette::Result<()> {
+fn mount_nfs(mountpoint: &Path, port: u16, readonly: bool, name: &str) -> miette::Result<()> {
     let opts = nfs_mount_opts("nolocks", port, readonly);
     run_mount_command(Command::new("mount_nfs").args([
         "-o",
         &opts,
-        "localhost:/mq-mount",
+        &format!("localhost:/{name}"),
         &mountpoint.to_string_lossy(),
     ]))
 }
 
 #[cfg(target_os = "linux")]
-fn mount_nfs(mountpoint: &Path, port: u16, readonly: bool) -> miette::Result<()> {
+fn mount_nfs(mountpoint: &Path, port: u16, readonly: bool, name: &str) -> miette::Result<()> {
     let opts = nfs_mount_opts("nolock", port, readonly);
     run_mount_command(Command::new("mount").args([
         "-t",
         "nfs",
         "-o",
         &opts,
-        "localhost:/mq-mount",
+        &format!("localhost:/{name}"),
         &mountpoint.to_string_lossy(),
     ]))
 }
@@ -259,25 +259,31 @@ fn unmount(mountpoint: &Path) -> miette::Result<()> {
     run_mount_command(Command::new("umount").arg(mountpoint))
 }
 
-pub fn run(filesystem: MqFs, mountpoint: &Path, file_count: usize, readonly: bool) -> miette::Result<()> {
+pub fn run(filesystem: MqFs, mountpoint: &Path, file_count: usize, readonly: bool, name: &str) -> miette::Result<()> {
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()
         .build()
         .map_err(|e| miette::miette!("failed to start async runtime: {e}"))?
-        .block_on(run_mounted(filesystem, mountpoint, file_count, readonly))
+        .block_on(run_mounted(filesystem, mountpoint, file_count, readonly, name))
 }
 
-async fn run_mounted(filesystem: MqFs, mountpoint: &Path, file_count: usize, readonly: bool) -> miette::Result<()> {
+async fn run_mounted(
+    filesystem: MqFs,
+    mountpoint: &Path,
+    file_count: usize,
+    readonly: bool,
+    name: &str,
+) -> miette::Result<()> {
     let mut listener = NFSTcpListener::bind("127.0.0.1:0", NfsAdapter(filesystem))
         .await
         .map_err(|e| miette::miette!("failed to start NFS server: {e}"))?;
-    listener.with_export_name("mq-mount");
+    listener.with_export_name(name);
     let port = listener.get_listen_port();
     let server = tokio::spawn(async move {
         let _ = listener.handle_forever().await;
     });
 
-    mount_nfs(mountpoint, port, readonly)?;
+    mount_nfs(mountpoint, port, readonly, name)?;
     tracing::info!("mounted {file_count} file(s) at {}", mountpoint.display());
 
     tokio::signal::ctrl_c().await.ok();

src/backend/winfsp.rs

@@ -306,11 +306,12 @@ impl<T: MountFs> FileSystemContext for WinFspAdapter<T> {
     }
 }
 
-pub fn run(filesystem: MqFs, mountpoint: &Path, file_count: usize, readonly: bool) -> miette::Result<()> {
+pub fn run(filesystem: MqFs, mountpoint: &Path, file_count: usize, readonly: bool, name: &str) -> miette::Result<()> {
     let init = winfsp::winfsp_init().map_err(|e| miette::miette!("failed to initialize WinFSP: {e:?}"))?;
 
     let filesystem = std::sync::Mutex::new(Some(filesystem));
     let mountpoint_owned = mountpoint.to_path_buf();
+    let filesystem_name = name.to_string();
 
     let mut service = FileSystemServiceBuilder::new()
         .with_start(move || {
@@ -329,7 +330,7 @@ pub fn run(filesystem: MqFs, mountpoint: &Path, file_count: usize, readonly: boo
                 .unicode_on_disk(true)
                 .persistent_acls(false)
                 .read_only_volume(readonly)
-                .filesystem_name("mq-mount")
+                .filesystem_name(&filesystem_name)
                 .volume_creation_time(filetime(SystemTime::now()));
             let params = FileSystemParams::default_params(volume_params);
 
@@ -344,7 +345,7 @@ pub fn run(filesystem: MqFs, mountpoint: &Path, file_count: usize, readonly: boo
             }
             Ok(())
         })
-        .build("mq-mount", init)
+        .build(name, init)
         .map_err(|e| miette::miette!("failed to build WinFSP service: {e:?}"))?;
 
     service

src/main.rs

@@ -65,13 +65,61 @@ mod app {
             })
             .collect::<miette::Result<Vec<_>>>()?;
         let file_count = entries.len();
+        let name = mount_name(&entries);
         let filesystem = MqFs::new(entries, cli.readonly, cli.allow_other)
             .map_err(|e| miette::miette!("failed to read source file(s): {e}"))?;
 
         #[cfg(unix)]
-        return crate::backend::nfs::run(filesystem, mountpoint, file_count, cli.readonly);
+        return crate::backend::nfs::run(filesystem, mountpoint, file_count, cli.readonly, &name);
         #[cfg(windows)]
-        return crate::backend::winfsp::run(filesystem, mountpoint, file_count, cli.readonly);
+        return crate::backend::winfsp::run(filesystem, mountpoint, file_count, cli.readonly, &name);
+    }
+
+    /// Derives an export/volume name identifying this mount instance (e.g.
+    /// `mq-notes`), so multiple concurrently mounted instances are
+    /// distinguishable in `mount`/`df` output or the Windows Explorer volume
+    /// list instead of all showing up as the same fixed name.
+    fn mount_name(entries: &[(PathBuf, Vec<String>)]) -> String {
+        let mut top_level: Vec<&str> = Vec::new();
+        for (_, mount_path) in entries {
+            if let Some(first) = mount_path.first().map(String::as_str)
+                && !top_level.contains(&first)
+            {
+                top_level.push(first);
+            }
+        }
+        let label = match top_level.as_slice() {
+            [] => String::new(),
+            [only] => sanitize(only),
+            [first, rest @ ..] => format!("{}+{}", sanitize(first), rest.len()),
+        };
+        let label = if label.is_empty() { "mount".to_string() } else { label };
+        format!("mq-{}", truncate(&label, 40))
+    }
+
+    /// Keeps only ASCII alphanumerics, collapsing every other run of
+    /// characters (spaces, punctuation, non-ASCII) into a single `-`, so the
+    /// result is safe to use as an NFS export name or WinFSP filesystem/service name.
+    fn sanitize(name: &str) -> String {
+        let mut out = String::new();
+        let mut last_dash = false;
+        for c in name.chars() {
+            if c.is_ascii_alphanumeric() {
+                out.push(c);
+                last_dash = false;
+            } else if !last_dash && !out.is_empty() {
+                out.push('-');
+                last_dash = true;
+            }
+        }
+        out.trim_end_matches('-').to_string()
+    }
+
+    fn truncate(s: &str, max_chars: usize) -> &str {
+        match s.char_indices().nth(max_chars) {
+            Some((idx, _)) => &s[..idx],
+            None => s,
+        }
     }
 
     fn collect_entries(sources: &[PathBuf]) -> miette::Result<Vec<(PathBuf, Vec<String>)>> {