rmux-server 0.8.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

use rmux_core::command_parser::ParsedCommand;
use rmux_proto::{DisplayMessageRequest, Request, Response, RmuxError, Target};

use super::format_context_for_target_with_server_values;
use super::pane_parse::ParsedSplitWindowCommand;
use super::queue::{queue_action_from_response, QueueCommandAction, QueueExecutionContext};
use super::RequestHandler;
use crate::format_runtime::render_runtime_template;

impl RequestHandler {
    pub(super) async fn execute_queued_split_window(
        &self,
        requester_pid: u32,
        command_for_hooks: &ParsedCommand,
        mut command: ParsedSplitWindowCommand,
        context: &QueueExecutionContext,
    ) -> Result<QueueCommandAction, RmuxError> {
        command.request = self
            .render_queued_split_window_command(command.request, context)
            .await?;
        let can_write = self.requester_can_write(requester_pid).await;
        let request =
            crate::server_access::apply_access_policy(command.request.clone(), can_write)?;
        let request_for_hooks = request.clone();
        let (outcome, inline_hooks) =
            Box::pin(self.dispatch_captured(requester_pid, u64::from(requester_pid), request))
                .await;
        let inline_hook_names = inline_hooks
            .iter()
            .map(|pending| pending.hook)
            .collect::<Vec<_>>();
        self.run_inline_hooks(requester_pid, inline_hooks, Some(command_for_hooks))
            .await;
        self.run_request_hooks(
            requester_pid,
            &request_for_hooks,
            &outcome.response,
            Some(command_for_hooks),
            &inline_hook_names,
        )
        .await;
        self.queued_split_window_action(requester_pid, command, outcome.response)
            .await
    }

    async fn render_queued_split_window_command(
        &self,
        request: Request,
        context: &QueueExecutionContext,
    ) -> Result<Request, RmuxError> {
        let mut request = match request {
            Request::SplitWindowExt(request) => request,
            request => return Ok(request),
        };
        let Some(command) = request.command.clone() else {
            return Ok(Request::SplitWindowExt(request));
        };
        if !command.iter().any(|argument| argument.contains("#{")) {
            return Ok(Request::SplitWindowExt(request));
        }

        let format_target = match &request.target {
            rmux_proto::SplitWindowTarget::Session(session_name) => {
                Target::Session(session_name.clone())
            }
            rmux_proto::SplitWindowTarget::Pane(target) => Target::Pane(target.clone()),
        };
        let attached_count = self.attached_count(format_target.session_name()).await;
        let socket_path = self.socket_path();
        let state = self.state.lock().await;
        let mut runtime = format_context_for_target_with_server_values(
            &state,
            &format_target,
            attached_count,
            &socket_path,
        )?;
        if let Some(client_name) = context.client_name.as_ref() {
            runtime = runtime.with_named_value("client_name", client_name.clone());
        }

        request.command = Some(
            command
                .into_iter()
                .map(|argument| render_runtime_template(&argument, &runtime, false))
                .collect(),
        );
        Ok(Request::SplitWindowExt(request))
    }

    async fn queued_split_window_action(
        &self,
        requester_pid: u32,
        command: ParsedSplitWindowCommand,
        response: Response,
    ) -> Result<QueueCommandAction, RmuxError> {
        let pane = match &response {
            Response::SplitWindow(response) if command.print_target => response.pane.clone(),
            _ => return queue_action_from_response(response),
        };
        let printed = self
            .handle_display_message(
                requester_pid,
                DisplayMessageRequest {
                    target: Some(Target::Pane(pane)),
                    print: true,
                    message: Some(command.format),
                    empty_target_context: false,
                },
            )
            .await;
        queue_action_from_response(printed)
    }
}