mirror of
https://github.com/actix/actix-web.git
synced 2024-11-18 15:41:17 +00:00
Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.
examples | ||
src | ||
tests | ||
.appveyor.yml | ||
.gitignore | ||
.travis.yml | ||
build.rs | ||
Cargo.toml | ||
CHANGES.md | ||
LICENSE | ||
Makefile | ||
README.md |
Actix web
Asynchronous web framework for Actix.
- API Documentation (Development)
- API Documentation (Releases)
- Cargo package: actix-web
- Minimum supported Rust version: 1.20 or later
Actix web is licensed under the Apache-2.0 license.
Features
- Supported HTTP/1 and HTTP/2 protocols
- Streaming and pipelining
- Keep-alive and slow requests handling
- WebSockets
- Transparent content compression/decompression (br, gzip, deflate)
- Configurable request routing
- Multipart streams
- Middlewares
Usage
To use actix-web
, add this to your Cargo.toml
:
[dependencies]
actix-web = "0.2"
HTTP/2
Actix web automatically upgrades connection to http/2
if possible.
Negotiation
HTTP/2
protocol over tls without prior knowlage requires
tls alpn. At the moment only
rust-openssl
supports alpn.
[dependencies]
actix-web = { git = "https://github.com/actix/actix-web", features=["alpn"] }
Upgrade to http/2
schema described in
rfc section 3.2 is not supported.
Starting http/2
with prior knowledge is supported for both clear text connection
and tls connection. rfc section 3.4
Example
extern crate actix;
extern crate actix_web;
extern crate env_logger;
use actix::*;
use actix_web::*;
struct MyWebSocket;
/// Actor with http context
impl Actor for MyWebSocket {
type Context = HttpContext<Self>;
}
/// Http route handler
impl Route for MyWebSocket {
type State = ();
fn request(req: &mut HttpRequest,
payload: Payload, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
{
// websocket handshake
let resp = ws::handshake(req)?;
// send HttpResponse back to peer
ctx.start(resp);
// convert bytes stream to a stream of `ws::Message` and handle stream
ctx.add_stream(ws::WsStream::new(payload));
Reply::async(MyWebSocket)
}
}
/// Standard actix's stream handler for a stream of `ws::Message`
impl StreamHandler<ws::Message> for MyWebSocket {
fn started(&mut self, ctx: &mut Self::Context) {
println!("WebSocket session openned");
}
fn finished(&mut self, ctx: &mut Self::Context) {
println!("WebSocket session closed");
}
}
impl Handler<ws::Message> for MyWebSocket {
fn handle(&mut self, msg: ws::Message, ctx: &mut HttpContext<Self>)
-> Response<Self, ws::Message>
{
// process websocket messages
println!("WS: {:?}", msg);
match msg {
ws::Message::Ping(msg) => ws::WsWriter::pong(ctx, &msg),
ws::Message::Text(text) => ws::WsWriter::text(ctx, &text),
ws::Message::Binary(bin) => ws::WsWriter::binary(ctx, bin),
ws::Message::Closed | ws::Message::Error => {
ctx.stop();
}
_ => (),
}
Self::empty()
}
}
fn main() {
::std::env::set_var("RUST_LOG", "actix_web=info");
let _ = env_logger::init();
let sys = actix::System::new("ws-example");
HttpServer::new(
Application::default("/")
// enable logger
.middleware(middlewares::Logger::default())
// websocket route
.resource("/ws/", |r| r.get::<MyWebSocket>())
.route_handler("/", StaticFiles::new("examples/static/", true)))
.serve::<_, ()>("127.0.0.1:8080").unwrap();
Arbiter::system().send(msgs::SystemExit(0));
let _ = sys.run();
}