add minimal server loop using tokio

Cargo.toml

@@ -21,10 +21,16 @@ bench = false
 default = ["server", "client"]
 server = []
 client = []
-tls_no_verify = ["rustls/dangerous_configuration"]
+#tls_no_verify = ["rustls/dangerous_configuration"]
 
 [dependencies]
+argh = "*"
 chrono = "0.4"
+tokio = { version = "*", features = [ "full" ] }
+tokio-io = "*"
+tokio-rustls = { version = "*" }
+futures = "*"
+bytes = "*"
 postgres = "0.17.3"
 postgres-types = {version = "0.1.1", features = ["derive"]}
 log = "0.4"
@@ -35,8 +41,6 @@ ring="*"
 data-encoding="*"
 bincode="*"
 serde={ version = "1.0", features = ["derive"] }
-rustls="0.18.0"
-mio={ version = "0.7.0", features = ["os-poll", "tcp"] }
 webpki="0.21.0"
 webpki-roots="0.20"
 ct-logs="0.7"

src/libtrader/libtrader.rs

@@ -6,6 +6,8 @@ extern crate log;
 extern crate arrayref;
 #[cfg(all(feature = "server", not(feature = "client")))]
 extern crate json;
+#[cfg(all(feature = "server", not(feature = "client")))]
+extern crate tokio;
 
 #[cfg(all(feature = "client", not(feature = "server")))]
 #[macro_use]

src/libtrader/server/initializer.rs

@@ -1,11 +1,32 @@
-use mio::net::TcpListener;
-use std::net;
+use argh::FromArgs;
+use std::path::PathBuf;
+use tokio::io::{copy, sink, split, AsyncWriteExt};
+use tokio::net::TcpListener;
+use tokio_rustls::TlsAcceptor;
+
+use std::net::ToSocketAddrs;
 
 use crate::common::misc::gen_tls_server_config::gen_tls_server_config;
 use crate::common::misc::path_exists::path_exists;
 use crate::common::misc::return_flags::ReturnFlags;
 
-use crate::server::network::tls_server::TlsServer;
+//use crate::server::network::tls_server::TlsServer;
+
+/// Server Options
+#[derive(FromArgs)]
+struct Options {
+    /// bind addr
+    #[argh(positional)]
+    addr: String,
+
+    /// cert file
+    #[argh(option, short = 'c')]
+    cert: PathBuf,
+
+    /// key file
+    #[argh(option, short = 'k')]
+    key: PathBuf,
+}
 
 #[cfg(not(debug_assertions))]
 use crate::common::misc::gen_log::gen_log;
@@ -33,8 +54,7 @@ fn libtrader_init_log() -> Result<(), ReturnFlags> {
     gen_log();
 
     #[cfg(debug_assertions)]
-    {
-        use simplelog::*;
+    { use simplelog::*;
         use std::fs::File;
 
         if !path_exists("log") {
@@ -69,37 +89,42 @@ fn libtrader_init_log() -> Result<(), ReturnFlags> {
 /// ```rust
 ///     libtrader_init_server()?;
 /// ```
-pub fn libtrader_init_server() -> Result<(), ReturnFlags> {
+#[tokio::main]
+pub async fn libtrader_init_server() -> std::io::Result<()> {
     // Initialize log.
-    #[cfg(not(test))] // wot dis
+    //#[cfg(not(test))] // wot dis
     match libtrader_init_log() {
         Ok(()) => {}
-        Err(err) => return Err(err),
+        Err(err) => {}, // TODO: handle this case
     };
-    let addr: net::SocketAddr = "0.0.0.0:4000".parse().unwrap();
-    let config = gen_tls_server_config("certs/test_tls.crt", "certs/test_tls.key", None);
 
-    let mut listener = TcpListener::bind(addr).expect("LIBTRADER_INIT_SERVER_FAILED");
-    let mut poll = mio::Poll::new().unwrap();
+    // Initialize arguments
+    let options: Options = argh::from_env();
 
-    poll.registry()
-        .register(&mut listener, mio::Token(0), mio::Interest::READABLE)
-        .unwrap();
+    let addr = options.addr.to_socket_addrs()?.next().
+        ok_or_else(|| std::io::Error::from(std::io::ErrorKind::AddrNotAvailable))?;
+
+    let config = gen_tls_server_config(&options.cert, &options.key)?;
+    let acceptor = TlsAcceptor::from(config);
+
+    let listener = TcpListener::bind(&addr).await?;
 
-    let mut tls_server = TlsServer::new(listener, config);
-    let mut events = mio::Events::with_capacity(256);
     loop {
-        poll.poll(&mut events, None).unwrap();
+        let (stream, peer_addr) = listener.accept().await?;
+        let acceptor = acceptor.clone();
 
-        for event in &events {
-            match event.token() {
-                mio::Token(0) => {
-                    tls_server
-                        .accept(poll.registry())
-                        .expect("error accepting socket");
-                }
-                _ => tls_server.conn_event(poll.registry(), &event),
+        let fut = async move {
+            let mut _stream = acceptor.accept(stream).await?;
+
+            // handle_data here?
+
+            Ok(()) as std::io::Result<()>
+        };
+
+        tokio::spawn(async move {
+            if let Err(err) = fut.await {
+                eprintln!("{:?}", err);
             }
-        }
+        });
     }
 }