renamed grace_timeout -> request_timeout; renamed min_throughput -> request_min_throughput

Author: amunra

cpp_test/test_line_sender.cpp

@@ -812,22 +812,22 @@ TEST_CASE("HTTP basics") {
         "localhost",
         1};
     questdb::ingress::opts opts1conf = questdb::ingress::opts::from_conf(
-        "http::addr=localhost:1;user=user;pass=pass;grace_timeout=5000;retry_timeout=5;");
+        "http::addr=localhost:1;user=user;pass=pass;request_timeout=5000;retry_timeout=5;");
     questdb::ingress::opts opts2{
         questdb::ingress::line_sender_protocol::http,
         "localhost",
         "1"};
     questdb::ingress::opts opts2conf = questdb::ingress::opts::from_conf(
-        "http::addr=localhost:1;token=token;min_throughput=1000;retry_timeout=0;");
+        "http::addr=localhost:1;token=token;request_min_throughput=1000;retry_timeout=0;");
     opts1
         .user("user")
         .pass("pass")
         .max_buf_size(1000000)
-        .grace_timeout(5000)
+        .request_timeout(5000)
         .retry_timeout(5);
     opts2
         .token("token")
-        .min_throughput(1000)
+        .request_min_throughput(1000)
         .retry_timeout(0);
     questdb::ingress::line_sender sender1{opts1};
     questdb::ingress::line_sender sender1conf{opts1conf};

include/questdb/ingress/line_sender.h

