Do not start default resolver immediately for default connector.

actix-connect/CHANGES.md

@@ -1,5 +1,18 @@
 # Changes
 
+## [0.1.4] - 2019-04-12
+
+### Changed
+
+* Do not start default resolver immediately for default connector.
+
+
+## [0.1.3] - 2019-04-11
+
+### Changed
+
+* Start trust-dns default resolver on first use
+
 ## [0.1.2] - 2019-04-04
 
 ### Added

actix-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-connect"
-version = "0.1.2"
+version = "0.1.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Connector - tcp connector service"
 keywords = ["network", "framework", "async", "futures"]
@@ -30,9 +30,9 @@ ssl = ["openssl", "tokio-openssl"]
 uri = ["http"]
 
 [dependencies]
-actix-service = "0.3.4"
-actix-codec = "0.1.1"
-actix-utils = "0.3.4"
+actix-service = "0.3.6"
+actix-codec = "0.1.2"
+actix-utils = "0.3.5"
 derive_more = "0.14.0"
 either = "1.5.1"
 futures = "0.1.25"
@@ -40,7 +40,7 @@ http = { version = "0.1.16", optional = true }
 log = "0.4"
 tokio-tcp = "0.1.3"
 tokio-current-thread = "0.1.5"
-trust-dns-resolver = { version="0.11.0-alpha.2", default-features = false }
+trust-dns-resolver = { version="0.11.0-alpha.3", default-features = false }
 
 # openssl
 openssl = { version="0.10", optional = true }
@@ -48,8 +48,8 @@ tokio-openssl = { version="0.3", optional = true }
 
 [dev-dependencies]
 bytes = "0.4"
-actix-connect = { path=".", features=["ssl"] }
-actix-test-server = { version="0.2.0", features=["ssl"] }
+#actix-test-server = { version="0.2.0", features=["ssl"] }
+actix-test-server = { path="../actix-test-server", features=["ssl"] }
 actix-server-config = "0.1.0"
 actix-utils = "0.3.4"
 tokio-tcp = "0.1"

actix-connect/src/lib.rs

@@ -8,6 +8,8 @@
 #[macro_use]
 extern crate log;
 
+use std::cell::RefCell;
+
 mod connect;
 mod connector;
 mod error;
@@ -46,18 +48,34 @@ pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver
     resolver
 }
 
