Move initial server connection to Handler::new.

src/handler.rs

@@ -1,5 +1,6 @@
 use std::collections::VecDeque;
 use std::io;
+use std::net::ToSocketAddrs;
 use std::sync::mpsc::Sender;
 
 use mio::{EventLoop, EventSet, Handler, PollOpt, Token};
@@ -37,20 +38,26 @@ pub struct ConnectionHandler {
 
 impl ConnectionHandler {
     pub fn new(
-        server_tcp_stream: TcpStream, client_tx: Sender<Response>,
-        event_loop: &mut EventLoop<Self>) -> Self
+        server_host: &str,
+        server_port: u16,
+        client_tx: Sender<Response>,
+        event_loop: &mut EventLoop<Self>)
+        -> io::Result<Self>
     {
+        let server_tcp_stream = try!(Self::connect(server_host, server_port));
+        let server_stream = PacketStream::new(server_tcp_stream);
+        info!("Connected to server at {}:{}", server_host, server_port);
+
         let mut token_counter = TokenCounter::new();
         let server_token = token_counter.next();
 
         let event_set = EventSet::readable();
         let poll_opt = PollOpt::edge() | PollOpt::oneshot();
 
-        let server_stream = PacketStream::new(server_tcp_stream);
-        server_stream.register(event_loop, server_token, event_set, poll_opt)
-            .unwrap();
+        try!(server_stream.register(
+                event_loop, server_token, event_set, poll_opt));
 
-        ConnectionHandler {
+        Ok(ConnectionHandler {
             token_counter: token_counter,
 
             server_token: server_token,
@@ -58,7 +65,17 @@ impl ConnectionHandler {
             server_queue: VecDeque::new(),
 
             client_tx: client_tx,
+        })
+    }
+
+    fn connect(hostname: &str, port: u16) -> io::Result<TcpStream> {
+        for sock_addr in try!((hostname, port).to_socket_addrs()) {
+            if let Ok(stream) = TcpStream::connect(&sock_addr) {
+                return Ok(stream)
+            }
         }
+        Err(io::Error::new(io::ErrorKind::Other,
+                       format!("Cannot connect to {}:{}", hostname, port)))
     }
 
     fn read_server(&mut self) {

src/main.rs

@@ -15,36 +15,18 @@ extern crate mio;
 extern crate rustc_serialize;
 extern crate websocket;
 
-use std::io;
-use std::net::ToSocketAddrs;
 use std::sync::mpsc::channel;
 use std::thread;
 
 use mio::EventLoop;
-use mio::tcp::TcpStream;
 
 use client::Client;
 use control::Controller;
 use handler::ConnectionHandler;
 
-fn connect(hostname: &str, port: u16) -> io::Result<TcpStream> {
-    for sock_addr in try!((hostname, port).to_socket_addrs()) {
-        if let Ok(stream) = TcpStream::connect(&sock_addr) {
-            return Ok(stream)
-        }
-    }
-    Err(io::Error::new(io::ErrorKind::Other,
-                   format!("Cannot connect to {}:{}", hostname, port)))
-}
-
 fn main() {
     env_logger::init().unwrap();
 
-    let host = config::SERVER_HOST;
-    let port = config::SERVER_PORT;
-    let stream = connect(host, port).unwrap();
-    info!("Connected to {}:{}", host, port);
-
     let mut event_loop = EventLoop::new().unwrap();
 
     let (handler_to_client_tx, handler_to_client_rx) = channel();
@@ -52,8 +34,9 @@ fn main() {
     let (client_to_control_tx, client_to_control_rx) = channel();
     let client_to_handler_tx = event_loop.channel();
 
-    let mut handler =
-        ConnectionHandler::new(stream, handler_to_client_tx, &mut event_loop);
+    let mut handler = ConnectionHandler::new(
+        config::SERVER_HOST, config::SERVER_PORT,
+        handler_to_client_tx, &mut event_loop).unwrap();
 
     let mut client = Client::new(
         client_to_handler_tx, handler_to_client_rx,