markbase/markbase-core/src/cli/storage/mount.rs

use clap::Subcommand;

#[derive(Subcommand)]
pub enum MountCommand {
    #[command(name = "mount-attach")]
    Attach {
        #[arg(short, long)]
        type_: String,
        #[arg(short, long)]
        server: String,
        #[arg(short, long)]
        path: String,
    },
    #[command(name = "mount-detach")]
    Detach {
        #[arg(short, long)]
        path: String,
    },
    #[command(name = "mount-list")]
    List,
}

pub fn handle_mount_command(cmd: MountCommand) -> anyhow::Result<()> {
    match cmd {
        MountCommand::Attach {
            type_,
            server,
            path,
        } => {
            use std::process::Command;

            println!("Mounting {} from {} to {}", type_, server, path);

            if type_ == "nfs" {
                let mount_point = std::path::Path::new(&path);
                std::fs::create_dir_all(mount_point)?;

                let nfs_path = format!("{}:{}", server, path);

                let status = Command::new("mount")
                    .args(["-t", "nfs", &nfs_path, &path])
                    .status()?;

                if status.success() {
                    println!("✓ NFS mounted: {} to {}", nfs_path, path);
                } else {
                    return Err(anyhow::anyhow!("NFS mount failed"));
                }
            } else if type_ == "smb" {
                let mount_point = std::path::Path::new(&path);
                std::fs::create_dir_all(mount_point)?;

                let smb_path = format!("//{}", server);

                let status = Command::new("mount")
                    .args(["-t", "smbfs", &smb_path, &path])
                    .status()?;

                if status.success() {
                    println!("✓ SMB mounted: {} to {}", smb_path, path);
                } else {
                    return Err(anyhow::anyhow!("SMB mount failed"));
                }
            } else {
                return Err(anyhow::anyhow!(
                    "Unknown mount type: {}. Use 'nfs' or 'smb'",
                    type_
                ));
            }
        }
        MountCommand::Detach { path } => {
            use std::process::Command;

            println!("Unmounting {}", path);

            let status = Command::new("umount").arg(&path).status()?;

            if status.success() {
                println!("✓ Unmounted: {}", path);
            } else {
                return Err(anyhow::anyhow!("Unmount failed"));
            }
        }
        MountCommand::List => {
            use std::process::Command;

            println!("Listing mounted storage");

            let output = Command::new("mount").output()?;

            let mounts = String::from_utf8_lossy(&output.stdout);

            println!("=== Mounted Filesystems ===");
            for line in mounts.lines() {
                if line.contains("nfs") || line.contains("smbfs") || line.contains("fuse") {
                    println!("  {}", line);
                }
            }
        }
    }
    Ok(())
}