Migrate actix-net to std::future (#64)

* Migrate actix-codec, actix-rt, and actix-threadpool to std::future

* update to latest tokio alpha and futures-rs

* Migrate actix-service to std::future,

This is a squash of ~8 commits, since it included a lot of experimentation. To see the commits,
look into the semtexzv/std-future-service-tmp branch.

* update futures-rs and tokio

* Migrate actix-threadpool to std::future (#59)

* Migrate actix-threadpool to std::future

* Cosmetic refactor

- turn log::error! into log::warn! as it doesn't throw any error
- add Clone and Copy impls for Cancelled making it cheap to operate with
- apply rustfmt

* Bump up crate version to 0.2.0 and pre-fill its changelog

* Disable patching 'actix-threadpool' crate in global workspace as unnecessary

* Revert patching and fix 'actix-rt'

* Migrate actix-rt to std::future (#47)

* remove Pin from Service::poll_ready(); simplify combinators api; make code compile

* disable tests

* update travis config

* refactor naming

* drop IntoFuture trait

* Migrate actix-server to std::future (#50)

Still not finished, this is more WIP, this is an aggregation of several commits, which
can be found in semtexzv/std-future-server-tmp branch

* update actix-server

* rename Factor to ServiceFactory

* start server worker in start mehtod

* update actix-utils

* remove IntoTransform trait

* Migrate actix-server::ssl::nativetls to std futures (#61)

* Refactor 'nativetls' module

* Migrate 'actix-server-config' to std futures

- remove "uds" feature
- disable features by default

* Switch NativeTlsAcceptor to use 'tokio-tls' crate

* Bikeshed features names and remove unnecessary dependencies for 'actix-server-config' crate

* update openssl impl

* migrate actix-connect to std::future

* migrate actix-ioframe to std::future

* update version to alpha.1

* fix boxed service

* migrate server rustls support

* migratte openssl and rustls connecttors

* store the thread's handle with arbiter (#62)

* update ssl connect tests

* restore service tests

* update readme

actix-ioframe/tests/test_server.rs

@@ -4,11 +4,11 @@ use std::time::Duration;
 
 use actix_codec::BytesCodec;
 use actix_server_config::Io;
-use actix_service::{new_apply_fn, Service};
+use actix_service::{apply_fn_factory, service_fn, Service};
 use actix_testing::{self as test, TestServer};
-use futures::Future;
-use tokio_tcp::TcpStream;
-use tokio_timer::sleep;
+use futures::future::ok;
+use tokio_net::tcp::TcpStream;
+use tokio_timer::delay_for;
 
 use actix_ioframe::{Builder, Connect};
 
@@ -22,13 +22,15 @@ fn test_disconnect() -> std::io::Result<()> {
     let srv = TestServer::with(move || {
         let disconnect1 = disconnect1.clone();
 
-        new_apply_fn(
+        apply_fn_factory(
             Builder::new()
-                .factory(|conn: Connect<_>| Ok(conn.codec(BytesCodec).state(State)))
+                .factory(service_fn(|conn: Connect<_>| {
+                    ok(conn.codec(BytesCodec).state(State))
+                }))
                 .disconnect(move |_, _| {
                     disconnect1.store(true, Ordering::Relaxed);
                 })
-                .finish(|_t| Ok(None)),
+                .finish(service_fn(|_t| ok(None))),
             |io: Io<TcpStream>, srv| srv.call(io.into_parts().0),
         )
     });
@@ -37,9 +39,9 @@ fn test_disconnect() -> std::io::Result<()> {
         .service(|conn: Connect<_>| {
             let conn = conn.codec(BytesCodec).state(State);
             conn.sink().close();
-            Ok(conn)
+            ok(conn)
         })
-        .finish(|_t| Ok(None));
+        .finish(service_fn(|_t| ok(None)));
 
     let conn = test::block_on(
         actix_connect::default_connector()
@@ -48,11 +50,7 @@ fn test_disconnect() -> std::io::Result<()> {
     .unwrap();
 
     test::block_on(client.call(conn.into_parts().0)).unwrap();
-    let _ = test::block_on(
-        sleep(Duration::from_millis(100))
-            .map(|_| ())
-            .map_err(|_| ()),
-    );
+    let _ = test::block_on(delay_for(Duration::from_millis(100)));
     assert!(disconnect.load(Ordering::Relaxed));
 
     Ok(())