fd294049c7
This commit completely rewrites Rocket's HTTP serving. In addition to
significant internal cleanup, this commit introduces the following major
features:
* Support for custom, external listeners in the `listener` module.
The new `listener` module contains new `Bindable`, `Listener`, and
`Connection` traits which enable composable, external
implementations of connection listeners. Rocket can launch on any
`Listener`, or anything that can be used to create a listener
(`Bindable`), via a new `launch_on()` method.
* Support for Unix domain socket listeners out of the box.
The default listener backwards compatibly supports listening on Unix
domain sockets. To do so, configure an `address` of
`unix:path/to/socket` and optional set `reuse` to `true` (the
default) or `false` which controls whether Rocket will handle
creating and deleting the unix domain socket.
In addition to these new features, this commit makes the following major
improvements:
* Rocket now depends on hyper 1.
* Rocket no longer depends on hyper to handle connections. This allows
us to handle more connection failure conditions which results in an
overall more robust server with fewer dependencies.
* Logic to work around hyper's inability to reference incoming request
data in the response results in a 15% performance improvement.
* `Client`s can be marked secure with `Client::{un}tracked_secure()`,
allowing Rocket to treat local connections as running under TLS.
* The `macros` feature of `tokio` is no longer used by Rocket itself.
Dependencies can take advantage of this reduction in compile-time
cost by disabling the new default feature `tokio-macros`.
* A new `TlsConfig::validate()` method allows checking a TLS config.
* New `TlsConfig::{certs,key}_reader()`,
`MtlsConfig::ca_certs_reader()` methods return `BufReader`s, which
allow reading the configured certs and key directly.
* A new `NamedFile::open_with()` constructor allows specifying
`OpenOptions`.
These improvements resulted in the following breaking changes:
* The MSRV is now 1.74.
* `hyper` is no longer exported from `rocket::http`.
* `IoHandler::io` takes `Box<Self>` instead of `Pin<Box<Self>>`.
- Use `Box::into_pin(self)` to recover the previous type.
* `Response::upgrade()` now returns an `&mut dyn IoHandler`, not
`Pin<& mut _>`.
* `Config::{address,port,tls,mtls}` methods have been removed.
- Use methods on `Rocket::endpoint()` instead.
* `TlsConfig` was moved to `tls::TlsConfig`.
* `MutualTls` was renamed and moved to `mtls::MtlsConfig`.
* `ErrorKind::TlsBind` was removed.
* The second field of `ErrorKind::Shutdown` was removed.
* `{Local}Request::{set_}remote()` methods take/return an `Endpoint`.
* `Client::new()` was removed; it was previously deprecated.
Internally, the following major changes were made:
* A new `async_bound` attribute macro was introduced to allow setting
bounds on futures returned by `async fn`s in traits while
maintaining good docs.
* All utility functionality was moved to a new `util` module.
Resolves #2671.
Resolves #1070.
|
||
|---|---|---|
| .github | ||
| benchmarks | ||
| contrib | ||
| core | ||
| examples | ||
| scripts | ||
| site | ||
| .gitattributes | ||
| .gitignore | ||
| .rustfmt.toml | ||
| CHANGELOG.md | ||
| Cargo.toml | ||
| LICENSE-APACHE | ||
| LICENSE-MIT | ||
| README.md | ||
README.md
Rocket
Rocket is an async web framework for Rust with a focus on usability, security, extensibility, and speed.
#[macro_use] extern crate rocket;
#[get("/<name>/<age>")]
fn hello(name: &str, age: u8) -> String {
format!("Hello, {} year old named {}!", age, name)
}
#[launch]
fn rocket() -> _ {
rocket::build().mount("/hello", routes![hello])
}
Visiting localhost:8000/hello/John/58, for example, will trigger the hello
route resulting in the string Hello, 58 year old named John! being sent to the
browser. If an <age> string was passed in that can't be parsed as a u8, the
route won't get called, resulting in a 404 error.
Documentation
Rocket is extensively documented:
- Overview: A brief look at what makes Rocket special.
- Quickstart: How to get started as quickly as possible.
- Getting Started: How to start your first Rocket project.
- Guide: A detailed guide and reference to Rocket.
- API Documentation: The "rustdocs".
The official community support channels are #rocket:mozilla.org on Matrix
and the bridged #rocket IRC channel on Libera.Chat at irc.libera.chat. We
recommend joining us on Matrix via Element. If your prefer IRC, you can join
via the Kiwi IRC client or a client of your own.
Examples
An extensive number of examples are provided in the examples/ directory. Each
example can be compiled and run with Cargo. For instance, the following sequence
of commands builds and runs the Hello, world! example:
cd examples/hello
cargo run
You should see Hello, world! by visiting http://localhost:8000.
Building and Testing
The core directory contains the three core libraries: lib, codegen, and
http published as rocket, rocket_codegen and rocket_http, respectively.
The latter two are implementations details and are reexported from rocket.
Testing
Rocket's complete test suite can be run with ./scripts/test.sh from the root
of the source tree. The script builds and tests all libraries and examples in
all configurations. It accepts the following flags:
--examples: tests all examples inexamples/--contrib: tests eachcontriblibrary and feature individually--core: tests eachcore/libfeature individually--benchmarks: runs all benchmarks--all: runs all tests in all configurations
Additionally, a +${toolchain} flag, where ${toolchain} is a valid rustup
toolchain string, can be passed as the first parameter. The flag is forwarded to
cargo commands. Any other extra parameters are passed directly to cargo.
To test crates individually, simply run cargo test --all-features in the
crate's directory.
Codegen Testing
Code generation diagnostics are tested using trybuild; tests can be found in
the codegen/tests/ui-fail directories of respective codegen crates. Each
test is symlinked into sibling ui-fail-stable and ui-fail-nightly
directories which contain the expected error output for stable and nightly
compilers, respectively. To update codegen test UI output, run a codegen test
suite with TRYBUILD=overwrite and inspect the diff of .std* files.
API Docs
API documentation is built with ./scripts/mk-docs.sh. The resulting assets are
uploaded to api.rocket.rs.
Documentation for a released version ${x} can be found at
https://api.rocket.rs/v${x} and https://rocket.rs/v${x}. For instance, the
documentation for 0.4 can be found at https://api.rocket.rs/v0.4 and
https://rocket.rs/v0.4. Documentation for unreleased versions in branch
${branch} be found at https://api.rocket.rs/${branch} and
https://rocket.rs/${branch}. For instance, the documentation for the master
branch can be found at https://api.rocket.rs/master and
https://rocket.rs/master. Documentation for unreleased branches is updated
periodically.
Contributing
Contributions are absolutely, positively welcome and encouraged! Contributions come in many forms. You could:
- Submit a feature request or bug report as an issue.
- Ask for improved documentation as an issue.
- Comment on issues that require feedback.
- Contribute code via pull requests.
We aim to keep Rocket's code quality at the highest level. This means that any code you contribute must be:
- Commented: Complex and non-obvious functionality must be properly commented.
- Documented: Public items must have doc comments with examples, if applicable.
- Styled: Your code's style should match the existing and surrounding code style.
- Simple: Your code should accomplish its task as simply and idiomatically as possible.
- Tested: You must write (and pass) convincing tests for any new functionality.
- Focused: Your code should do what it's supposed to and nothing more.
All pull requests are code reviewed and tested by the CI. Note that unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Rocket by you shall be dual licensed under the MIT License and Apache License, Version 2.0, without any additional terms or conditions.
License
Rocket is licensed under either of the following, at your option:
- Apache License, Version 2.0, (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
- MIT License (LICENSE-MIT or https://opensource.org/licenses/MIT)
The Rocket website source is licensed under separate terms.