Fix/main (#508)

* fix error

* fix

* fix cargo

* fix openssl cfg

* fix clippy

* fix clippy

* fix

* fix clippy

* fix clippy

crates/utils/src/net.rs

@@ -115,7 +115,7 @@ pub fn must_get_local_ips() -> std::io::Result<Vec<IpAddr>> {
     }
 }
 
-pub fn get_default_location(u: Url, region_override: &str) -> String {
+pub fn get_default_location(_u: Url, _region_override: &str) -> String {
     todo!();
 }
 
@@ -136,7 +136,7 @@ pub fn get_endpoint_url(endpoint: &str, secure: bool) -> Result<Url, std::io::Er
 
 pub const DEFAULT_DIAL_TIMEOUT: i64 = 5;
 
-pub fn new_remotetarget_http_transport(insecure: bool) -> Builder<TokioExecutor> {
+pub fn new_remotetarget_http_transport(_insecure: bool) -> Builder<TokioExecutor> {
     todo!();
 }
 
@@ -255,11 +255,8 @@ impl TryFrom<String> for XHost {
     }
 }
 
-/// parses the address string, process the ":port" format for double-stack binding,
-/// and resolve the host name or IP address. If the port is 0, an available port is assigned.
 pub fn parse_and_resolve_address(addr_str: &str) -> std::io::Result<SocketAddr> {
     let resolved_addr: SocketAddr = if let Some(port) = addr_str.strip_prefix(":") {
-        // Process the ":port" format for double stack binding
         let port_str = port;
         let port: u16 = port_str
             .parse()
@@ -269,10 +266,8 @@ pub fn parse_and_resolve_address(addr_str: &str) -> std::io::Result<SocketAddr>
         } else {
             port
         };
-        // Using IPv6 without address specified [::], it should handle both IPv4 and IPv6
         SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), final_port)
     } else {
-        // Use existing logic to handle regular address formats
         let mut addr = check_local_server_addr(addr_str)?; // assume check_local_server_addr is available here
         if addr.port() == 0 {
             addr.set_port(get_available_port());

crates/utils/src/os/windows.rs

@@ -1,7 +1,7 @@
 #![allow(unsafe_code)] // TODO: audit unsafe code
 
 use super::{DiskInfo, IOStats};
-use std::io::{Error, ErrorKind};
+use std::io::Error;
 use std::mem;
 use std::os::windows::ffi::OsStrExt;
 use std::path::Path;
@@ -40,8 +40,7 @@ pub fn get_info(p: impl AsRef<Path>) -> std::io::Result<DiskInfo> {
     let free = unsafe { *lp_total_number_of_free_bytes.QuadPart() };
 
     if free > total {
-        return Err(Error::new(
-            ErrorKind::Other,
+        return Err(Error::other(
             format!(
                 "detected free space ({}) > total drive space ({}), fs corruption at ({}). please run 'fsck'",
                 free,

crates/utils/src/retry.rs

@@ -1,22 +1,9 @@
 use std::time::Duration;
 
-// MaxRetry is the maximum number of retries before stopping.
 pub const MAX_RETRY: i64 = 10;
-
-// MaxJitter will randomize over the full exponential backoff time
 pub const MAX_JITTER: f64 = 1.0;
-
-// NoJitter disables the use of jitter for randomizing the exponential backoff time
 pub const NO_JITTER: f64 = 0.0;
 
-// DefaultRetryUnit - default unit multiplicative per retry.
-// defaults to 200 * time.Millisecond
-//const DefaultRetryUnit = 200 * time.Millisecond;
-
-// DefaultRetryCap - Each retry attempt never waits no longer than
-// this maximum time duration.
-//const DefaultRetryCap = time.Second;
-
 /*
 struct Delay {
     when: Instant,
@@ -76,100 +63,6 @@ impl Stream for RetryTimer {
     }
 }*/
 
-pub fn new_retry_timer(max_retry: i32, base_sleep: Duration, max_sleep: Duration, jitter: f64) -> Vec<i32> {
-    /*attemptCh := make(chan int)
-
-    exponentialBackoffWait := func(attempt int) time.Duration {
-      // normalize jitter to the range [0, 1.0]
-      if jitter < NoJitter {
-        jitter = NoJitter
-      }
-      if jitter > MaxJitter {
-        jitter = MaxJitter
-      }
-
-      // sleep = random_between(0, min(maxSleep, base * 2 ** attempt))
-      sleep := baseSleep * time.Duration(1<<uint(attempt))
-      if sleep > maxSleep {
-        sleep = maxSleep
-      }
-      if jitter != NoJitter {
-        sleep -= time.Duration(c.random.Float64() * float64(sleep) * jitter)
-      }
-      return sleep
-    }
-
-    go func() {
-      defer close(attemptCh)
-      for i := 0; i < maxRetry; i++ {
-        select {
-        case attemptCh <- i + 1:
-        case <-ctx.Done():
-          return
-        }
-
-        select {
-        case <-time.After(exponentialBackoffWait(i)):
-        case <-ctx.Done():
-          return
-        }
-      }
-    }()
-    return attemptCh*/
+pub fn new_retry_timer(_max_retry: i32, _base_sleep: Duration, _max_sleep: Duration, _jitter: f64) -> Vec<i32> {
     todo!();
-}
-
-/*var retryableS3Codes = map[string]struct{}{
-  "RequestError":          {},
-  "RequestTimeout":        {},
-  "Throttling":            {},
-  "ThrottlingException":   {},
-  "RequestLimitExceeded":  {},
-  "RequestThrottled":      {},
-  "InternalError":         {},
-  "ExpiredToken":          {},
-  "ExpiredTokenException": {},
-  "SlowDown":              {},
-}
-
-fn isS3CodeRetryable(s3Code string) (ok bool) {
-  _, ok = retryableS3Codes[s3Code]
-  return ok
-}
-
-var retryableHTTPStatusCodes = map[int]struct{}{
-  http.StatusRequestTimeout:      {},
-  429:                            {}, // http.StatusTooManyRequests is not part of the Go 1.5 library, yet
-  499:                            {}, // client closed request, retry. A non-standard status code introduced by nginx.
-  http.StatusInternalServerError: {},
-  http.StatusBadGateway:          {},
-  http.StatusServiceUnavailable:  {},
-  http.StatusGatewayTimeout:      {},
-  520:                            {}, // It is used by Cloudflare as a catch-all response for when the origin server sends something unexpected.
-  // Add more HTTP status codes here.
-}
-
-fn isHTTPStatusRetryable(httpStatusCode int) (ok bool) {
-  _, ok = retryableHTTPStatusCodes[httpStatusCode]
-  return ok
-}
-
-fn isRequestErrorRetryable(ctx context.Context, err error) bool {
-  if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-    // Retry if internal timeout in the HTTP call.
-    return ctx.Err() == nil
-  }
-  if ue, ok := err.(*url.Error); ok {
-    e := ue.Unwrap()
-    switch e.(type) {
-    // x509: certificate signed by unknown authority
-    case x509.UnknownAuthorityError:
-      return false
-    }
-    switch e.Error() {
-    case "http: server gave HTTP response to HTTPS client":
-      return false
-    }
-  }
-  return true
-}*/
+}