@@ -751,7 +751,7 @@ bool line_sender_opts_retry_timeout(
  * The value is expressed as a number of bytes per second.
  */
 LINESENDER_API
-bool line_sender_opts_min_throughput(
+bool line_sender_opts_request_min_throughput(
     line_sender_opts* opts,
     uint64_t bytes_per_sec,
     line_sender_error** err_out);
@@ -761,7 +761,7 @@ bool line_sender_opts_min_throughput(
  * The default is 5 seconds.
  */
 LINESENDER_API
-bool line_sender_opts_grace_timeout(
+bool line_sender_opts_request_timeout(
     line_sender_opts* opts,
     uint64_t millis,
     line_sender_error** err_out);

include/questdb/ingress/line_sender.hpp

@@ -1019,10 +1019,10 @@ namespace questdb::ingress
              * The default is 100 KiB/s.
              * The value is expressed as a number of bytes per second.
              */
-            opts& min_throughput(uint64_t bytes_per_sec)
+            opts& request_min_throughput(uint64_t bytes_per_sec)
             {
                 line_sender_error::wrapped_call(
-                    ::line_sender_opts_min_throughput,
+                    ::line_sender_opts_request_min_throughput,
                     _impl,
                     bytes_per_sec);
                 return *this;
@@ -1032,10 +1032,10 @@ namespace questdb::ingress
              * Grace request timeout before relying on the minimum throughput logic.
              * The default is 5 seconds.
              */
-            opts& grace_timeout(uint64_t millis)
+            opts& request_timeout(uint64_t millis)
             {
                 line_sender_error::wrapped_call(
-                    ::line_sender_opts_grace_timeout,
+                    ::line_sender_opts_request_timeout,
                     _impl,
                     millis);
                 return *this;

questdb-rs-ffi/src/lib.rs

@@ -1122,24 +1122,24 @@ pub unsafe extern "C" fn line_sender_opts_retry_timeout(
 /// The default is 100 KiB/s.
 /// The value is expressed as a number of bytes per second.
 #[no_mangle]
-pub unsafe extern "C" fn line_sender_opts_min_throughput(
+pub unsafe extern "C" fn line_sender_opts_request_min_throughput(
     opts: *mut line_sender_opts,
     bytes_per_sec: u64,
     err_out: *mut *mut line_sender_error,
 ) -> bool {
-    upd_opts!(opts, err_out, min_throughput, bytes_per_sec)
+    upd_opts!(opts, err_out, request_min_throughput, bytes_per_sec)
 }
 
 /// Grace request timeout before relying on the minimum throughput logic.
 /// The default is 5 seconds.
 #[no_mangle]
-pub unsafe extern "C" fn line_sender_opts_grace_timeout(
+pub unsafe extern "C" fn line_sender_opts_request_timeout(
     opts: *mut line_sender_opts,
     millis: u64,
     err_out: *mut *mut line_sender_error,
 ) -> bool {
-    let grace_timeout = std::time::Duration::from_millis(millis);
-    upd_opts!(opts, err_out, grace_timeout, grace_timeout)
+    let request_timeout = std::time::Duration::from_millis(millis);
+    upd_opts!(opts, err_out, request_timeout, request_timeout)
 }
 
 /// Set the HTTP user agent. Internal API. Do not use.

questdb-rs/src/ingress/http.rs

@@ -41,19 +41,19 @@ impl TokenAuthParams {
 
 #[derive(Debug, Clone)]
 pub(super) struct HttpConfig {
-    pub(super) min_throughput: ConfigSetting<u64>,
+    pub(super) request_min_throughput: ConfigSetting<u64>,
     pub(super) user_agent: ConfigSetting<Option<String>>,
     pub(super) retry_timeout: ConfigSetting<Duration>,
-    pub(super) grace_timeout: ConfigSetting<Duration>,
+    pub(super) request_timeout: ConfigSetting<Duration>,
 }
 
 impl Default for HttpConfig {
     fn default() -> Self {
         Self {
-            min_throughput: ConfigSetting::new_default(102400), // 100 KiB/s
+            request_min_throughput: ConfigSetting::new_default(102400), // 100 KiB/s
             user_agent: ConfigSetting::new_default(None),
             retry_timeout: ConfigSetting::new_default(Duration::from_secs(10)),
-            grace_timeout: ConfigSetting::new_default(Duration::from_secs(5)),
+            request_timeout: ConfigSetting::new_default(Duration::from_secs(5)),
         }
     }
 }

questdb-rs/src/ingress/mod.rs

@@ -1761,8 +1761,6 @@ impl SenderBuilder {
         };
         let mut builder = SenderBuilder::new(host, port, protocol);
 
-        // tls=  tls_verify=  tls_roots=  tls_roots_password=
-        // TODO: no support in config string for WebPkiAndOsRoots
         builder.tls_enabled.set_specified("tls", with_tls)?;
 
         validate_auto_flush_params(&params)?;
@@ -1861,11 +1859,13 @@ impl SenderBuilder {
                 }
 
                 #[cfg(feature = "ilp-over-http")]
-                "min_throughput" => builder.min_throughput(parse_conf_value(key, val)?)?,
+                "request_min_throughput" => {
+                    builder.request_min_throughput(parse_conf_value(key, val)?)?
+                }
 
                 #[cfg(feature = "ilp-over-http")]
-                "grace_timeout" => {
-                    builder.grace_timeout(Duration::from_millis(parse_conf_value(key, val)?))?
+                "request_timeout" => {
+                    builder.request_timeout(Duration::from_millis(parse_conf_value(key, val)?))?
                 }
 
                 #[cfg(feature = "ilp-over-http")]
@@ -2082,8 +2082,6 @@ impl SenderBuilder {
 
     /// Set the path to a custom root certificate `.pem` file.
     /// This is used to validate the server's certificate during the TLS handshake.
-    /// The file may be password-protected, if so, also specify the password.
-    /// via the [`tls_roots_password`](SenderBuilder::tls_roots_password) method.
     ///
     /// See notes on how to test with [self-signed certificates](https://github.com/questdb/c-questdb-client/tree/main/tls_certs).
     pub fn tls_roots<P: Into<PathBuf>>(self, path: P) -> Result<Self> {
@@ -2137,14 +2135,15 @@ impl SenderBuilder {
     /// The default is 100 KiB/s.
     /// The value is expressed as a number of bytes per second.
     /// This is used to calculate additional request timeout, on top of
-    /// the [`grace_timeout`](SenderBuilder::grace_timeout).
-    pub fn min_throughput(mut self, value: u64) -> Result<Self> {
+    /// the [`request_timeout`](SenderBuilder::request_timeout).
+    pub fn request_min_throughput(mut self, value: u64) -> Result<Self> {
         if let Some(http) = &mut self.http {
-            http.min_throughput.set_specified("min_throughput", value)?;
+            http.request_min_throughput
+                .set_specified("request_min_throughput", value)?;
         } else {
             return Err(error::fmt!(
                 ConfigError,
-                "\"min_throughput\" is supported only in ILP over HTTP."
+                "\"request_min_throughput\" is supported only in ILP over HTTP."
             ));
         }
         Ok(self)
@@ -2153,14 +2152,15 @@ impl SenderBuilder {
     #[cfg(feature = "ilp-over-http")]
     /// Grace request timeout before relying on the minimum throughput logic.
     /// The default is 5 seconds.
-    /// See [`min_throughput`](SenderBuilder::min_throughput) for more details.
-    pub fn grace_timeout(mut self, value: Duration) -> Result<Self> {
+    /// See [`request_min_throughput`](SenderBuilder::request_min_throughput) for more details.
+    pub fn request_timeout(mut self, value: Duration) -> Result<Self> {
         if let Some(http) = &mut self.http {
-            http.grace_timeout.set_specified("grace_timeout", value)?;
+            http.request_timeout
+                .set_specified("request_timeout", value)?;
         } else {
             return Err(error::fmt!(
                 ConfigError,
-                "\"grace_timeout\" is supported only in ILP over HTTP."
+                "\"request_timeout\" is supported only in ILP over HTTP."
             ));
         }
         Ok(self)
@@ -2663,8 +2663,8 @@ impl Sender {
                     ));
                 }
                 let timeout = Duration::from_secs_f64(
-                    (bytes.len() as f64) / (*state.config.min_throughput as f64),
-                ) + *state.config.grace_timeout;
+                    (bytes.len() as f64) / (*state.config.request_min_throughput as f64),
+                ) + *state.config.request_timeout;
                 let request = state
                     .agent
                     .post(&state.url)

questdb-rs/src/ingress/tests.rs

@@ -360,25 +360,26 @@ fn tcps_tls_roots_file_with_password() {
 
 #[cfg(feature = "ilp-over-http")]
 #[test]
-fn http_min_throughput() {
-    let builder = SenderBuilder::from_conf("http::addr=localhost;min_throughput=100;").unwrap();
+fn http_request_min_throughput() {
+    let builder =
+        SenderBuilder::from_conf("http::addr=localhost;request_min_throughput=100;").unwrap();
     let Some(http_config) = builder.http else {
         panic!("Expected Some(HttpConfig)");
     };
-    assert_specified_eq(&http_config.min_throughput, 100u64);
-    assert_defaulted_eq(&http_config.grace_timeout, Duration::from_millis(5000));
+    assert_specified_eq(&http_config.request_min_throughput, 100u64);
+    assert_defaulted_eq(&http_config.request_timeout, Duration::from_millis(5000));
     assert_defaulted_eq(&http_config.retry_timeout, Duration::from_millis(10000));
 }
 
 #[cfg(feature = "ilp-over-http")]
 #[test]
-fn http_grace_timeout() {
-    let builder = SenderBuilder::from_conf("http::addr=localhost;grace_timeout=100;").unwrap();
+fn http_request_timeout() {
+    let builder = SenderBuilder::from_conf("http::addr=localhost;request_timeout=100;").unwrap();
     let Some(http_config) = builder.http else {
         panic!("Expected Some(HttpConfig)");
     };
-    assert_defaulted_eq(&http_config.min_throughput, 102400u64);
-    assert_specified_eq(&http_config.grace_timeout, Duration::from_millis(100));
+    assert_defaulted_eq(&http_config.request_min_throughput, 102400u64);
+    assert_specified_eq(&http_config.request_timeout, Duration::from_millis(100));
     assert_defaulted_eq(&http_config.retry_timeout, Duration::from_millis(10000));
 }
 
@@ -389,8 +390,8 @@ fn http_retry_timeout() {
     let Some(http_config) = builder.http else {
         panic!("Expected Some(HttpConfig)");
     };
-    assert_defaulted_eq(&http_config.min_throughput, 102400u64);
-    assert_defaulted_eq(&http_config.grace_timeout, Duration::from_millis(5000));
+    assert_defaulted_eq(&http_config.request_min_throughput, 102400u64);
+    assert_defaulted_eq(&http_config.request_timeout, Duration::from_millis(5000));
     assert_specified_eq(&http_config.retry_timeout, Duration::from_millis(100));
 }
 

questdb-rs/src/tests/http.rs

@@ -419,7 +419,7 @@ fn test_token_auth() -> TestResult {
 }
 
 #[test]
-fn test_grace_timeout() -> TestResult {
+fn test_request_timeout() -> TestResult {
     let mut buffer = Buffer::new();
     buffer
         .table("test")?
@@ -430,16 +430,19 @@ fn test_grace_timeout() -> TestResult {
     // Here we use a mock (tcp) server instead and don't send a response back.
     let server = MockServer::new()?;
 
-    let grace = Duration::from_millis(50);
+    let request_timeout = Duration::from_millis(50);
     let time_start = std::time::Instant::now();
-    let mut sender = server.lsb_http().grace_timeout(grace)?.build()?;
+    let mut sender = server
+        .lsb_http()
+        .request_timeout(request_timeout)?
+        .build()?;
     let res = sender.flush_and_keep(&buffer);
     let time_elapsed = time_start.elapsed();
     assert!(res.is_err());
     let err = res.unwrap_err();
     assert_eq!(err.code(), ErrorCode::SocketError);
     assert!(err.msg().contains("timed out reading response"));
-    assert!(time_elapsed >= grace);
+    assert!(time_elapsed >= request_timeout);
     Ok(())
 }
 

system_test/questdb_line_sender.py

@@ -355,13 +355,13 @@ def set_sig(fn, restype, *argtypes):
         c_uint64,
         c_line_sender_error_p_p)
     set_sig(
-        dll.line_sender_opts_min_throughput,
+        dll.line_sender_opts_request_min_throughput,
         c_bool,
         c_line_sender_opts_p,
         c_uint64,
         c_line_sender_error_p_p)
     set_sig(
-        dll.line_sender_opts_grace_timeout,
+        dll.line_sender_opts_request_timeout,
         c_bool,
         c_line_sender_opts_p,
         c_uint64,