terrazzo-terminal 0.2.8

A simple web-based terminal emulator built on Terrazzo.
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

use scopeguard::defer;
use tracing::Instrument as _;
use tracing::debug;
use tracing::info;
use tracing::info_span;
use tracing::warn;

use crate::backend::Server;
use crate::backend::protos::terrazzo::terminal::ListTerminalsRequest;
use crate::backend::protos::terrazzo::terminal::MaybeString;
use crate::backend::protos::terrazzo::terminal::TerminalDef;
use crate::backend::protos::terrazzo::terminal::terminal_service_client::TerminalServiceClient;
use crate::processes;

pub async fn list_terminals(server: &Server, visited: Vec<String>) -> Vec<TerminalDef> {
    async {
        debug!("Start");
        defer!(debug!("Done"));
        let mut response = vec![];
        response.extend(processes::list::list().iter().map(|terminal| {
            let title = &terminal.title;
            TerminalDef {
                address: Some(terminal.address.clone().into()),
                shell_title: title.shell_title.clone(),
                override_title: title.override_title.clone().map(|s| MaybeString { s }),
                order: terminal.order,
                tile: terminal.tile.into(),
            }
        }));
        for client_name in server.connections().clients() {
            async {
                if visited.iter().any(|v| v.as_str() == client_name.as_ref()) {
                    info!("Already visited");
                    return;
                }
                let Some(client) = server.connections().get_client(&client_name) else {
                    warn!("Client connection not found");
                    return;
                };
                let mut client = TerminalServiceClient::new(client);
                let terminals = client.list_terminals(ListTerminalsRequest {
                    visited: visited.clone(),
                });
                let Ok(mut terminals) = terminals
                    .await
                    .inspect_err(|error| warn!("Failed: {error}"))
                    .map(|response| response.into_inner().terminals)
                else {
                    return;
                };
                for terminal in &mut terminals {
                    let client_address = terminal
                        .address
                        .get_or_insert_default()
                        .via
                        .get_or_insert_default();
                    client_address.via.push(client_name.to_string());
                }
                response.extend(terminals);
            }
            .instrument(info_span!("Client terminals", %client_name))
            .await
        }
        debug!("Result = {response:?}");
        return response;
    }
    .instrument(info_span!("List terminals"))
    .await
}