fix: refine codes

Author: halajohn

core/src/ten_rust/BUILD.gn

@@ -86,7 +86,7 @@ if (ten_enable_ten_rust) {
     output_file = "include_internal/ten_rust/ten_rust.h"
     binding_files = [
       "src/bindings.rs",
-      "src/telemetry/mod.rs",
+      "src/endpoint/mod.rs",
     ]
 
     deps = [ ":ten_rust_static_lib" ]

core/src/ten_rust/src/constants/endpoint.rs

@@ -5,3 +5,6 @@
 // Refer to the "LICENSE" file in the root directory for more information.
 //
 pub const METRICS: &str = "/metrics";
+
+pub const ENDPOINT_SERVER_BIND_MAX_RETRIES: u32 = 5;
+pub const ENDPOINT_SERVER_BIND_RETRY_INTERVAL_SECS: u64 = 5; // seconds

core/src/ten_rust/src/constants/mod.rs

@@ -7,9 +7,6 @@
 pub mod endpoint;
 pub use endpoint::*;
 
-pub const TELEMETRY_SERVER_START_RETRY_MAX_ATTEMPTS: u32 = 3;
-pub const TELEMETRY_SERVER_START_RETRY_INTERVAL: u64 = 1; // seconds
-
 pub const ERR_MSG_GRAPH_LOCALHOST_FORBIDDEN_IN_SINGLE_APP_MODE: &str =
     "'localhost' is not allowed in graph definition, and the graph seems to \
      be a single-app graph, just remove the 'app' field";

core/src/ten_rust/src/endpoint/mod.rs

@@ -22,8 +22,7 @@ use prometheus::{
 };
 
 use crate::constants::{
-    TELEMETRY_SERVER_START_RETRY_INTERVAL,
-    TELEMETRY_SERVER_START_RETRY_MAX_ATTEMPTS,
+    ENDPOINT_SERVER_BIND_MAX_RETRIES, ENDPOINT_SERVER_BIND_RETRY_INTERVAL_SECS,
 };
 
 pub struct TelemetrySystem {
@@ -45,7 +44,7 @@ pub enum MetricHandle {
     HistogramVec(HistogramVec),
 }
 
-/// Configuration function for telemetry server routes.
+/// Configure API endpoints.
 fn configure_routes(cfg: &mut web::ServiceConfig, registry: Registry) {
     let registry_clone = registry;
 
@@ -56,32 +55,26 @@ fn configure_routes(cfg: &mut web::ServiceConfig, registry: Registry) {
     api_handler::configure_api_route(cfg);
 }
 
-/// Initialize the endpoint system.
-#[no_mangle]
-#[allow(clippy::not_unsafe_ptr_arg_deref)]
-pub extern "C" fn ten_endpoint_system_create(
-    endpoint: *const c_char,
-) -> *mut TelemetrySystem {
-    let endpoint_str = match unsafe { CStr::from_ptr(endpoint) }.to_str() {
-        Ok(s) if !s.trim().is_empty() => s.to_string(),
-        _ => return ptr::null_mut(),
-    };
-
-    // Note: `prometheus::Registry` internally uses `Arc` and `RwLock` to
-    // achieve thread safety, so there is no need to add additional locking
-    // mechanisms. It can be used directly here.
-    let registry = Registry::new();
-
-    // Start the actix-web server to provide metrics data at the specified path.
-
+/// Creates an HTTP server with retry mechanism if binding fails.
+///
+/// This function attempts to bind an HTTP server to the specified endpoint.
+/// If binding fails, it will retry up to a configured maximum number of
+/// attempts with a delay between each attempt.
+fn create_endpoint_server_with_retry(
+    endpoint_str: &str,
+    registry: Registry,
+) -> Option<actix_web::dev::Server> {
     let mut attempts = 0;
-    let max_attempts = TELEMETRY_SERVER_START_RETRY_MAX_ATTEMPTS;
-    let wait_duration =
-        std::time::Duration::from_secs(TELEMETRY_SERVER_START_RETRY_INTERVAL);
+    let max_attempts = ENDPOINT_SERVER_BIND_MAX_RETRIES;
+    let wait_duration = std::time::Duration::from_secs(
+        ENDPOINT_SERVER_BIND_RETRY_INTERVAL_SECS,
+    );
 
+    // Try to create and bind the HTTP server, with retries if it fails.
     let server_builder = loop {
         let registry_clone = registry.clone();
 
+        // Create a new HTTP server with the configured routes.
         let result = HttpServer::new(move || {
             App::new()
                 .configure(|cfg| configure_routes(cfg, registry_clone.clone()))
@@ -94,28 +87,65 @@ pub extern "C" fn ten_endpoint_system_create(
             Ok(server) => break server,
             Err(e) => {
                 attempts += 1;
+
+                // If we've reached the maximum number of attempts, log the
+                // error and return None.
                 if attempts >= max_attempts {
                     eprintln!(
                         "Error binding to address: {} after {} attempts: {:?}",
                         endpoint_str, attempts, e
                     );
-                    return ptr::null_mut();
+                    return None;
                 }
 
+                // Otherwise, log the error and retry after a delay.
                 eprintln!(
                     "Failed to bind to address: {}. Attempt {} of {}. \
-                     Retrying in {} second...",
+                     Retrying in {} second{}...",
                     endpoint_str,
                     attempts,
                     max_attempts,
-                    TELEMETRY_SERVER_START_RETRY_INTERVAL
+                    ENDPOINT_SERVER_BIND_RETRY_INTERVAL_SECS,
+                    if ENDPOINT_SERVER_BIND_RETRY_INTERVAL_SECS == 1 {
+                        ""
+                    } else {
+                        "s"
+                    }
                 );
                 std::thread::sleep(wait_duration);
             }
         }
     };
 
-    let server = server_builder.run();
+    // Start the server and return it.
+    Some(server_builder.run())
+}
+
+/// Initialize the endpoint system.
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "C" fn ten_endpoint_system_create(
+    endpoint: *const c_char,
+) -> *mut TelemetrySystem {
+    let endpoint_str = match unsafe { CStr::from_ptr(endpoint) }.to_str() {
+        Ok(s) if !s.trim().is_empty() => s.to_string(),
+        _ => return ptr::null_mut(),
+    };
+
+    // Note: `prometheus::Registry` internally uses `Arc` and `RwLock` to
+    // achieve thread safety, so there is no need to add additional locking
+    // mechanisms. It can be used directly here.
+    let registry = Registry::new();
+
+    // Start the actix-web server to provide metrics data at the specified path.
+    let server = match create_endpoint_server_with_retry(
+        &endpoint_str,
+        registry.clone(),
+    ) {
+        Some(server) => server,
+        None => return ptr::null_mut(),
+    };
+
     let server_handle = server.handle();
 
     // Create an `oneshot` channel to notify the actix system to shut down.