more progress tidying up feature flags

amunra · amunra · commit 70d044fa5a68 · 2025-06-26T11:27:40.000+01:00
diff --git a/questdb-rs/Cargo.toml b/questdb-rs/Cargo.toml
@@ -37,7 +37,8 @@ chrono = { version = "0.4.40", optional = true }
 # the `ureq::unversioned` module which does not respect semantic versioning.
 ureq = { version = "3.0.10, <3.1.0", default-features = false, features = ["rustls-no-provider"], optional = true }
 
-tokio = { version = "1.45.1", default-features = false, optional = true }
+tokio = { version = "1.45.1", default-features = false, features = ["net"], optional = true }
+tokio-rustls = { version = "0.26.2", default-features = false, optional = true }
 hyper = { version = "1.6.0", default-features = false, optional = true }
 
 serde_json = { version = "1", optional = true }
@@ -68,16 +69,16 @@ default = ["sync-sender", "tls-webpki-certs", "ring-crypto"]
 sync-sender = ["sync-sender-tcp", "sync-sender-http"]
 
 # Sync ILP/TCP
-sync-sender-tcp = ["_sender-tcp"]
+sync-sender-tcp = ["_sync-sender", "_sender-tcp"]
 
 # Sync ILP/HTTP
-sync-sender-http = ["_sender-http", "dep:ureq", "dep:serde_json", "dep:rand"]
+sync-sender-http = ["_sync-sender", "_sender-http", "dep:ureq", "dep:serde_json", "dep:rand"]
 
 # Async ILP/TCP + ILP/HTTP Sender
-async-sender = ["async-sender-tcp", "async-sender-http"]
+async-sender = ["_async-sender", "async-sender-tcp", "async-sender-http"]
 
 # Async ILP/TCP Sender
-async-sender-tcp = ["_sender-tcp", "dep:tokio"]
+async-sender-tcp = ["_async-sender", "_sender-tcp", "dep:tokio", "dep:tokio-rustls"]
 
 # Async ILP/HTTP Sender
 async-sender-http = ["_sender-http", "dep:tokio", "dep:hyper"]
@@ -109,6 +110,8 @@ chrono_timestamp = ["chrono"]
 # Hidden derived features, used in code to enable-disable code sections. Don't use directly.
 _sender-tcp = []
 _sender-http = []
+_sync-sender = []
+_async-sender = []
 
 # The `aws-lc-crypto` and `ring-crypto` features are mutually exclusive,
 # thus compiling with `--all-features` will not work.
diff --git a/questdb-rs/src/ingress/http.rs b/questdb-rs/src/ingress/http.rs
@@ -95,7 +95,8 @@ impl Default for HttpConfig {
     }
 }
 
