rmux-server 0.1.1

Tokio daemon and request dispatcher for the RMUX terminal multiplexer.
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

use std::future::Future;
use std::process::{Output, Stdio};

use rmux_proto::RmuxError;

use crate::terminal::TerminalProfile;

pub(in super::super) fn spawn_background_async<Fut, Factory>(
    thread_name: &'static str,
    factory: Factory,
) where
    Factory: FnOnce() -> Fut + Send + 'static,
    Fut: Future<Output = ()> + 'static,
{
    let _ = std::thread::Builder::new()
        .name(thread_name.to_owned())
        .spawn(move || {
            let Ok(runtime) = tokio::runtime::Builder::new_current_thread()
                .enable_all()
                .build()
            else {
                return;
            };
            runtime.block_on(factory());
        });
}

pub(super) async fn run_shell_foreground(
    command: String,
    profile: &TerminalProfile,
    show_stderr: bool,
) -> Result<Output, RmuxError> {
    let mut command_builder = profile.shell_command(&command);
    command_builder
        .stdin(Stdio::null())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .current_dir(profile.cwd())
        .env_clear();
    for (name, value) in profile.environment() {
        command_builder.env(name, value);
    }
    if !show_stderr {
        command_builder.stderr(Stdio::piped());
    }
    command_builder
        .output()
        .await
        .map_err(|error| RmuxError::Server(format!("failed to run shell command: {error}")))
}

pub(super) fn run_shell_status_error(output: &Output) -> String {
    let stderr = String::from_utf8_lossy(&output.stderr);
    let stderr = stderr.trim();

    if stderr.is_empty() {
        format!("run-shell command exited with {}", output.status)
    } else {
        format!("run-shell command exited with {}: {stderr}", output.status)
    }
}

pub(super) async fn shell_condition_is_true(
    command: String,
    profile: &TerminalProfile,
) -> Result<bool, RmuxError> {
    let mut command_builder = profile.shell_command(&command);
    command_builder
        .stdin(Stdio::null())
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .current_dir(profile.cwd())
        .env_clear();
    for (name, value) in profile.environment() {
        command_builder.env(name, value);
    }
    command_builder
        .status()
        .await
        .map(|status| status.success())
        .map_err(|error| RmuxError::Server(format!("failed to run if-shell condition: {error}")))
}