rmux-server 0.10.0

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
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

use super::*;

#[tokio::test]
async fn send_keys_target_client_uses_that_clients_current_pane() {
    let handler = RequestHandler::new();
    let alpha = session_name("alpha");
    create_send_keys_test_session(&handler, &alpha).await;
    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    handler.register_attach(77, alpha.clone(), control_tx).await;
    let capture = RawPaneInputProbe::start(&handler, &alpha, "target-client", 1).await;

    let response = handler
        .handle(Request::SendKeysExt2(Box::new(
            rmux_proto::SendKeysExt2Request {
                target: None,
                keys: vec!["A".to_owned()],
                expand_formats: false,
                hex: false,
                literal: true,
                dispatch_key_table: false,
                copy_mode_command: false,
                forward_mouse_event: false,
                reset_terminal: false,
                repeat_count: None,
                target_client: Some("77".to_owned()),
            },
        )))
        .await;

    assert_eq!(
        response,
        Response::SendKeys(SendKeysResponse { key_count: 1 })
    );
    capture.assert_contents(&handler, b"A").await;
}

#[tokio::test]
async fn send_keys_missing_target_client_is_successful_noop() {
    let handler = RequestHandler::new();
    let alpha = session_name("alpha");
    create_send_keys_test_session(&handler, &alpha).await;
    let capture = RawPaneInputProbe::start(&handler, &alpha, "target-client-missing", 0).await;

    let response = handler
        .handle(Request::SendKeysExt2(Box::new(
            rmux_proto::SendKeysExt2Request {
                target: Some(PaneTarget::new(alpha, 0)),
                keys: vec!["A".to_owned()],
                expand_formats: false,
                hex: false,
                literal: true,
                dispatch_key_table: false,
                copy_mode_command: false,
                forward_mouse_event: false,
                reset_terminal: false,
                repeat_count: None,
                target_client: Some("999999".to_owned()),
            },
        )))
        .await;

    assert_eq!(
        response,
        Response::SendKeys(SendKeysResponse { key_count: 0 })
    );
    capture.assert_contents(&handler, b"").await;
}

#[tokio::test]
async fn send_keys_target_client_key_dispatch_uses_target_client_context() {
    let handler = RequestHandler::new();
    let alpha = session_name("alpha");
    let beta = session_name("beta");
    create_send_keys_test_session(&handler, &alpha).await;
    create_send_keys_test_session(&handler, &beta).await;

    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    handler.register_attach(77, alpha.clone(), control_tx).await;

    let bound = handler
        .handle(Request::BindKey(Box::new(BindKeyRequest {
            table_name: "prefix".to_owned(),
            key: "x".to_owned(),
            note: Some("target-client-context".to_owned()),
            repeat: false,
            command: Some(vec![
                "switch-client".to_owned(),
                "-t".to_owned(),
                beta.to_string(),
            ]),
        })))
        .await;
    assert!(matches!(bound, Response::BindKey(_)));

    let response = handler
        .handle(Request::SendKeysExt2(Box::new(
            rmux_proto::SendKeysExt2Request {
                target: None,
                keys: vec!["C-b".to_owned(), "x".to_owned()],
                expand_formats: false,
                hex: false,
                literal: false,
                dispatch_key_table: true,
                copy_mode_command: false,
                forward_mouse_event: false,
                reset_terminal: false,
                repeat_count: None,
                target_client: Some("77".to_owned()),
            },
        )))
        .await;

    assert_eq!(
        response,
        Response::SendKeys(SendKeysResponse { key_count: 2 })
    );

    let active_attach = handler.active_attach.lock().await;
    let active = active_attach
        .by_pid
        .get(&77)
        .expect("target attached client remains registered");
    assert_eq!(active.session_name, beta);
}