Load balancer

Cargo.toml

@@ -110,7 +110,7 @@ required-features = ["std", "rand"]
 
 [[example]]
 name = "client-transports"
-required-features = ["net", "unstable-client-transport"]
+required-features = ["net", "unstable-client-transport", "tokio-rustls"]
 
 [[example]]
 name = "server-transports"

examples/client-transports.rs

@@ -1,24 +1,19 @@
-/// Using the `domain::net::client` module for sending a query.
+//! Using the `domain::net::client` module for sending a query.
+use domain::base::{MessageBuilder, Name, Rtype};
+use domain::net::client::protocol::{TcpConnect, TlsConnect, UdpConnect};
+use domain::net::client::request::{
+    RequestMessage, RequestMessageMulti, SendRequest,
+};
+use domain::net::client::{
+    cache, dgram, dgram_stream, load_balancer, multi_stream, redundant,
+    stream,
+};
 use std::net::{IpAddr, SocketAddr};
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
 use std::vec::Vec;
 
-use domain::base::MessageBuilder;
-use domain::base::Name;
-use domain::base::Rtype;
-use domain::net::client::cache;
-use domain::net::client::dgram;
-use domain::net::client::dgram_stream;
-use domain::net::client::multi_stream;
-use domain::net::client::protocol::{TcpConnect, TlsConnect, UdpConnect};
-use domain::net::client::redundant;
-use domain::net::client::request::{
-    RequestMessage, RequestMessageMulti, SendRequest,
-};
-use domain::net::client::stream;
-
 #[cfg(feature = "tsig")]
 use domain::net::client::request::SendRequestMulti;
 #[cfg(feature = "tsig")]
@@ -205,9 +200,9 @@ async fn main() {
     });
 
     // Add the previously created transports.
-    redun.add(Box::new(udptcp_conn)).await.unwrap();
-    redun.add(Box::new(tcp_conn)).await.unwrap();
-    redun.add(Box::new(tls_conn)).await.unwrap();
+    redun.add(Box::new(udptcp_conn.clone())).await.unwrap();
+    redun.add(Box::new(tcp_conn.clone())).await.unwrap();
+    redun.add(Box::new(tls_conn.clone())).await.unwrap();
 
     // Start a few queries.
     for i in 1..10 {
@@ -220,6 +215,37 @@ async fn main() {
 
     drop(redun);
 
+    // Create a transport connection for load balanced connections.
+    let (lb, transp) = load_balancer::Connection::new();
+
+    // Start the run function on a separate task.
+    let run_fut = transp.run();
+    tokio::spawn(async move {
+        run_fut.await;
+        println!("load_balancer run terminated");
+    });
+
+    // Add the previously created transports.
+    let mut conn_conf = load_balancer::ConnConfig::new();
+    conn_conf.set_max_burst(Some(10));
+    conn_conf.set_burst_interval(Duration::from_secs(10));
+    lb.add("UDP+TCP", &conn_conf, Box::new(udptcp_conn))
+        .await
+        .unwrap();
+    lb.add("TCP", &conn_conf, Box::new(tcp_conn)).await.unwrap();
+    lb.add("TLS", &conn_conf, Box::new(tls_conn)).await.unwrap();
+
+    // Start a few queries.
+    for i in 1..10 {
+        let mut request = lb.send_request(req.clone());
+        let reply = request.get_response().await;
+        if i == 2 {
+            println!("load_balancer connection reply: {reply:?}");
+        }
+    }
+
+    drop(lb);
+
     // Create a new datagram transport connection. Pass the destination address
     // and port as parameter. This transport does not retry over TCP if the
     // reply is truncated. This transport does not have a separate run