rmux-client 0.1.1

Blocking local client and attach-mode plumbing 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
83
84
85
86
87
88
89
90
91
92

//! Unsupported attach-mode surface for Windows builds.

use std::error::Error as StdError;
use std::fmt;
use std::io::{self, Read, Write};

use rmux_ipc::BlockingLocalStream;

use crate::ClientError;

/// Attach-mode result type.
pub type Result<T> = std::result::Result<T, AttachError>;

/// Attach-mode errors.
#[derive(Debug)]
pub enum AttachError {
    /// A terminal descriptor operation failed.
    Io(io::Error),
    /// Attach mode is not available on this platform yet.
    Unsupported(&'static str),
}

impl fmt::Display for AttachError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Io(error) => write!(formatter, "terminal descriptor operation failed: {error}"),
            Self::Unsupported(operation) => {
                write!(
                    formatter,
                    "attach mode is unsupported on this platform: {operation}"
                )
            }
        }
    }
}

impl StdError for AttachError {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match self {
            Self::Io(error) => Some(error),
            Self::Unsupported(_) => None,
        }
    }
}

impl From<io::Error> for AttachError {
    fn from(error: io::Error) -> Self {
        Self::Io(error)
    }
}

/// Raw terminal guard type for unsupported platforms.
#[derive(Debug)]
pub struct RawTerminal;

/// Runs the attach loop using the process stdin/stdout streams.
pub fn attach_terminal(_stream: BlockingLocalStream) -> std::result::Result<(), ClientError> {
    Err(ClientError::Attach(AttachError::Unsupported(
        "attach terminal",
    )))
}

/// Runs the attach loop with an explicit terminal handle.
pub fn attach_with_terminal<Terminal, Input, Output>(
    _stream: BlockingLocalStream,
    _terminal: &Terminal,
    _input: Input,
    _output: Output,
) -> std::result::Result<(), ClientError>
where
    Input: Read + Send + 'static,
    Output: Write + Send + 'static,
{
    Err(ClientError::Attach(AttachError::Unsupported(
        "attach terminal",
    )))
}

/// Drives an already-upgraded attach stream.
pub fn drive_attach_stream<Input, Output>(
    _stream: BlockingLocalStream,
    _input: Input,
    _output: Output,
) -> std::result::Result<(), ClientError>
where
    Input: Read + Send + 'static,
    Output: Write + Send + 'static,
{
    Err(ClientError::Attach(AttachError::Unsupported(
        "attach stream",
    )))
}