Return driver as first member of endpoint tuple

interop/src/main.rs

@@ -85,8 +85,8 @@ fn run(log: Logger, options: Opt) -> Result<()> {
     };
 
     builder.logger(log.clone());
-    let (endpoint, driver, _) = builder.bind("[::]:0")?;
-    runtime.spawn(driver.map_err(|e| eprintln!("IO error: {}", e)));
+    let (endpoint_driver, endpoint, _) = builder.bind("[::]:0")?;
+    runtime.spawn(endpoint_driver.map_err(|e| eprintln!("IO error: {}", e)));
 
     let mut handshake = false;
     let mut stream_data = false;

quinn/examples/client.rs

@@ -94,9 +94,9 @@ fn run(log: Logger, options: Opt) -> Result<()> {
 
     endpoint.default_client_config(client_config.build());
 
-    let (endpoint, driver, _) = endpoint.bind("[::]:0")?;
+    let (endpoint_driver, endpoint, _) = endpoint.bind("[::]:0")?;
     let mut runtime = Runtime::new()?;
-    runtime.spawn(driver.map_err(|e| eprintln!("IO error: {}", e)));
+    runtime.spawn(endpoint_driver.map_err(|e| eprintln!("IO error: {}", e)));
 
     let request = format!("GET {}\r\n", url.path());
     let start = Instant::now();

quinn/examples/server.rs

@@ -150,13 +150,13 @@ fn run(log: Logger, options: Opt) -> Result<()> {
         bail!("root path does not exist");
     }
 
-    let (_, driver, incoming) = endpoint.bind(options.listen)?;
+    let (endpoint_driver, _, incoming) = endpoint.bind(options.listen)?;
     let mut runtime = Runtime::new()?;
     runtime.spawn(incoming.for_each(move |conn| {
         handle_connection(&root, &log, conn);
         Ok(())
     }));
-    runtime.block_on(driver)?;
+    runtime.block_on(endpoint_driver)?;
 
     Ok(())
 }

quinn/src/builders.rs

@@ -38,7 +38,7 @@ impl<'a> EndpointBuilder<'a> {
     pub fn bind<T: ToSocketAddrs>(
         self,
         addr: T,
-    ) -> Result<(Endpoint, EndpointDriver, Incoming), EndpointError> {
+    ) -> Result<(EndpointDriver, Endpoint, Incoming), EndpointError> {
         let socket = std::net::UdpSocket::bind(addr).map_err(EndpointError::Socket)?;
         self.from_socket(socket)
     }
@@ -47,7 +47,7 @@ impl<'a> EndpointBuilder<'a> {
     pub fn from_socket(
         self,
         socket: std::net::UdpSocket,
-    ) -> Result<(Endpoint, EndpointDriver, Incoming), EndpointError> {
+    ) -> Result<(EndpointDriver, Endpoint, Incoming), EndpointError> {
         let reactor = if let Some(x) = self.reactor {
             Cow::Borrowed(x)
         } else {
@@ -66,11 +66,11 @@ impl<'a> EndpointBuilder<'a> {
             addr.is_ipv6(),
         );
         Ok((
+            EndpointDriver(rc.clone()),
             Endpoint {
                 inner: rc.clone(),
                 default_client_config: self.client_config,
             },
-            EndpointDriver(rc.clone()),
             Incoming::new(rc),
         ))
     }

quinn/src/lib.rs

@@ -18,8 +18,8 @@
 //! let mut runtime = tokio::runtime::current_thread::Runtime::new().unwrap();
 //! let mut builder = quinn::Endpoint::new();
 //! // <configure builder>
-//! let (endpoint, driver, _) = builder.bind("[::]:0").unwrap();
-//! runtime.spawn(driver.map_err(|e| panic!("IO error: {}", e)));
+//! let (endpoint_driver, endpoint, _) = builder.bind("[::]:0").unwrap();
+//! runtime.spawn(endpoint_driver.map_err(|e| panic!("IO error: {}", e)));
 //! // ...
 //! # }
 //! ```

quinn/src/tests.rs

@@ -12,7 +12,7 @@ use super::{read_to_end, ClientConfigBuilder, Endpoint, NewStream, ServerConfigB
 #[test]
 fn handshake_timeout() {
     let client = Endpoint::new();
-    let (client, client_driver, _) = client
+    let (client_driver, client, _) = client
         .bind(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0))
         .unwrap();
 
@@ -55,7 +55,7 @@ fn handshake_timeout() {
 #[test]
 fn local_addr() {
     let port = 56987;
-    let (ep, _, _) = Endpoint::new()
+    let (_, ep, _) = Endpoint::new()
         .bind(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port))
         .expect("Could not bind to localhost");
     assert_eq!(
@@ -107,7 +107,7 @@ fn run_echo(client_addr: SocketAddr, server_addr: SocketAddr) {
         server.listen(server_config.build());
         let server_sock = UdpSocket::bind(server_addr).unwrap();
         let server_addr = server_sock.local_addr().unwrap();
-        let (_, server_driver, server_incoming) = server.from_socket(server_sock).unwrap();
+        let (server_driver, _, server_incoming) = server.from_socket(server_sock).unwrap();
 
         let mut client_config = ClientConfigBuilder::default();
         client_config.add_certificate_authority(cert).unwrap();
@@ -115,7 +115,7 @@ fn run_echo(client_addr: SocketAddr, server_addr: SocketAddr) {
         let mut client = Endpoint::new();
         client.logger(log.clone());
         client.default_client_config(client_config.build());
-        let (client, client_driver, _) = client.bind(client_addr).unwrap();
+        let (client_driver, client, _) = client.bind(client_addr).unwrap();
 
         runtime.spawn(server_driver.map_err(|e| panic!("server driver failed: {}", e)));
         runtime.spawn(client_driver.map_err(|e| panic!("client driver failed: {}", e)));