update futures dependency to 0.3

async-coap-tokio/Cargo.toml

@@ -13,9 +13,9 @@ readme = "README.md"
 
 [dependencies]
 async-coap = { path = "../async-coap", version = "0.1" }
-tokio-net = "0.2.0-alpha.4"
+tokio = {version = "0.2", features = ["net"]}
 mio = "0.6"
-futures-preview = { version = "=0.3.0-alpha.18", features = ["async-await", "nightly"] }
+futures = "0.3"
 
 [dev-dependencies]
-tokio = "0.2.0-alpha.4"
+tokio = {version = "0.2", features = ["rt-core", "macros"]}

async-coap-tokio/src/lib.rs

@@ -24,7 +24,7 @@
 //! use async_coap_tokio::TokioAsyncUdpSocket;
 //! use futures::prelude::*;
 //! use std::sync::Arc;
-//! use tokio::executor::spawn;
+//! use tokio::spawn;
 //!
 //! #[tokio::main]
 //! async fn main() {

async-coap-tokio/src/tokio_async_udp_socket.rs

@@ -17,12 +17,12 @@ use async_coap::datagram::{
     AsyncDatagramSocket, AsyncRecvFrom, AsyncSendTo, DatagramSocketTypes, MulticastSocket,
 };
 use futures::task::Context;
-use futures::{ready, Poll};
+use futures::{ready, task::Poll};
 use mio::net::UdpSocket;
 use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
 use std::ops::Deref;
 use std::pin::Pin;
-use tokio_net::util::PollEvented;
+use tokio::io::PollEvented;
 
 /// An asynchronous [`AsyncDatagramSocket`] wrapper around [`std::net::UdpSocket`] that
 /// uses [Tokio][] for the event loop.
@@ -65,7 +65,7 @@ impl TokioAsyncUdpSocket {
 
     /// Wraps a [`mio::net::UdpSocket`] instance with a [`TokioAsyncUdpSocket`].
     pub(crate) fn from_mio(udp_socket: UdpSocket) -> TokioAsyncUdpSocket {
-        TokioAsyncUdpSocket(PollEvented::new(udp_socket))
+        TokioAsyncUdpSocket(PollEvented::new(udp_socket).expect("Async UDP socket"))
     }
 }
 

async-coap-tokio/tests/test.rs

@@ -1,11 +1,9 @@
-#![feature(async_await)]
-
 use async_coap::datagram::DatagramLocalEndpoint;
 use async_coap::prelude::*;
 use async_coap_tokio::TokioAsyncUdpSocket;
 use futures::prelude::*;
 use std::sync::Arc;
-use tokio::executor::spawn;
+use tokio::spawn;
 
 #[tokio::test]
 async fn test_tokio() {

async-coap/Cargo.toml

@@ -26,6 +26,6 @@ rand = "0.6"
 num = "0.2"
 regex = "1.1"
 pin-utils = "0.1.0-alpha.4"
-futures-preview = { version = "=0.3.0-alpha.18", features = ["async-await", "nightly"] }
-futures-timer = "0.3"
+futures = {version = "0.3", features=["default", "thread-pool"]}
+futures-timer = "2.0"
 async-coap-uri = { path = "../async-coap-uri", version = "0.1.0" }

async-coap/src/datagram/allow_udp_socket.rs

@@ -14,14 +14,13 @@
 //
 
 use super::*;
-use futures::task::Context;
-use futures::Poll;
+use futures::task::{Context, Poll};
 use futures_timer::Delay;
 use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6, UdpSocket};
 use std::ops::Deref;
 use std::pin::Pin;
 use std::sync::Mutex;
-use std::time::Duration;
+use std::time::{Instant, Duration};
 
 /// A naive wrapper around [`std::net::UdpSocket`] that implements [`AsyncDatagramSocket`].
 ///