-pub(super) struct HttpHandlerState {
+#[cfg(feature = "sync-sender-http")]
+pub(super) struct SyncHttpHandlerState {
     /// Maintains a pool of open HTTP connections to the endpoint.
     pub(super) agent: ureq::Agent,
 
@@ -109,7 +110,8 @@ pub(super) struct HttpHandlerState {
     pub(super) config: HttpConfig,
 }
 
-impl HttpHandlerState {
+#[cfg(feature = "sync-sender-http")]
+impl SyncHttpHandlerState {
     fn send_request(
         &self,
         buf: &[u8],
@@ -384,7 +386,7 @@ pub(super) fn parse_http_error(http_status_code: u16, response: Response<Body>)
 
 #[allow(clippy::result_large_err)] // `ureq::Error` is large enough to cause this warning.
 fn retry_http_send(
-    state: &HttpHandlerState,
+    state: &SyncHttpHandlerState,
     buf: &[u8],
     request_timeout: Duration,
     retry_timeout: Duration,
@@ -417,7 +419,7 @@ fn retry_http_send(
 
 #[allow(clippy::result_large_err)] // `ureq::Error` is large enough to cause this warning.
 pub(super) fn http_send_with_retries(
-    state: &HttpHandlerState,
+    state: &SyncHttpHandlerState,
     buf: &[u8],
     request_timeout: Duration,
     retry_timeout: Duration,
@@ -438,7 +440,7 @@ pub(super) fn http_send_with_retries(
 /// If the server does not support the `/settings` endpoint (404), it returns
 /// default values.
 pub(super) fn read_server_settings(
-    state: &HttpHandlerState,
+    state: &SyncHttpHandlerState,
     settings_url: &str,
     default_max_name_len: usize,
 ) -> Result<(Vec<ProtocolVersion>, usize), Error> {
@@ -540,7 +542,7 @@ pub(super) fn read_server_settings(
 
 #[allow(clippy::result_large_err)] // `ureq::Error` is large enough to cause this warning.
 fn retry_http_get(
-    state: &HttpHandlerState,
+    state: &SyncHttpHandlerState,
     url: &str,
     request_timeout: Duration,
     retry_timeout: Duration,
@@ -573,7 +575,7 @@ fn retry_http_get(
 
 #[allow(clippy::result_large_err)] // `ureq::Error` is large enough to cause this warning.
 fn http_get_with_retries(
-    state: &HttpHandlerState,
+    state: &SyncHttpHandlerState,
     url: &str,
     request_timeout: Duration,
     retry_timeout: Duration,
diff --git a/questdb-rs/src/ingress/mod.rs b/questdb-rs/src/ingress/mod.rs
@@ -38,7 +38,11 @@ use socket2::{Domain, Protocol as SockProtocol, SockAddr, Socket, Type};
 use std::collections::HashMap;
 use std::convert::Infallible;
 use std::fmt::{Debug, Display, Formatter, Write};
-use std::io::{self, BufRead, BufReader, ErrorKind, Write as IoWrite};
+use std::io::{self, BufReader, ErrorKind, Write as IoWrite};
+
+#[cfg(feature = "sync-sender-tcp")]
+use std::io::BufRead;
+
 use std::num::NonZeroUsize;
 use std::ops::Deref;
 use std::path::PathBuf;
@@ -350,12 +354,20 @@ fn write_escaped_quoted(output: &mut Vec<u8>, s: &str) {
     write_escaped_impl(must_escape_quoted, |output| output.push(b'"'), output, s)
 }
 
-enum Connection {
+#[cfg(feature = "sync-sender-tcp")]
+enum SyncConnection {
     Direct(Socket),
     Tls(Box<StreamOwned<ClientConnection, Socket>>),
 }
 
-impl Connection {
+#[cfg(feature = "async-sender-tcp")]
+enum AsyncConnection {
+    Direct(tokio::net::TcpStream),
+    Tls(Box<tokio_rustls::client::TlsStream<tokio::net::TcpStream>>),
+}
+
+#[cfg(feature = "sync-sender-tcp")]
+impl SyncConnection {
     fn send_key_id(&mut self, key_id: &str) -> Result<()> {
         writeln!(self, "{}", key_id)
             .map_err(|io_err| map_io_to_socket_err("Failed to send key_id: ", io_err))?;
@@ -419,16 +431,22 @@ impl Connection {
     }
 }
 
-#[cfg(any(feature = "sync-sender-tcp", feature = "sync-sender-http"))]
 enum ProtocolHandler {
     #[cfg(feature = "sync-sender-tcp")]
-    Socket(Connection),
+    SyncTcp(SyncConnection),
 
     #[cfg(feature = "sync-sender-http")]
-    Http(HttpHandlerState),
+    SyncHttp(SyncHttpHandlerState),
+
+    #[cfg(feature = "async-sender-tcp")]
+    AsyncTcp(AsyncConnection),
+
+    #[cfg(feature = "async-sender-http")]
+    AsyncHttp()
 }
 
-impl io::Read for Connection {
+#[cfg(feature = "sync-sender-tcp")]
+impl io::Read for SyncConnection {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
             Self::Direct(sock) => sock.read(buf),
@@ -437,7 +455,8 @@ impl io::Read for Connection {
     }
 }
 
-impl io::Write for Connection {
+#[cfg(feature = "sync-sender-tcp")]
+impl IoWrite for SyncConnection {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         match self {
             Self::Direct(sock) => sock.write(buf),
@@ -1379,6 +1398,7 @@ impl Buffer {
     }
 }
 
+#[cfg(feature = "_sync-sender")]
 /// Connects to a QuestDB instance and inserts data via the ILP protocol.
 ///
 /// * To construct an instance, use [`Sender::from_conf`] or the [`SenderBuilder`].
@@ -1393,7 +1413,8 @@ pub struct Sender {
     max_name_len: usize,
 }
 
-impl std::fmt::Debug for Sender {
+#[cfg(feature = "_sync-sender")]
+impl Debug for Sender {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         f.write_str(self.descr.as_str())
     }
@@ -1867,7 +1888,7 @@ pub struct SenderBuilder {
 
     tls_ca: ConfigSetting<CertificateAuthority>,
     tls_roots: ConfigSetting<Option<PathBuf>>,
-    
+
     #[cfg(feature = "_sender-http")]
     http: Option<HttpConfig>,
 }
@@ -2359,6 +2380,7 @@ impl SenderBuilder {
         Ok(self)
     }
 
+    #[cfg(feature = "sync-sender-tcp")]
     fn connect_tcp(&self, auth: &Option<AuthParams>) -> Result<ProtocolHandler> {
         let addr: SockAddr = gai::resolve_host_port(self.host.as_str(), self.port.as_str())?;
         let mut sock = Socket::new(Domain::IPV4, Type::STREAM, Some(SockProtocol::TCP))
@@ -2439,16 +2461,16 @@ impl SenderBuilder {
                         }
                     })?;
                 }
-                Connection::Tls(StreamOwned::new(tls_conn, sock).into())
+                SyncConnection::Tls(StreamOwned::new(tls_conn, sock).into())
             }
-            None => Connection::Direct(sock),
+            None => SyncConnection::Direct(sock),
         };
 
         if let Some(AuthParams::Ecdsa(auth)) = auth {
             conn.authenticate(auth)?;
         }
 
-        Ok(ProtocolHandler::Socket(conn))
+        Ok(ProtocolHandler::SyncTcp(conn))
     }
 
     fn build_auth(&self) -> Result<Option<AuthParams>> {
@@ -2545,6 +2567,7 @@ impl SenderBuilder {
         }
     }
 
+    #[cfg(feature = "_sync-sender")]
     /// Build the sender.
     ///
     /// In the case of TCP, this synchronously establishes the TCP connection, and
@@ -2563,6 +2586,7 @@ impl SenderBuilder {
         let auth = self.build_auth()?;
 
         let handler = match self.protocol {
+            #[cfg(feature = "sync-sender-tcp")]
             Protocol::Tcp | Protocol::Tcps => self.connect_tcp(&auth)?,
             #[cfg(feature = "sync-sender-http")]
             Protocol::Http | Protocol::Https => {
@@ -2624,7 +2648,7 @@ impl SenderBuilder {
                     self.host.deref(),
                     self.port.deref()
                 );
-                ProtocolHandler::Http(HttpHandlerState {
+                ProtocolHandler::SyncHttp(SyncHttpHandlerState {
                     agent,
                     url,
                     auth,
@@ -2642,7 +2666,7 @@ impl SenderBuilder {
                 Protocol::Tcp | Protocol::Tcps => ProtocolVersion::V1,
                 #[cfg(feature = "sync-sender-http")]
                 Protocol::Http | Protocol::Https => {
-                    if let ProtocolHandler::Http(http_state) = &handler {
+                    if let ProtocolHandler::SyncHttp(http_state) = &handler {
                         let settings_url = &format!(
                             "{}://{}:{}/settings",
                             self.protocol.schema(),
@@ -2837,6 +2861,7 @@ impl F64Serializer {
     }
 }
 
+#[cfg(feature = "_sync-sender")]
 impl Sender {
     /// Create a new `Sender` instance from the given configuration string.
     ///
@@ -2907,7 +2932,7 @@ impl Sender {
             return Ok(());
         }
         match self.handler {
-            ProtocolHandler::Socket(ref mut conn) => {
+            ProtocolHandler::SyncTcp(ref mut conn) => {
                 if transactional {
                     return Err(error::fmt!(
                         InvalidApiCall,
@@ -2920,7 +2945,7 @@ impl Sender {
                 })?;
             }
             #[cfg(feature = "sync-sender-http")]
-            ProtocolHandler::Http(ref state) => {
+            ProtocolHandler::SyncHttp(ref state) => {
                 if transactional && !buf.transactional() {
                     return Err(error::fmt!(
                         InvalidApiCall,
