Need help with Rocket?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

SergioBenitez
12.0K Stars 800 Forks Other 1.6K Commits 110 Opened issues

Description

A web framework for Rust.

Services available

!
?

Need anything else?

Contributors list

Rocket

Build Status Rocket Homepage Current Crates.io Version Matrix: #rocket:mozilla.org IRC: #rocket on chat.freenode.net

Rocket is an async web framework for Rust with a focus on usability, security, extensibility, and speed.

#[macro_use] extern crate rocket;

#[get("//")] fn hello(name: String, age: u8) -> String { format!("Hello, {} year old named {}!", age, name) }

#[launch] fn rocket() -> rocket::Rocket { rocket::ignite().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
 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:

The official community support channels are

#rocket:mozilla.org
on Matrix and the bridged
#rocket
IRC channel on Freenode at

chat.freenode.net
. 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_world
cargo run

You should see

Hello, world!
by visiting
http://localhost:8000
.

Building and Testing

Core and Contrib

The

core
directory contains the three core libraries:
lib
,
codegen
, and
http
. The
contrib
directory contains officially supported community contributions and similarly consists of
lib
and
codegen
.

Public APIs are exposed via

lib
packages:
core/lib
is distributed as the
rocket
crate while
contrib/lib
is distributed as the
rocket_contrib
crate. The remaining crates are implementation details.

Library 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. It accepts the following flags:
  • --contrib
    : tests each
    contrib
    feature individually
  • --core
    : tests each
    core
    feature individually
  • --release
    : runs the testing suite in
    release
    mode

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.

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
directory of both
core
and
contrib
. 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.

Documentation

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:

  1. Submit a feature request or bug report as an issue.
  2. Ask for improved documentation as an issue.
  3. Comment on issues that require feedback.
  4. 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 http://www.apache.org/licenses/LICENSE-2.0)
  • MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)

The Rocket website source is licensed under separate terms.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.