implement SRV lookup

src/happy_eyeballs.rs

@@ -0,0 +1,91 @@
+use std::str::FromStr;
+use futures::*;
+use tokio_core::reactor::Handle;
+use tokio_core::net::{TcpStream, TcpStreamNew};
+use domain::resolv::Resolver;
+use domain::resolv::lookup::srv::*;
+use domain::bits::DNameBuf;
+
+pub struct Connecter {
+    handle: Handle,
+    resolver: Resolver,
+    lookup: Option<LookupSrv>,
+    srvs: Option<LookupSrvStream>,
+    connects: Vec<TcpStreamNew>,
+}
+
+impl Connecter {
+    pub fn from_lookup(handle: Handle, domain: &str, srv: &str, fallback_port: u16) -> Result<Connecter, String> {
+        let domain = try!(
+            DNameBuf::from_str(domain)
+                .map_err(|e| format!("{}", e))
+        );
+        let srv = try!(
+            DNameBuf::from_str(srv)
+                .map_err(|e| format!("{}", e))
+        );
+
+        let resolver = Resolver::new(&handle);
+        let lookup = lookup_srv(resolver.clone(), srv, domain, fallback_port);
+
+        Ok(Connecter {
+            handle,
+            resolver,
+            lookup: Some(lookup),
+            srvs: None,
+            connects: vec![],
+        })
+    }
+}
+
+impl Future for Connecter {
+    type Item = TcpStream;
+    type Error = String;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.lookup.as_mut().map(|mut lookup| lookup.poll()) {
+            None => (),
+            Some(Ok(Async::NotReady)) => (),
+            Some(Ok(Async::Ready(found_srvs))) => {
+                self.lookup = None;
+                match found_srvs {
+                    Some(srvs) =>
+                        self.srvs = Some(srvs.to_stream(self.resolver.clone())),
+                    None =>
+                        return Err("No SRV records".to_owned()),
+                }
+            },
+            Some(Err(e)) =>
+                return Err(format!("{}", e)),
+        }
+
+        match self.srvs.as_mut().map(|mut srv| srv.poll()) {
+            None => (),
+            Some(Ok(Async::NotReady)) => (),
+            Some(Ok(Async::Ready(None))) =>
+                self.srvs = None,
+            Some(Ok(Async::Ready(Some(srv_item)))) => {
+                for addr in srv_item.to_socket_addrs() {
+                    println!("Connect to {}", addr);
+                    let connect = TcpStream::connect(&addr, &self.handle);
+                    self.connects.push(connect);
+                }
+            },
+            Some(Err(e)) =>
+                return Err(format!("{}", e)),
+        }
+
+        for mut connect in &mut self.connects {
+            match connect.poll() {
+                Ok(Async::NotReady) => (),
+                Ok(Async::Ready(tcp_stream)) =>
+                    // Success!
+                    return Ok(Async::Ready(tcp_stream)),
+                Err(e) =>
+                    return Err(format!("{}", e)),
+            }
+        }
+        
+        Ok(Async::NotReady)
+    }
+}