timefs 0.1.0

Mount a Git repository as a read-only filesystem.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Filesystem-facing command handlers.

mod head;
mod inode;
pub mod resolve;

use crate::config::{MountConfig, UnmountConfig};
use crate::git::GixRepository;
use anyhow::{anyhow, Context, Result};
use fuser::Session;
use std::io::ErrorKind;
use std::path::Path;
use std::process::Command;
use std::sync::{Arc, Mutex};

/// Mount the read-only Git history filesystem.
pub fn mount(config: MountConfig) -> Result<()> {
    tracing::info!(
        repo = %config.repo.display(),
        mountpoint = %config.mountpoint.display(),
        foreground = config.foreground,
        allow_other = config.allow_other,
        submodules = ?config.submodules,
        lfs = config.lfs,
        ref_snapshot = config.ref_snapshot,
        cache_size_mb = config.cache_size_mb,
        uid = ?config.uid,
        gid = ?config.gid,
        mount_options = ?config.fuse_mount_options(),
        "mounting timefs"
    );

    if !config.foreground {
        tracing::info!("background mode is not implemented yet; running in the foreground");
    }

    let store = GixRepository::open_with_options(
        &config.repo,
        config.cache_size_mb,
        config.lfs,
        config.ref_snapshot,
    )
    .with_context(|| format!("failed to open Git repository {}", config.repo.display()))?;
    let filesystem = head::HeadFilesystem::new(store, &config)?;

    let mountpoint = config.mountpoint.clone();
    let options = config.fuse_mount_options();
    let mut session = Session::new(filesystem, &mountpoint, &options)
        .with_context(|| format!("failed to mount {}", mountpoint.display()))?;

    let unmounter = Arc::new(Mutex::new(Some(session.unmount_callable())));
    ctrlc::set_handler({
        let unmounter = Arc::clone(&unmounter);
        move || {
            if let Ok(mut guard) = unmounter.lock() {
                if let Some(unmounter) = guard.as_mut() {
                    let _ = unmounter.unmount();
                }
            }
        }
    })
    .context("failed to install Ctrl-C handler")?;

    session
        .run()
        .with_context(|| format!("filesystem session failed at {}", mountpoint.display()))
}

/// Unmount a previously mounted `timefs` filesystem.
pub fn unmount(config: UnmountConfig) -> Result<()> {
    tracing::info!(
        mountpoint = %config.mountpoint.display(),
        "unmounting timefs"
    );

    let attempts = [
        ("fusermount3", ["-u"].as_slice()),
        ("fusermount", ["-u"].as_slice()),
        ("umount", &[] as &[&str]),
    ];

    let mut last_error = None;
    for (program, args) in attempts {
        match try_unmount(program, args, &config.mountpoint)? {
            UnmountOutcome::Success => return Ok(()),
            UnmountOutcome::NotFound => {}
            UnmountOutcome::Failed(error) => last_error = Some(error),
        }
    }

    Err(last_error.unwrap_or_else(|| {
        anyhow!("no unmount utility found; tried fusermount3, fusermount, and umount")
    }))
}

enum UnmountOutcome {
    Success,
    NotFound,
    Failed(anyhow::Error),
}

fn try_unmount(program: &str, args: &[&str], mountpoint: &Path) -> Result<UnmountOutcome> {
    let output = match Command::new(program).args(args).arg(mountpoint).output() {
        Ok(output) => output,
        Err(source) if source.kind() == ErrorKind::NotFound => return Ok(UnmountOutcome::NotFound),
        Err(source) => {
            return Err(anyhow!(
                "failed to invoke {program} for {}: {source}",
                mountpoint.display()
            ));
        }
    };

    if output.status.success() {
        return Ok(UnmountOutcome::Success);
    }

    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_owned();
    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_owned();
    let detail = if !stderr.is_empty() {
        stderr
    } else if !stdout.is_empty() {
        stdout
    } else {
        format!("exit status {}", output.status)
    };

    Ok(UnmountOutcome::Failed(anyhow!(
        "{program} failed to unmount {}: {detail}",
        mountpoint.display()
    )))
}