fux 0.7.0

Minimal persistent terminal multiplexer built on bevy_ecs
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

//! Private runtime/state locations for one user.

use std::env;
use std::ffi::OsString;
use std::path::{Path, PathBuf};

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DaemonPaths {
    pub runtime_dir: PathBuf,
    pub state_dir: PathBuf,
    pub manager_socket: PathBuf,
    pub descriptors_dir: PathBuf,
}

impl DaemonPaths {
    pub fn discover() -> Result<Self, PathError> {
        Self::from_env(
            env::var_os("XDG_RUNTIME_DIR"),
            env::var_os("XDG_STATE_HOME"),
            env::var_os("HOME"),
        )
    }

    pub fn from_env(
        runtime: Option<OsString>,
        state: Option<OsString>,
        home: Option<OsString>,
    ) -> Result<Self, PathError> {
        let runtime = absolute(runtime)
            .or_else(|| macos_runtime_fallback(home.as_ref()))
            .ok_or(PathError::MissingRuntime)?;
        let state = absolute(state)
            .or_else(|| absolute(home).map(|path| path.join(".local/state")))
            .ok_or(PathError::MissingState)?;
        let runtime_dir = runtime.join("fux");
        let state_dir = state.join("fux");
        Ok(Self {
            manager_socket: runtime_dir.join("manager.sock"),
            descriptors_dir: runtime_dir.join("workspaces"),
            runtime_dir,
            state_dir,
        })
    }

    pub fn prepare(&self) -> Result<(), PathError> {
        private_dir(&self.runtime_dir)?;
        private_dir(&self.state_dir)?;
        private_dir(&self.descriptors_dir)
    }

    pub fn descriptor(&self, name: &str) -> Result<PathBuf, PathError> {
        crate::ids::validate_workspace_name(name).map_err(|_| PathError::UnsafeName)?;
        Ok(self.descriptors_dir.join(format!("{name}.json")))
    }

    pub fn attach_socket(&self, name: &str) -> Result<PathBuf, PathError> {
        crate::ids::validate_workspace_name(name).map_err(|_| PathError::UnsafeName)?;
        Ok(self.runtime_dir.join(format!("{name}.attach.sock")))
    }

    pub fn control_socket(&self, name: &str) -> Result<PathBuf, PathError> {
        crate::ids::validate_workspace_name(name).map_err(|_| PathError::UnsafeName)?;
        Ok(self.runtime_dir.join(format!("{name}.sock")))
    }
}

#[cfg(target_os = "macos")]
fn macos_runtime_fallback(home: Option<&OsString>) -> Option<PathBuf> {
    absolute(home.cloned()).map(|path| path.join("Library/Caches/fux-runtime"))
}

#[cfg(not(target_os = "macos"))]
fn macos_runtime_fallback(_: Option<&OsString>) -> Option<PathBuf> {
    None
}

#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
pub enum PathError {
    #[error("XDG_RUNTIME_DIR (or HOME on macOS) must be set to an absolute path")]
    MissingRuntime,
    #[error("XDG_STATE_HOME or HOME must be set to an absolute path")]
    MissingState,
    #[error("unsafe workspace name")]
    UnsafeName,
    #[error("{} must be a private directory owned by this user", .0.display())]
    UnsafeDirectory(PathBuf),
    #[error("{0}")]
    Io(String),
}

fn absolute(value: Option<OsString>) -> Option<PathBuf> {
    value
        .filter(|value| !value.is_empty())
        .map(PathBuf::from)
        .filter(|path| path.is_absolute())
}

fn private_dir(path: &Path) -> Result<(), PathError> {
    crate::proto::socket::ensure_private_directory(path).map_err(|error| {
        if error.kind() == std::io::ErrorKind::PermissionDenied {
            PathError::UnsafeDirectory(path.to_owned())
        } else {
            PathError::Io(error.to_string())
        }
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn paths_derive_from_runtime_and_state_homes() {
        let paths = DaemonPaths::from_env(
            Some("/run/user/1".into()),
            Some("/home/u/.local/state".into()),
            Some("/home/u".into()),
        )
        .unwrap_or_else(|_| DaemonPaths {
            runtime_dir: PathBuf::new(),
            state_dir: PathBuf::new(),
            manager_socket: PathBuf::new(),
            descriptors_dir: PathBuf::new(),
        });
        assert_eq!(
            paths.manager_socket,
            PathBuf::from("/run/user/1/fux/manager.sock")
        );
        assert_eq!(
            paths.attach_socket("default").ok(),
            Some(PathBuf::from("/run/user/1/fux/default.attach.sock"))
        );
        assert_eq!(
            paths.control_socket("default").ok(),
            Some(PathBuf::from("/run/user/1/fux/default.sock"))
        );
        assert!(paths.descriptor("../x").is_err());
        assert!(DaemonPaths::from_env(Some("relative".into()), None, None).is_err());
    }
}