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
133
134
135
136
137
138
139
140
141
142
143
144

//! Validated runtime configuration derived from CLI input.

use crate::cli::{Cli, Command, MountArgs, SubmodulesMode, UnmountArgs};
use crate::errors::{Error, Result};
use fuser::MountOption;
use std::path::{Path, PathBuf};

/// The validated command selected by the user.
#[derive(Debug, Clone)]
pub enum AppCommand {
    /// Mount a repository at the requested mountpoint.
    Mount(MountConfig),
    /// Unmount an existing mountpoint.
    Unmount(UnmountConfig),
}

impl AppCommand {
    /// Convert parsed CLI arguments into validated runtime configuration.
    pub fn from_cli(cli: Cli) -> Result<Self> {
        match cli.command {
            Command::Mount(args) => MountConfig::try_from(args).map(Self::Mount),
            Command::Unmount(args) => UnmountConfig::try_from(args).map(Self::Unmount),
        }
    }
}

/// Validated configuration for a `timefs mount` request.
#[derive(Debug, Clone)]
pub struct MountConfig {
    /// Canonical path to the Git repository.
    pub repo: PathBuf,
    /// Canonical path to the mountpoint directory.
    pub mountpoint: PathBuf,
    /// Run in the foreground when `true`.
    pub foreground: bool,
    /// Allow access for other users.
    pub allow_other: bool,
    /// Strategy for submodule exposure.
    pub submodules: SubmodulesMode,
    /// Resolve local Git LFS objects when available.
    pub lfs: bool,
    /// Freeze ref resolution at mount time.
    pub ref_snapshot: bool,
    /// In-memory cache size in MiB.
    pub cache_size_mb: usize,
    /// Reported UID override.
    pub uid: Option<u32>,
    /// Reported GID override.
    pub gid: Option<u32>,
}

impl MountConfig {
    /// The FUSE mount options required by the project invariants.
    pub fn fuse_mount_options(&self) -> Vec<MountOption> {
        let mut options = vec![
            MountOption::RO,
            MountOption::DefaultPermissions,
            MountOption::FSName(String::from("timefs")),
            MountOption::Subtype(String::from("timefs")),
        ];

        if self.allow_other {
            options.push(MountOption::AllowOther);
        }

        options
    }
}

impl TryFrom<MountArgs> for MountConfig {
    type Error = Error;

    fn try_from(args: MountArgs) -> Result<Self> {
        let repo = validate_existing_dir(&args.repo, "repository")?;
        let mountpoint = validate_existing_dir(&args.mountpoint, "mountpoint")?;

        Ok(Self {
            repo,
            mountpoint,
            foreground: args.foreground,
            allow_other: args.allow_other,
            submodules: args.submodules,
            lfs: args.lfs,
            ref_snapshot: args.ref_snapshot,
            cache_size_mb: args.cache_size_mb,
            uid: args.uid,
            gid: args.gid,
        })
    }
}

/// Validated configuration for a `timefs unmount` request.
#[derive(Debug, Clone)]
pub struct UnmountConfig {
    /// Canonical path to the mountpoint directory.
    pub mountpoint: PathBuf,
}

impl TryFrom<UnmountArgs> for UnmountConfig {
    type Error = Error;

    fn try_from(args: UnmountArgs) -> Result<Self> {
        let mountpoint = validate_existing_dir(&args.mountpoint, "mountpoint")?;
        Ok(Self { mountpoint })
    }
}

fn validate_existing_dir(path: &Path, label: &'static str) -> Result<PathBuf> {
    match path.try_exists() {
        Ok(true) => {}
        Ok(false) => {
            return Err(Error::PathDoesNotExist {
                label,
                path: path.to_path_buf(),
            });
        }
        Err(source) => {
            return Err(Error::PathProbeFailed {
                label,
                path: path.to_path_buf(),
                source,
            });
        }
    }

    let metadata = std::fs::metadata(path).map_err(|source| Error::PathProbeFailed {
        label,
        path: path.to_path_buf(),
        source,
    })?;

    if !metadata.is_dir() {
        return Err(Error::PathIsNotDirectory {
            label,
            path: path.to_path_buf(),
        });
    }

    std::fs::canonicalize(path).map_err(|source| Error::PathCanonicalizeFailed {
        label,
        path: path.to_path_buf(),
        source,
    })
}