atac 0.22.1

Arguably a Terminal API Client. Feature-full, free, open-source, offline and account-less.
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

use std::sync::Arc;
use futures_util::SinkExt;
use reqwest_websocket::CloseCode;
use tokio::task;
use tracing::info;
use crate::app::app::App;
use crate::app::business_logic::request::http::send::send_http_request;
use crate::app::business_logic::request::ws::send::send_ws_request;
use crate::models::protocol::protocol::Protocol;

impl App<'_> {
    pub async fn tui_send_request(&mut self) {
        let local_selected_request = self.get_selected_request_as_local();

        {
            let selected_request = local_selected_request.read();
            
            if selected_request.is_pending {
                selected_request.cancellation_token.cancel();
                info!("Request canceled");
                return;
            }
        }
        
        let mut selected_request = local_selected_request.write();

        match &mut selected_request.protocol {
            Protocol::HttpRequest(_) => {}
            Protocol::WsRequest(ws_request) => if ws_request.is_connected {
                if let Some(websocket) = ws_request.websocket.clone() {
                    drop(websocket.rx);

                    // Lock each time to avoid potential deadlock if the user is spamming "send request"
                    websocket.tx
                        .lock()
                        .send(reqwest_websocket::Message::Close {
                            code: CloseCode::Normal,
                            reason: String::new(),
                        })
                        .await
                        .unwrap();

                    websocket.tx.lock().close().await.unwrap();

                    ws_request.websocket = None;
                    ws_request.is_connected = false;
                    return;
                }
            }
        }

        /* PRE-REQUEST SCRIPT */

        let prepared_request = match self.prepare_request(&mut selected_request).await {
            Ok(result) => result,
            Err(prepare_request_error) => {
                selected_request.response.status_code = Some(prepare_request_error.to_string());
                return;
            }
        };

        let protocol = selected_request.protocol.clone();
        let local_selected_request = self.get_selected_request_as_local();
        let local_env = self.get_selected_env_as_local();

        let local_should_refresh_scrollbars = Arc::clone(&self.received_response);

        /* SEND REQUEST */

        task::spawn(async move {
            let response = match protocol {
                Protocol::HttpRequest(_) => send_http_request(prepared_request, local_selected_request.clone(), &local_env).await,
                Protocol::WsRequest(_) => send_ws_request(prepared_request, local_selected_request.clone(), &local_env, local_should_refresh_scrollbars.clone()).await
            };

            let response = match response {
                Ok(response) => response,
                Err(response_error) => {
                    let mut selected_request = local_selected_request.write();
                    selected_request.response.status_code = Some(response_error.to_string());
                    return;
                }
            };

            let mut selected_request = local_selected_request.write();
            selected_request.response = response;
            *local_should_refresh_scrollbars.lock() = true;
        });
    }
}