async io with tokio

.travis.yml

@@ -16,7 +16,6 @@ addons:
 rust:
   - nightly
   - beta
-  - stable
 
 # load travis-cargo
 before_script:
@@ -32,8 +31,6 @@ script:
 after_success:
 # measure code coverage and upload to coveralls.io
   - cargo coveralls
-# upload documentation to github.io (gh-pages branch)
-  - cargo doc-upload
 
 env:
   global:

Cargo.toml

@@ -13,15 +13,15 @@ edition = "2018"
 [dependencies]
 bincode = "1.1.2"
 serde = { version= "1.0.88", features= [ "derive" ] }
-mio = "0.5"
 url = "1.7.2"
-num = "0.2.0"
 num-derive = "0.2.4"
 num-traits = "0.2.6"
-rand = "0.3"
 log = "0.4.6"
-threadpool = "1.7.1"
 regex = "1.1.0"
+tokio = "0.2.0-alpha.2"
+tokio-net = "0.2.0-alpha.2"
+futures-preview = { version = "=0.3.0-alpha.18", features = ["nightly", "async-await"] }
+bytes = "0.4.12"
 
 [dev-dependencies]
 quickcheck = "0.8.2"

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2016 Yang Zhang
+Copyright (c) 2014-2019 Yang Zhang
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -14,7 +14,7 @@ Features:
 - CoAP Observe option [RFC 7641](https://tools.ietf.org/rfc/rfc7641.txt)
 - *Too Many Requests* Response Code [RFC 8516](https://tools.ietf.org/html/rfc8516)
 
-[Documentation](http://covertness.github.io/coap-rs/master/coap/index.html)
+[Documentation](https://docs.rs/coap/0.7.5/coap/)
 
 ## Installation
 
@@ -37,31 +37,33 @@ extern crate coap;
 ```rust
 extern crate coap;
 
-use std::io;
-use coap::{CoAPServer, CoAPResponse, CoAPRequest, Method};
-
-fn request_handler(request: CoAPRequest) -> Option<CoAPResponse> {
-    match request.get_method() {
-		&Method::Get => println!("request by get {}", request.get_path()),
-		&Method::Post => println!("request by post {}", String::from_utf8(request.message.payload).unwrap()),
-		_ => println!("request by other method"),
-	};
-
-    // Return the auto-generated response
-    request.response
-}
+use coap::{Server, IsMessage, Method};
+use tokio::runtime::current_thread::Runtime;
 
 fn main() {
     let addr = "127.0.0.1:5683";
-
-    let mut server = CoAPServer::new(addr).unwrap();
-    server.handle(request_handler).unwrap();
-
-    println!("Server up on {}", addr);
-    println!("Press any key to stop...");
-    io::stdin().read_line(&mut String::new()).unwrap();
-
-    println!("Server shutdown");
+	let mut server = Server::new(addr).unwrap();
+
+	println!("Server up on {}", addr);
+
+	Runtime::new().unwrap().block_on(async move {
+		server.run(move |request| {
+            match request.get_method() {
+				&Method::Get => println!("request by get {}", request.get_path()),
+				&Method::Post => println!("request by post {}", String::from_utf8(request.message.payload).unwrap()),
+				&Method::Put => println!("request by put {}", String::from_utf8(request.message.payload).unwrap()),
+				_ => println!("request by other method"),
+			};
+
+			return match request.response {
+				Some(mut message) => {
+					message.set_payload(b"OK".to_vec());
+					Some(message)
+				},
+				_ => None
+			};
+    	}).await.unwrap();
+	});
 }
 ```
 

benches/server.rs

@@ -0,0 +1,45 @@
+#![feature(test)]
+
+extern crate test;
+
+use std::thread;
+use coap::{Server, CoAPClient, CoAPRequest, IsMessage, MessageType, CoAPOption};
+use tokio::runtime::current_thread::Runtime;
+
+#[bench]
+fn bench_server_with_request(b: &mut test::Bencher) {
+    let mut server = Server::new("127.0.0.1:0").unwrap();
+    let server_port = server.socket_addr().unwrap().port();
+
+    thread::spawn(move || {
+		Runtime::new().unwrap().block_on(async move {
+			server.run(move |request| {
+                let uri_path = request.get_path().to_string();
+
+                return match request.response {
+                    Some(mut response) => {
+                        response.set_payload(uri_path.as_bytes().to_vec());
+                        Some(response)
+                    }
+                    _ => None,
+                };
+            }).await.unwrap();
+		});
+	});
+
+    let client = CoAPClient::new(format!("127.0.0.1:{}", server_port)).unwrap();
+
+    let mut request = CoAPRequest::new();
+	request.set_version(1);
+	request.set_type(MessageType::Confirmable);
+	request.set_code("0.01");
+	request.set_message_id(1);
+	request.set_token(vec!(0x51, 0x55, 0x77, 0xE8));
+	request.add_option(CoAPOption::UriPath, "test".to_string().into_bytes());
+
+	b.iter(|| {
+		client.send(&request).unwrap();
+		let recv_packet = client.receive().unwrap();
+        assert_eq!(recv_packet.message.payload, b"test".to_vec());
+	});
+}

examples/client_and_server.rs

@@ -1,23 +1,28 @@
 extern crate coap;
 
-use coap::{CoAPServer, CoAPClient, CoAPRequest, CoAPResponse};
+use std::thread;
+use coap::{Server, CoAPClient};
 use coap::IsMessage;
+use tokio::runtime::current_thread::Runtime;
 
-fn request_handler(request: CoAPRequest) -> Option<CoAPResponse> {
-    let uri_path = request.get_path().to_string();
+fn main() {
+    let mut server = Server::new("127.0.0.1:5683").unwrap();
 
-    return match request.response {
-        Some(mut response) => {
-            response.set_payload(uri_path.as_bytes().to_vec());
-            Some(response)
-        }
-        _ => None,
-    };
-}
+    thread::spawn(move || {
+		Runtime::new().unwrap().block_on(async move {
+			server.run(move |request| {
+                let uri_path = request.get_path().to_string();
 
-fn main() {
-    let mut server = CoAPServer::new("127.0.0.1:5683").unwrap();
-    server.handle(request_handler).unwrap();
+                return match request.response {
+                    Some(mut response) => {
+                        response.set_payload(uri_path.as_bytes().to_vec());
+                        Some(response)
+                    }
+                    _ => None,
+                };
+            }).await.unwrap();
+		});
+	});
 
     let url = "coap://127.0.0.1:5683/Rust";
     println!("Client request: {}", url);

examples/server.rs

@@ -1,35 +1,30 @@
 extern crate coap;
 
-use std::io;
-use coap::{CoAPServer, CoAPResponse, CoAPRequest, IsMessage, Method};
-
-fn request_handler(request: CoAPRequest) -> Option<CoAPResponse> {
-	match request.get_method() {
-		&Method::Get => println!("request by get {}", request.get_path()),
-		&Method::Post => println!("request by post {}", String::from_utf8(request.message.payload).unwrap()),
-		&Method::Put => println!("request by put {}", String::from_utf8(request.message.payload).unwrap()),
-		_ => println!("request by other method"),
-	};
-
-	return match request.response {
-		Some(mut message) => {
-			message.set_payload(b"OK".to_vec());
-			Some(message)
-		},
-		_ => None
-	};
-}
+use coap::{Server, IsMessage, Method};
+use tokio::runtime::current_thread::Runtime;
 
 fn main() {
     let addr = "127.0.0.1:5683";
-
-    let mut server = CoAPServer::new(addr).unwrap();
-    server.handle(request_handler).unwrap();
-
-    println!("Server up on {}", addr);
-    println!("Press any key to stop...");
-
-    io::stdin().read_line(&mut String::new()).unwrap();
-
-    println!("Server shutdown");
+	let mut server = Server::new(addr).unwrap();
+
+	println!("Server up on {}", addr);
+
+	Runtime::new().unwrap().block_on(async move {
+		server.run(move |request| {
+            match request.get_method() {
+				&Method::Get => println!("request by get {}", request.get_path()),
+				&Method::Post => println!("request by post {}", String::from_utf8(request.message.payload).unwrap()),
+				&Method::Put => println!("request by put {}", String::from_utf8(request.message.payload).unwrap()),
+				_ => println!("request by other method"),
+			};
+
+			return match request.response {
+				Some(mut message) => {
+					message.set_payload(b"OK".to_vec());
+					Some(message)
+				},
+				_ => None
+			};
+    	}).await.unwrap();
+	});
 }