Rust should be well-equipped for writing robust, high-scale servers

[aturon]

Overview

The biggest area we've seen with interest in production Rust so far is the server, particularly in cases where high-scale performance, control, and/or reliability are paramount. At the moment, our ecosystem in this space is nascent, and production users are having to build a lot from scratch.

Of the specific domains we might target for having a more complete story, Rust on the server is the place with the clearest direction and momentum. In a year's time, it's within reach to drastically improve Rust's server ecosystem and the overall experience of writing server code. The relevant pieces here include foundations for async IO, language improvements for async code ergonomics, shared infrastructure for writing services (including abstractions for implementing protocols and middleware), and endless interfaces to existing services/protocols.

There are two reasons to focus on the robust, high-scale case. Most importantly, it's the place where Rust has the clearest value proposition relative to other languages, and hence the place where we're likeliest to achieve significant, quality production usage (as discussed earlier in the RFC). More generally, the overall server space is huge, so choosing a particular niche provides essential focus for our efforts.

Current status

As of 2017-06-06

Mid-way through the year we've got some excellent projects underway (linked below) and are starting to wind down a discussion on what blocks you today from using Rust on the server with the most requested items being documentation for futures/Tokio, async/await syntax, a "solid" HTTP library (e.g. stable, 1.0 quality, async, HTTP/2 support, etc), and database drivers (particularly async ones). This thread will likely help guide work for the next few months and possibly through to the end of the year.

Projects

• Tokio, an asynchronous networking stack.

• Stackless coroutines and generators, either of which might support async/await syntax.

• Generators implementation (not landed as of 2017-06-06)

• async/await syntax (depends on implementation above)

• Rocket

• Hyper

Tokio projects:

• General
  • tokio-timer - timer/timeout related methods
  • tokio-uds - Unix Domain Sockets
  • tokio-inotify
  • tokio-signal - Unix signal handling
  • tokio-process - process spawning
  • trust-dns - DNS resolution
  • capnproto-rust
• HTTP
  • tokio-curl
  • Hyper
• TLS / SSL libraries
  • tokio-tls - built on native-tls
  • tokio-openssl
  • tokio-rustls
• Database drivers
  • tokio-postgres
  • couchbase

Discussion

• What does Rust needs today for server workloads?
  • users.rust-lang.org
  • reddit
  • abridged summary
• coroutines post-rfc (async/await)

[alexcrichton]

I've updated the issue with links and some summaries from our recent users thread as well as some updates along some projects that have happened.

[sorenbs]

@alexcrichton Any chance you could add a new status update?