Rust is a system programming language focused on safety, speed, and concurrency. It's standard library provides API for dealing with I/O, but for now in a synchronous way. In this talk we'll dive into the ecosystem of asynchronous libraries published so far on crates.io and how to use them in order to build robust, scalable, and production ready network clients and servers.

1. Asynchronous I/O in Rust
Enrico Risa - OrientDB
ROME 24-25 MARCH 2017

2. About You
• Any async I/O ?
• … with Rust?
• … maybe Node.js

3. About Me
• Java/Javascript developer at OrientDB
@wolf4ood
• Nightly Rust developer

4. This Talk
• Async I/O for network
• Current status in standard library
• Crates available for doing async I/O

5. The std::{io,net} way
use std::io::prelude::*;
use std::net::TcpStream;
fn main() {
let mut stream = TcpStream::connect(“127.0.0.1:2424").unwrap();
let _ = stream.read_exact(&mut [0; 128]);
}

6. Simple Server
use std::io::Write;
use std::net::TcpListener;
use std::thread;
fn main() {
let listener = TcpListener::bind(“127.0.0.1:9123").unwrap();
println!("listening started, ready to accept”);
for stream in listener.incoming() {
thread::spawn(|| {
let mut stream = stream.unwrap();
stream.write(b"Hello Worldrn").unwrap();
});
}
}

7. Simple Web Server
(Hyper 0.10.x)
extern crate hyper;
use hyper::server::{Server, Request, Response};
fn main() {
let server = Server::http(“127.0.0.1:8080").unwrap();
let _guard = server.handle(|mut req: Request, mut res: Response| {
res.send(b"Hello Rust");
});
println!("Listening on http://127.0.0.1:8080");
}

8. Based on Hyper
• Iron
• Rocket
• Nickel
• Pencil

9. Sync Architecture
Process / Thread per connection

10. Async Architecture
Process / Thread handles multiple connections
Non Blocking “Event Driven”

11. Web Server Comparison
https://help.dreamhost.com/hc/en-us/articles/215945987-Web-server-performance-comparison

12. Advantages of async I/O
• Throughput
• Lower Memory usage
• Latency
• Scalability

13. Async I/O Model
• Readiness
• Completion

14. READINESS
read -> EWOULDBLOCK
poll for readiness
sockets ready
read -> data

15. COMPLETION
read -> OK
fired in background
do some stuff
Poll for completion notifications

16. Async I/O with Rust

17. MIO

18. Metal I/O (mio)
• I/O Abstraction over OS
• Zero Cost Abstraction
• Readiness Model
• Event Loop
• Handler with tokens
https://github.com/carllerche/mio

19. Metal I/O (mio)
• Very Low level
• Manually tracking I/O events
• Wire up a state machine
Solid foundation of async in Rust

20. Abstraction over the metal
for
handling async computation

21. Something like
• JS Promise
• Java CompletableFuture

22. Future
• Database Query
• HTTP Request
• CPU computation
• Timeout
• Read from a socket
• ….

23. FUTURES

24. Futures
• Composability
• Error handling / Timeout / Cancellation
• Ergonomics
• Readiness / No Callback
• Zero Cost
https://aturon.github.io/blog/2016/08/11/futures/

25. How it looks in Rust
pub trait Future {
type Item;
type Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error>;
}

26. How it looks in Rust
pub enum Async<T> {
Ready(T),
NotReady,
}
pub type Poll<T, E> = Result<Async<T>, E>;

27. Composition
f.and_then(|val| new_future(val))

28. Mapping
f.map(|val| some_new_value(val))

29. Joining
f.join(g)

30. Selecting
f.select(g)

31. Executors
• Current thread
• Thread Pool
• Event Loop

32. Combining Example
fn get_person(id : i32) -> Box<Future<Item=Person,Error=()>>
fn hello_person(person : Person) -> Box<Future<Item=String,Error=()>>
get_person(1)
.and_then(hello_person)
.map(|s|{
let result: Result<String, ()> =
Ok(format!("{} from Codemotion",s));
result
});

33. Combining Example
let pool = CpuPool::new_num_cpus();
let combined =
get_person(1).and_then(hello_person).map(|s|{
let result: Result<String, ()> =
Ok(format!("{} from Codemotion",s));
result
});
let future = pool.spawn(combined);
println!("{:?}",future.wait().unwrap());

34. Streams
pub trait Stream {
type Item;
type Error;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error>;
}

35. Stream Example
let (mut tx, rx) = mpsc::channel(10);
thread::spawn(move ||{
let mut sender = tx;
for i in 0..10 {
sender = sender.send(i).wait().unwrap();
}
});
rx.for_each(|val|{
println!("Got {:?}",val);
Ok(())
}).wait();

36. Zero Cost
• No Allocation in composition
• One dynamic dispatch
• No Synchronisation
https://aturon.github.io/blog/2016/09/07/futures-design

37. Benchmark
https://aturon.github.io/blog/2016/08/11/futures/

38. Is it enough?

39. Hello Tokio
Mio Futures
Tokio

40. What is?
Tokio is a platform for writing fast networking code in Rust.

41. Tokio (Core)
• Built on top of mio and futures
• Lower Level
• Tcp Handlers
• Timeout
• Event Loop
https://medium.com/@carllerche/announcing-tokio-df6bb4ddb34#.g9ugbqg71

42. Event Loop
loop {
let event = next_event();
dispatch(event);
}

43. Tokio Event Loop
• Core
• Handle
• Remote

44. Echo Server (Core)
let mut core = Core::new().unwrap();
let handle = core.handle();
let address = "127.0.0.1:8080".parse().unwrap();
let acceptor = TcpListener::bind(&address,&handle).unwrap();
let server = acceptor.incoming().for_each(|(socket,address)|{
let (reader, writer) = socket.split();
let future = copy(reader,writer).then(|result|{
println!("{:?}", result);
Ok(())
});
handle.spawn(future);
Ok(())
});
core.run(server).unwrap();

45. Codec
• Encoder
• Decoder
Describe how to encode and decode the frames via buffers

46. Codec Declaration
pub struct ExampleCodec;
impl Encoder for ExampleCodec {
type Item = String;
type Error = io::Error;
fn encode(&mut self, msg: String, buf: &mut BytesMut)
-> io::Result<()> {}
}
impl Decoder for ExampleCodec {
type Item = String;
type Error = io::Error;
fn decode(&mut self, buf: &mut BytesMut)
-> io::Result<Option<String>> {
}
}

47. Codec Usage
let ( writer , reader) =
socket.framed(CodemotionCodec).split();

48. Tokio Architecture
Mio Futures
Tokio Core
Tokio Proto
Tokio Service

49. Tokio Proto
• Transport:
encoding/deconding frames to the I/O source
• Protocol:
codec + protocol specification

50. Tokio Service
• Higher level
• Handle Request/Response in async way

51. Proto Impl
struct ExampleProto;
impl<T: Io + 'static> ServerProto<T> for ExampleProto {
type Request = String;
type Response = String;
type Transport = Framed<T, ExampleCodec>;
type BindTransport = Result<Self::Transport, io::Error>;
fn bind_transport(&self, io: T) -> Self::BindTransport {
Ok(io.framed(ExampleCodec))
}
}

52. Service Impl
pub struct ExampleService;
impl Service for ExampleService {
type Request = String;
type Response = String;
type Error = io::Error;
type Future = BoxFuture<String, io::Error>;
fn call(&self, req: String) -> Self::Future {
let res = format!("{} from Codemotion",req)
future::finished(res).boxed()
}
}

53. Hyper + Tokio = ♥

54. Hyper Service
#[derive(Clone, Copy)]
struct Hello;
impl Service for Hello {
type Request = Request;
type Response = Response;
type Error = hyper::Error;
type Future = FutureResult<Response, hyper::Error>;
fn call(&self, _req: Request) -> Self::Future {
let response = "Hello Rust!";
futures::future::ok(
Response::new()
.with_header(ContentLength(response.len() as u64))
.with_header(ContentType::plaintext())
.with_body(response)
)
}
}

55. Hyper Server
fn main() {
let addr = “127.0.0.1:8080".parse().unwrap();
let server = Http::new().bind(&addr,|| Ok(Hello)).unwrap();
println!("Listening on port 8080”);
server.run().unwrap();
}

56. Tokio Based Projects
• Tokio Postgres
• Tokio Redis
• Tokio Memcache
• Hyper
• Tokio Curl
• Telebot
• Tokio IRC
• ….more

57. Rust Rome
https://www.meetup.com/it-IT/Rust-Roma

58. Thank You
• Question ?
• https://github.com/carllerche/mio
• https://github.com/alexcrichton/futures-rs
• https://tokio.rs