@@ -91,12 +90,13 @@ impl AllowStdUdpSocket {
         if let Some(d) = self.2 {
             let mut lock = self.1.lock().expect("Lock failed");
             let opt_mut: &mut Option<Delay> = &mut lock;
+
             if opt_mut.is_none() {
                 *opt_mut = Some(Delay::new(d));
                 delay = opt_mut.as_mut().unwrap();
             } else {
                 delay = opt_mut.as_mut().unwrap();
-                delay.reset(d);
+                delay.reset(Instant::now() + d);
             }
 
             let _ = Pin::new(delay).poll(cx);

async-coap/src/datagram/async_socket.rs

@@ -15,8 +15,7 @@
 
 use super::*;
 use futures::prelude::*;
-use futures::task::Context;
-use futures::Poll;
+use futures::task::{Context, Poll};
 use std::pin::Pin;
 
 /// A trait for asynchronous datagram sockets.

async-coap/src/datagram/local_endpoint.rs

@@ -338,12 +338,12 @@ impl<US: AsyncDatagramSocket> LocalEndpoint for DatagramLocalEndpoint<US> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::message::MessageDisplay;
+    use crate::message::{MessageDisplay, MessageRead};
     use crate::ContentFormat;
     use futures::executor::block_on;
     use futures::future::select;
     use futures::future::Either;
-    use futures_timer::TryFutureExt;
+    use futures_timer::Delay;
     use std::time::Duration;
 
     fn test_process_request<LE, F, R>(local_endpoint: &LE, future: F) -> R
@@ -517,8 +517,16 @@ mod tests {
             });
 
         let future = remote_endpoint
-            .send(send_desc)
-            .timeout(Duration::from_secs(5));
+            .send(send_desc);
+
+        let future = select(future, Delay::new(Duration::new(5, 0)))
+            .map(|f| {
+                if let Either::Left(x) = f {
+                    x.0
+                }else{
+                    Err(Error::ResponseTimeout)
+                }
+            });
 
         let result = test_process_request(&local_endpoint, future);
         assert!(result.is_ok(), "{:?}", result);

async-coap/src/datagram/loopback_socket.rs

@@ -17,8 +17,7 @@ use super::*;
 use futures::channel::mpsc::{channel, Receiver, Sender};
 use futures::lock::Mutex;
 use futures::prelude::*;
-use futures::task::Context;
-use futures::Poll;
+use futures::task::{Context, Poll};
 use std::fmt::{Debug, Display, Formatter};
 use std::pin::Pin;
 

async-coap/src/datagram/null_socket.rs

@@ -14,8 +14,7 @@
 //
 
 use super::*;
-use futures::task::Context;
-use futures::Poll;
+use futures::task::{Context, Poll};
 use std::fmt::{Debug, Display, Formatter};
 use std::pin::Pin;
 

async-coap/src/datagram/send_future.rs

@@ -16,8 +16,7 @@
 use super::*;
 use crate::message::BufferMessageEncoder;
 use futures::prelude::*;
-use futures::task::Waker;
-use futures::Poll;
+use futures::task::{Waker, Poll};
 use futures_timer::Delay;
 use std::cell::Cell;
 use std::fmt::{Display, Formatter};
@@ -136,7 +135,7 @@ where
     fn update_timeout(&mut self, d: Option<Duration>) {
         if let Some(d) = d {
             if let Some(delay) = self.delay.as_mut() {
-                delay.reset(d);
+                delay.reset(Instant::now() + d);
             } else {
                 self.delay = Some(Delay::new(d));
             }
@@ -148,7 +147,7 @@ where
     fn poll_timeout(
         &mut self,
         cx: &mut futures::task::Context<'_>,
-    ) -> Poll<Result<(), std::io::Error>> {
+    ) -> Poll<()> {
         if let Some(delay) = self.delay.as_mut() {
             Pin::new(delay).poll(cx)
         } else {

async-coap/src/lib.rs

@@ -48,7 +48,6 @@
 //! This similarly straightforward to do with *async-coap*:
 //!
 //! ```
-//! # #![feature(async_await)]
 //! # use std::sync::Arc;
 //! # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 //! # use async_coap::prelude::*;
@@ -94,7 +93,6 @@
 //! convenient. The *async-coap* way to do it is similarly convenient:
 //!
 //! ```
-//! # #![feature(async_await)]
 //! # use std::sync::Arc;
 //! # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 //! # use async_coap::prelude::*;
@@ -138,7 +136,6 @@
 //! [`inspect`]: send_desc::SendDescExt::inspect
 //!
 //! ```
-//! # #![feature(async_await)]
 //! # use std::sync::Arc;
 //! # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 //! # use async_coap::prelude::*;
@@ -183,15 +180,14 @@
 //! This allows us to collect all of the responses:
 //!
 //! ```no_run
-//! # #![feature(async_await)]
 //! # use std::sync::Arc;
 //! # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 //! # use async_coap::prelude::*;
 //! # use async_coap::datagram::{DatagramLocalEndpoint, AllowStdUdpSocket, LoopbackSocket};
 //! # use async_coap::null::NullLocalEndpoint;
 //! # use async_coap::message::MessageDisplay;
 //! # use async_coap::Error;
-//! # use futures_timer::TryFutureExt;
+//! # use futures::future::TryFutureExt;
 //! # use std::time::Duration;
 //! # let socket = AllowStdUdpSocket::bind("[::]:0").expect("UDP bind failed");
 //! # let local_endpoint = Arc::new(DatagramLocalEndpoint::new(socket));
@@ -256,8 +252,6 @@
 //! ## Full Example
 //!
 //! ```
-//! # #![feature(async_await)]
-//! #
 //! use std::sync::Arc;
 //! use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 //! use async_coap::prelude::*;
@@ -317,7 +311,6 @@
 //!
 //! [send-desc]: send_desc/index.html
 
-#![feature(async_await)]
 #![cfg_attr(not(feature = "std"), no_std)]
 #![warn(rust_2018_idioms)]
 #![warn(missing_debug_implementations)]

async-coap/src/local_endpoint.rs

@@ -124,7 +124,6 @@ use std::sync::Arc;
 /// Or, more naturally, the returned futures can be used directly in `async` blocks:
 ///
 /// ```
-/// # #![feature(async_await)]
 /// # use std::sync::Arc;
 /// # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 /// # use async_coap::prelude::*;
@@ -536,7 +535,6 @@ pub trait LocalEndpointExt: LocalEndpoint {
     /// future in an (effectively transparent) [`ArcGuard`] wrapper.
     ///
     /// ```
-    /// # #![feature(async_await)]
     /// #
     /// # use std::sync::Arc;
     /// # use futures::prelude::*;

async-coap/src/remote_endpoint.rs

@@ -21,7 +21,6 @@ use crate::UriBuf;
 /// # Example
 ///
 /// ```
-/// # #![feature(async_await)]
 /// #
 /// # use std::sync::Arc;
 /// # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};

async-coap/src/send_desc/mod.rs

@@ -28,7 +28,6 @@
 //! Here we create a `SendDesc` instance that just sends a GET request and waits for a response:
 //!
 //! ```
-//! # #![feature(async_await)]
 //! # use std::sync::Arc;
 //! # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 //! # use async_coap::prelude::*;
@@ -60,7 +59,6 @@
 //! an owned copy of the message it received ([`OwnedImmutableMessage`](crate::message::OwnedImmutableMessage)):
 //!
 //! ```
-//! # #![feature(async_await)]
 //! # use std::sync::Arc;
 //! # use futures::{prelude::*,executor::LocalPool,task::LocalSpawnExt};
 //! # use async_coap::prelude::*;