@smbcloud / cli
Code Commits Issues Pulls Cloud Agent CI/CD
feature/build-release
claude/smbcloud-github-app-k9641p development feature/apps feature/build-release feature/ci-docs feature/ci-ruby-gems feature/cicd feature/completion feature/dist-nuget feature/fix-ci-sdk-pypi-rubygem feature/fix-clippy-on-stable-channel feature/fix-deployment-script feature/github-email feature/gresiq-v1 feature/project-new-structure feature/rsync-deploy feature/ruby-runner feature/sdk-npm feature/sdk-workflows feature/smbcloud-cli-release-npm feature/smbcloud-deploy feature/wasm main release/v0.7.4
rs 142 lines 4.56 KB
Raw
1 use log::{debug, error};
2 use reqwest::{RequestBuilder, Response};
3 use serde::de::DeserializeOwned;
4 use smbcloud_model::error_codes::{ErrorCode, ErrorResponse};
5 //use std::time::Duration;
6 #[cfg(debug_assertions)]
7 const LOG_RESPONSE_BODY: bool = false; // You know what to do here.
8 #[cfg(not(debug_assertions))]
9 const LOG_RESPONSE_BODY: bool = false;
10
11 /// Check if there is an active internet connection
12 ///
13 /// This function attempts to connect to a reliable server (dns.google)
14 /// with a short timeout. Returns true if the connection was successful.
15 pub async fn check_internet_connection() -> bool {
16 debug!("Checking internet connection");
17 let client = reqwest::Client::builder()
18 //.timeout(Duration::from_secs(5)) Does not work on wasm32
19 .build();
20
21 if let Err(e) = client {
22 error!("Failed to create client for connectivity check: {:?}", e);
23 return false;
24 }
25
26 if let Ok(client) = client {
27 match client.get("https://dns.google").send().await {
28 Ok(response) => {
29 debug!(
30 "Internet connection check successful: {}",
31 response.status()
32 );
33 response.status().is_success()
34 }
35 Err(e) => {
36 error!("Internet connection check failed: {:?}", e);
37 false
38 }
39 }
40 } else {
41 false
42 }
43 }
44
45 pub async fn parse_error_response<T: DeserializeOwned>(
46 response: Response,
47 ) -> Result<T, ErrorResponse> {
48 let response_body = match response.text().await {
49 Ok(body) => body,
50 Err(e) => {
51 error!("Failed to get response body: {:?}", e);
52 return Err(ErrorResponse::Error {
53 error_code: ErrorCode::NetworkError,
54 message: ErrorCode::NetworkError.message(None).to_string(),
55 });
56 }
57 };
58
59 if LOG_RESPONSE_BODY {
60 println!();
61 println!("Parse Error >>>>");
62 println!("{:?}", serde_json::to_string_pretty(&response_body));
63 println!("Parse Error >>>>");
64 println!();
65 }
66
67 let e = match serde_json::from_str::<ErrorResponse>(&response_body) {
68 Ok(json) => json,
69 Err(e) => {
70 error!("Failed to parse error response: {:?}", e);
71 return Err(ErrorResponse::Error {
72 error_code: ErrorCode::ParseError,
73 message: ErrorCode::ParseError.message(None).to_string(),
74 });
75 }
76 };
77 error!("Error response: {:?}", e);
78 Err(e)
79 }
80
81 pub async fn request<R: DeserializeOwned>(builder: RequestBuilder) -> Result<R, ErrorResponse> {
82 // Check internet connection before making the request
83 if !check_internet_connection().await {
84 error!("No internet connection available");
85 return Err(ErrorResponse::Error {
86 error_code: ErrorCode::NetworkError,
87 message: "No internet connection. Please check your network settings and try again."
88 .to_string(),
89 });
90 }
91
92 let response = builder.send().await;
93 let response = match response {
94 Ok(response) => response,
95 Err(e) => {
96 error!("Failed to get response: {:?}", e);
97 return Err(ErrorResponse::Error {
98 error_code: ErrorCode::NetworkError,
99 message: ErrorCode::NetworkError.message(None).to_string(),
100 });
101 }
102 };
103 let response = match response.status() {
104 reqwest::StatusCode::OK | reqwest::StatusCode::CREATED => response,
105 status => {
106 error!("Failed to get response: {:?}", status);
107 return parse_error_response(response).await;
108 }
109 };
110
111 let response_body = match response.text().await {
112 Ok(body) => body,
113 Err(e) => {
114 error!("Failed to get response body: {:?}", e);
115 return Err(ErrorResponse::Error {
116 error_code: ErrorCode::NetworkError,
117 message: ErrorCode::NetworkError.message(None).to_string(),
118 });
119 }
120 };
121
122 if LOG_RESPONSE_BODY {
123 println!();
124 println!("Parse >>>>");
125 println!("{:?}", serde_json::to_string_pretty(&response_body));
126 println!("Parse >>>>");
127 println!();
128 }
129
130 let response = match serde_json::from_str::<R>(&response_body) {
131 Ok(response) => response,
132 Err(e) => {
133 error!("Failed to parse response: {:?}", e);
134 return Err(ErrorResponse::Error {
135 error_code: ErrorCode::ParseError,
136 message: e.to_string(),
137 });
138 }
139 };
140
141 Ok(response)
142 }