-pub fn start_default_resolver() -> AsyncResolver {
-    let (cfg, opts) = match read_system_conf() {
-        Ok((cfg, opts)) => (cfg, opts),
-        Err(e) => {
-            log::error!("TRust-DNS can not load system config: {}", e);
-            (ResolverConfig::default(), ResolverOpts::default())
-        }
-    };
+thread_local! {
+    static DEFAULT_RESOLVER: RefCell<Option<AsyncResolver>> = RefCell::new(None);
+}
 
-    let (resolver, bg) = AsyncResolver::new(cfg, opts);
-    tokio_current_thread::spawn(bg);
-    resolver
+pub(crate) fn get_default_resolver() -> AsyncResolver {
+    DEFAULT_RESOLVER.with(|cell| {
+        if let Some(ref resolver) = *cell.borrow() {
+            return resolver.clone();
+        }
+
+        let (cfg, opts) = match read_system_conf() {
+            Ok((cfg, opts)) => (cfg, opts),
+            Err(e) => {
+                log::error!("TRust-DNS can not load system config: {}", e);
+                (ResolverConfig::default(), ResolverOpts::default())
+            }
+        };
+
+        let (resolver, bg) = AsyncResolver::new(cfg, opts);
+        tokio_current_thread::spawn(bg);
+
+        *cell.borrow_mut() = Some(resolver.clone());
+        resolver
+    })
+}
+
+pub fn start_default_resolver() -> AsyncResolver {
+    get_default_resolver()
 }
 
 /// Create tcp connector service
@@ -84,7 +102,7 @@ pub fn new_connector_factory<T: Address>(
 pub fn default_connector<T: Address>(
 ) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
          + Clone {
-    Resolver::new(start_default_resolver()).and_then(TcpConnector::new())
+    Resolver::default().and_then(TcpConnector::new())
 }
 
 /// Create connector service factory with default parameters
@@ -94,5 +112,5 @@ pub fn default_connector_factory<T: Address>() -> impl NewService<
     Error = ConnectError,
     InitError = (),
 > + Clone {
-    ResolverFactory::new(start_default_resolver()).and_then(TcpConnectorFactory::new())
+    ResolverFactory::default().and_then(TcpConnectorFactory::new())
 }

actix-connect/src/resolver.rs

@@ -10,10 +10,11 @@ use trust_dns_resolver::{AsyncResolver, Background};
 
 use crate::connect::{Address, Connect};
 use crate::error::ConnectError;
+use crate::get_default_resolver;
 
 /// DNS Resolver Service factory
 pub struct ResolverFactory<T> {
-    resolver: AsyncResolver,
+    resolver: Option<AsyncResolver>,
     _t: PhantomData<T>,
 }
 
@@ -21,13 +22,18 @@ impl<T> ResolverFactory<T> {
     /// Create new resolver instance with custom configuration and options.
     pub fn new(resolver: AsyncResolver) -> Self {
         ResolverFactory {
-            resolver,
+            resolver: Some(resolver),
             _t: PhantomData,
         }
     }
+}
 
-    pub fn resolver(&self) -> &AsyncResolver {
-        &self.resolver
+impl<T> Default for ResolverFactory<T> {
+    fn default() -> Self {
+        ResolverFactory {
+            resolver: None,
+            _t: PhantomData,
+        }
     }
 }
 
@@ -58,7 +64,7 @@ impl<T: Address> NewService for ResolverFactory<T> {
 
 /// DNS Resolver Service
 pub struct Resolver<T> {
-    resolver: AsyncResolver,
+    resolver: Option<AsyncResolver>,
     _t: PhantomData<T>,
 }
 
@@ -66,7 +72,16 @@ impl<T> Resolver<T> {
     /// Create new resolver instance with custom configuration and options.
     pub fn new(resolver: AsyncResolver) -> Self {
         Resolver {
-            resolver,
+            resolver: Some(resolver),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T> Default for Resolver<T> {
+    fn default() -> Self {
+        Resolver {
+            resolver: None,
             _t: PhantomData,
         }
     }
@@ -100,7 +115,10 @@ impl<T: Address> Service for Resolver<T> {
                 Either::B(ok(req))
             } else {
                 trace!("DNS resolver: resolving host {:?}", req.host());
-                Either::A(ResolverFuture::new(req, &self.resolver))
+                if self.resolver.is_none() {
+                    self.resolver = Some(get_default_resolver());
+                }
+                Either::A(ResolverFuture::new(req, self.resolver.as_ref().unwrap()))
             }
         }
     }

actix-connect/tests/test_connect.rs

@@ -9,6 +9,7 @@ use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
 
 use actix_connect::{default_connector, Connect};
 
+#[cfg(feature = "ssl")]
 #[test]
 fn test_string() {
     let mut srv = TestServer::with(|| {
@@ -19,11 +20,9 @@ fn test_string() {
         })
     });
 
-    let mut conn = srv
-        .block_on(lazy(|| Ok::<_, ()>(default_connector())))
-        .unwrap();
+    let mut conn = default_connector();
     let addr = format!("localhost:{}", srv.port());
-    let con = srv.block_on(conn.call(addr.into())).unwrap();
+    let con = srv.run_on(move || conn.call(addr.into())).unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
@@ -92,6 +91,7 @@ fn test_new_service() {
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
+#[cfg(feature = "ssl")]
 #[test]
 fn test_uri() {
     let mut srv = TestServer::with(|| {
@@ -102,10 +102,8 @@ fn test_uri() {
         })
     });
 
-    let mut conn = srv
-        .block_on(lazy(|| Ok::<_, ()>(default_connector())))
-        .unwrap();
+    let mut conn = default_connector();
     let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
-    let con = srv.block_on(conn.call(addr.into())).unwrap();
+    let con = srv.run_on(move || conn.call(addr.into())).unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }

actix-test-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-test-server"
-version = "0.2.0"
+version = "0.2.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix test server"
 keywords = ["network", "framework", "async", "futures"]

actix-test-server/src/lib.rs

@@ -6,7 +6,7 @@ use actix_rt::{Runtime, System};
 use actix_server::{Server, StreamServiceFactory};
 pub use actix_server_config::{Io, ServerConfig};
 
-use futures::Future;
+use futures::future::{lazy, Future, IntoFuture};
 use net2::TcpBuilder;
 use tokio_reactor::Handle;
 use tokio_tcp::TcpStream;
@@ -99,6 +99,15 @@ impl TestServerRuntime {
         self.rt.block_on(fut)
     }
 
+    /// Runs the provided function, with runtime enabled.
+    pub fn run_on<F, R>(&mut self, f: F) -> Result<R::Item, R::Error>
+    where
+        F: FnOnce() -> R,
+        R: IntoFuture,
+    {
+        self.rt.block_on(lazy(|| f().into_future()))
+    }
+
     /// Spawn future to the current runtime
     pub fn spawn<F>(&mut self, fut: F)
     where