mirrors/actix-web
1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-11-25 19:11:10 +00:00
Code Issues Projects Releases Wiki Activity

pass request by value

Browse source
This commit is contained in:
Nikolay Kim 2017-11-26 20:32:12 -08:00
parent eb7f48a1c6
commit 8e0a7f44d4
12 changed files with 132 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
README.md
View file

@ -83,14 +83,14 @@ impl Actor for MyWebSocket {
impl Route for MyWebSocket {
type State = ();
fn request(req: &mut HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
fn request(mut req: HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
{
// websocket handshake
let resp = ws::handshake(req)?;
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(req));
ctx.add_stream(ws::WsStream::new(&mut req));
Reply::async(MyWebSocket)
}
}

6
examples/basic.rs
View file

@ -12,7 +12,7 @@ use actix_web::middlewares::RequestSession;
use futures::stream::{once, Once};
/// somple handle
fn index(req: &mut HttpRequest, state: &()) -> Result<HttpResponse> {
fn index(mut req: HttpRequest, state: &()) -> Result<HttpResponse> {
println!("{:?}", req);
if let Ok(ch) = req.payload_mut().readany() {
if let futures::Async::Ready(Some(d)) = ch {
@ -32,7 +32,7 @@ fn index(req: &mut HttpRequest, state: &()) -> Result<HttpResponse> {
}
/// somple handle
fn index_async(req: &mut HttpRequest, state: &()) -> Once<actix_web::Frame, Error>
fn index_async(req: HttpRequest, state: &()) -> Once<actix_web::Frame, Error>
{
println!("{:?}", req);
@ -44,7 +44,7 @@ fn index_async(req: &mut HttpRequest, state: &()) -> Once<actix_web::Frame, Erro
}
/// handle with path parameters like `/user/{name}/`
fn with_param(req: &mut HttpRequest, state: &()) -> Result<HttpResponse>
fn with_param(req: HttpRequest, state: &()) -> Result<HttpResponse>
{
println!("{:?}", req);

8
examples/state.rs
View file

@ -15,7 +15,7 @@ struct AppState {
}
/// somple handle
fn index(req: &mut HttpRequest, state: &AppState) -> HttpResponse {
fn index(req: HttpRequest, state: &AppState) -> HttpResponse {
println!("{:?}", req);
state.counter.set(state.counter.get() + 1);
httpcodes::HTTPOk.with_body(
@ -36,11 +36,11 @@ impl Route for MyWebSocket {
/// Shared application state
type State = AppState;
fn request(req: &mut HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
fn request(mut req: HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
{
let resp = ws::handshake(req)?;
let resp = ws::handshake(&req)?;
ctx.start(resp);
ctx.add_stream(ws::WsStream::new(req));
ctx.add_stream(ws::WsStream::new(&mut req));
Reply::async(MyWebSocket{counter: 0})
}
}

6
examples/websocket.rs
View file

@ -22,14 +22,14 @@ impl Actor for MyWebSocket {
impl Route for MyWebSocket {
type State = ();
fn request(req: &mut HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
fn request(mut req: HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
{
// websocket handshake
let resp = ws::handshake(req)?;
let resp = ws::handshake(&req)?;
// send HttpResponse back to peer
ctx.start(resp);
// convert bytes stream to a stream of `ws::Message` and register it
ctx.add_stream(ws::WsStream::new(req));
ctx.add_stream(ws::WsStream::new(&mut req));
Reply::async(MyWebSocket)
}
}

9
src/application.rs
View file

@ -24,7 +24,7 @@ pub struct Application<S> {
impl<S: 'static> Application<S> {
fn run(&self, req: &mut HttpRequest) -> Task {
fn run(&self, mut req: HttpRequest) -> Task {
if let Some((params, h)) = self.router.recognize(req.path()) {
if let Some(params) = params {
req.set_match_info(params);
@ -48,8 +48,7 @@ impl<S: 'static> HttpHandler for Application<S> {
}
fn handle(&self, req: HttpRequest) -> Pipeline {
Pipeline::new(req, Rc::clone(&self.middlewares),
&|req: &mut HttpRequest| {self.run(req)})
Pipeline::new(req, Rc::clone(&self.middlewares), &|req: HttpRequest| {self.run(req)})
}
}
@ -139,7 +138,7 @@ impl<S> ApplicationBuilder<S> where S: 'static {
/// impl Route for MyRoute {
/// type State = ();
///
/// fn request(req: &mut HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self> {
/// fn request(req: HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self> {
/// Reply::reply(httpcodes::HTTPOk)
/// }
/// }
@ -202,7 +201,7 @@ impl<S> ApplicationBuilder<S> where S: 'static {
/// }
/// ```
pub fn handler<P, F, R>(&mut self, path: P, handler: F) -> &mut Self
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Into<HttpResponse> + 'static,
P: Into<String>,
{

2
src/httpcodes.rs
View file

@ -70,7 +70,7 @@ impl StaticResponse {
}
impl<S> RouteHandler<S> for StaticResponse {
fn handle(&self, _: &mut HttpRequest, _: Rc<S>) -> Task {
fn handle(&self, _: HttpRequest, _: Rc<S>) -> Task {
Task::reply(HttpResponse::new(self.0, Body::Empty))
}
}

152
src/httprequest.rs
View file

@ -1,5 +1,6 @@
//! HTTP Request message related code.
use std::{str, fmt, mem};
use std::rc::Rc;
use std::net::SocketAddr;
use std::collections::HashMap;
use bytes::BytesMut;
@ -13,45 +14,24 @@ use payload::Payload;
use multipart::Multipart;
use error::{ParseError, PayloadError, MultipartError, CookieParseError, HttpRangeError};
/// An HTTP Request
pub struct HttpRequest {
struct HttpMessage {
version: Version,
method: Method,
path: String,
query: String,
headers: HeaderMap,
extensions: Extensions,
params: Params,
cookies: Vec<Cookie<'static>>,
cookies_loaded: bool,
extensions: Extensions,
addr: Option<SocketAddr>,
payload: Payload,
}
impl HttpRequest {
/// Construct a new Request.
#[inline]
pub fn new(method: Method, path: String,
version: Version, headers: HeaderMap, query: String, payload: Payload) -> Self
{
HttpRequest {
method: method,
path: path,
query: query,
version: version,
headers: headers,
params: Params::empty(),
cookies: Vec::new(),
cookies_loaded: false,
extensions: Extensions::new(),
addr: None,
payload: payload,
}
}
impl Default for HttpMessage {
pub(crate) fn for_error() -> HttpRequest {
HttpRequest {
fn default() -> HttpMessage {
HttpMessage {
method: Method::GET,
path: String::new(),
query: String::new(),
@ -60,38 +40,75 @@ impl HttpRequest {
params: Params::empty(),
cookies: Vec::new(),
cookies_loaded: false,
extensions: Extensions::new(),
addr: None,
payload: Payload::empty(),
extensions: Extensions::new(),
}
}
}
/// An HTTP Request
pub struct HttpRequest(Rc<HttpMessage>);
impl HttpRequest {
/// Construct a new Request.
#[inline]
pub fn new(method: Method, path: String, version: Version,
headers: HeaderMap, query: String, payload: Payload) -> HttpRequest
{
HttpRequest(
Rc::new(HttpMessage {
method: method,
path: path,
query: query,
version: version,
headers: headers,
params: Params::empty(),
cookies: Vec::new(),
cookies_loaded: false,
addr: None,
payload: payload,
extensions: Extensions::new(),
})
)
}
pub(crate) fn for_error() -> HttpRequest {
HttpRequest(Rc::new(HttpMessage::default()))
}
fn as_mut(&mut self) -> &mut HttpMessage {
let r: &HttpMessage = self.0.as_ref();
#[allow(mutable_transmutes)]
unsafe{mem::transmute(r)}
}
/// Protocol extensions.
#[inline]
pub fn extensions(&mut self) -> &mut Extensions {
&mut self.extensions
&mut self.as_mut().extensions
}
/// Read the Request method.
#[inline]
pub fn method(&self) -> &Method { &self.method }
pub fn method(&self) -> &Method { &self.0.method }
/// Read the Request Version.
#[inline]
pub fn version(&self) -> Version {
self.version
self.0.version
}
/// Read the Request Headers.
#[inline]
pub fn headers(&self) -> &HeaderMap {
&self.headers
&self.0.headers
}
/// The target path of this Request.
#[inline]
pub fn path(&self) -> &str {
&self.path
&self.0.path
}
/// Remote IP of client initiated HTTP request.
@ -103,18 +120,18 @@ impl HttpRequest {
/// - peername of opened socket
#[inline]
pub fn remote(&self) -> Option<&SocketAddr> {
self.addr.as_ref()
self.0.addr.as_ref()
}
pub(crate) fn set_remove_addr(&mut self, addr: Option<SocketAddr>) {
self.addr = addr
self.as_mut().addr = addr
}
/// Return a new iterator that yields pairs of `Cow<str>` for query parameters
#[inline]
pub fn query(&self) -> HashMap<String, String> {
let mut q: HashMap<String, String> = HashMap::new();
for (key, val) in form_urlencoded::parse(self.query.as_ref()) {
for (key, val) in form_urlencoded::parse(self.0.query.as_ref()) {
q.insert(key.to_string(), val.to_string());
}
q
@ -125,17 +142,17 @@ impl HttpRequest {
/// E.g., id=10
#[inline]
pub fn query_string(&self) -> &str {
&self.query
&self.0.query
}
/// Return request cookies.
pub fn cookies(&self) -> &Vec<Cookie<'static>> {
&self.cookies
&self.0.cookies
}
/// Return request cookie.
pub fn cookie(&self, name: &str) -> Option<&Cookie> {
for cookie in &self.cookies {
for cookie in &self.0.cookies {
if cookie.name() == name {
return Some(cookie)
}
@ -146,17 +163,18 @@ impl HttpRequest {
/// Load cookies
pub fn load_cookies(&mut self) -> Result<&Vec<Cookie<'static>>, CookieParseError>
{
if !self.cookies_loaded {
self.cookies_loaded = true;
if let Some(val) = self.headers.get(header::COOKIE) {
if !self.0.cookies_loaded {
let msg = self.as_mut();
msg.cookies_loaded = true;
if let Some(val) = msg.headers.get(header::COOKIE) {
let s = str::from_utf8(val.as_bytes())
.map_err(CookieParseError::from)?;
for cookie in s.split("; ") {
self.cookies.push(Cookie::parse_encoded(cookie)?.into_owned());
msg.cookies.push(Cookie::parse_encoded(cookie)?.into_owned());
}
}
}
Ok(&self.cookies)
Ok(&self.0.cookies)
}
/// Get a reference to the Params object.
@ -164,34 +182,34 @@ impl HttpRequest {
/// Route supports glob patterns: * for a single wildcard segment and :param
/// for matching storing that segment of the request url in the Params object.
#[inline]
pub fn match_info(&self) -> &Params { &self.params }
pub fn match_info(&self) -> &Params { &self.0.params }
/// Set request Params.
pub fn set_match_info(&mut self, params: Params) {
self.params = params;
self.as_mut().params = params;
}
/// Checks if a connection should be kept alive.
pub fn keep_alive(&self) -> bool {
if let Some(conn) = self.headers.get(header::CONNECTION) {
if let Some(conn) = self.0.headers.get(header::CONNECTION) {
if let Ok(conn) = conn.to_str() {
if self.version == Version::HTTP_10 && conn.contains("keep-alive") {
if self.0.version == Version::HTTP_10 && conn.contains("keep-alive") {
true
} else {
self.version == Version::HTTP_11 &&
self.0.version == Version::HTTP_11 &&
!(conn.contains("close") || conn.contains("upgrade"))
}
} else {
false
}
} else {
self.version != Version::HTTP_10
self.0.version != Version::HTTP_10
}
}
/// Read the request content type
pub fn content_type(&self) -> &str {
if let Some(content_type) = self.headers.get(header::CONTENT_TYPE) {
if let Some(content_type) = self.0.headers.get(header::CONTENT_TYPE) {
if let Ok(content_type) = content_type.to_str() {
return content_type
}
@ -201,17 +219,17 @@ impl HttpRequest {
/// Check if request requires connection upgrade
pub(crate) fn upgrade(&self) -> bool {
if let Some(conn) = self.headers.get(header::CONNECTION) {
if let Some(conn) = self.0.headers.get(header::CONNECTION) {
if let Ok(s) = conn.to_str() {
return s.to_lowercase().contains("upgrade")
}
}
self.method == Method::CONNECT
self.0.method == Method::CONNECT
}
/// Check if request has chunked transfer encoding
pub fn chunked(&self) -> Result<bool, ParseError> {
if let Some(encodings) = self.headers.get(header::TRANSFER_ENCODING) {
if let Some(encodings) = self.0.headers.get(header::TRANSFER_ENCODING) {
if let Ok(s) = encodings.to_str() {
Ok(s.to_lowercase().contains("chunked"))
} else {
@ -225,7 +243,7 @@ impl HttpRequest {
/// Parses Range HTTP header string as per RFC 2616.
/// `size` is full size of response (file).
pub fn range(&self, size: u64) -> Result<Vec<HttpRange>, HttpRangeError> {
if let Some(range) = self.headers().get(header::RANGE) {
if let Some(range) = self.0.headers.get(header::RANGE) {
HttpRange::parse(unsafe{str::from_utf8_unchecked(range.as_bytes())}, size)
.map_err(|e| e.into())
} else {
@ -236,25 +254,25 @@ impl HttpRequest {
/// Returns reference to the associated http payload.
#[inline]
pub fn payload(&self) -> &Payload {
&self.payload
&self.0.payload
}
/// Returns mutable reference to the associated http payload.
#[inline]
pub fn payload_mut(&mut self) -> &mut Payload {
&mut self.payload
&mut self.as_mut().payload
}
/// Return payload
pub fn take_payload(&mut self) -> Payload {
mem::replace(&mut self.payload, Payload::empty())
mem::replace(&mut self.as_mut().payload, Payload::empty())
}
/// Return stream to process BODY as multipart.
///
/// Content-type: multipart/form-data;
pub fn multipart(&self, payload: Payload) -> Result<Multipart, MultipartError> {
Ok(Multipart::new(Multipart::boundary(&self.headers)?, payload))
Ok(Multipart::new(Multipart::boundary(&self.0.headers)?, payload))
}
/// Parse `application/x-www-form-urlencoded` encoded body.
@ -287,7 +305,7 @@ impl HttpRequest {
}
}
if let Some(content_type) = self.headers().get(header::CONTENT_TYPE) {
if let Some(content_type) = self.0.headers.get(header::CONTENT_TYPE) {
if let Ok(content_type) = content_type.to_str() {
if content_type.to_lowercase() == "application/x-www-form-urlencoded" {
return Ok(UrlEncoded{pl: payload, body: BytesMut::new()})
@ -299,19 +317,25 @@ impl HttpRequest {
}
}
impl Clone for HttpRequest {
fn clone(&self) -> HttpRequest {
HttpRequest(Rc::clone(&self.0))
}
}
impl fmt::Debug for HttpRequest {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let res = write!(f, "\nHttpRequest {:?} {}:{}\n",
self.version, self.method, self.path);
self.0.version, self.0.method, self.0.path);
if !self.query_string().is_empty() {
let _ = write!(f, " query: ?{:?}\n", self.query_string());
}
if !self.params.is_empty() {
let _ = write!(f, " params: {:?}\n", self.params);
if !self.0.params.is_empty() {
let _ = write!(f, " params: {:?}\n", self.0.params);
}
let _ = write!(f, " headers:\n");
for key in self.headers.keys() {
let vals: Vec<_> = self.headers.get_all(key).iter().collect();
for key in self.0.headers.keys() {
let vals: Vec<_> = self.0.headers.get_all(key).iter().collect();
if vals.len() > 1 {
let _ = write!(f, " {:?}: {:?}\n", key, vals);
} else {

14
src/pipeline.rs
View file

@ -10,8 +10,8 @@ use h1writer::Writer;
use httprequest::HttpRequest;
use httpresponse::HttpResponse;
type Handler = Fn(&mut HttpRequest) -> Task;
pub(crate) type PipelineHandler<'a> = &'a Fn(&mut HttpRequest) -> Task;
type Handler = Fn(HttpRequest) -> Task;
pub(crate) type PipelineHandler<'a> = &'a Fn(HttpRequest) -> Task;
pub struct Pipeline(PipelineState);
@ -26,10 +26,10 @@ enum PipelineState {
impl Pipeline {
pub fn new(mut req: HttpRequest,
mw: Rc<Vec<Box<Middleware>>>, handler: PipelineHandler) -> Pipeline {
pub fn new(req: HttpRequest, mw: Rc<Vec<Box<Middleware>>>, handler: PipelineHandler) -> Pipeline
{
if mw.is_empty() {
let task = (handler)(&mut req);
let task = (handler)(req.clone());
Pipeline(PipelineState::Task(Box::new((task, req))))
} else {
match Start::init(mw, req, handler) {
@ -191,7 +191,7 @@ impl Start {
let len = self.middlewares.len();
loop {
if self.idx == len {
let task = (unsafe{&*self.hnd})(&mut req);
let task = (unsafe{&*self.hnd})(req.clone());
return Ok(StartResult::Ready(
Box::new(Handle::new(self.idx-1, req, self.prepare(task), self.middlewares))))
} else {
@ -243,7 +243,7 @@ impl Start {
self.prepare(Task::reply(resp)), Rc::clone(&self.middlewares)))))
}
if self.idx == len {
let task = (unsafe{&*self.hnd})(&mut req);
let task = (unsafe{&*self.hnd})(req.clone());
return Ok(Async::Ready(Box::new(Handle::new(
self.idx-1, req, self.prepare(task), Rc::clone(&self.middlewares)))))
} else {

6
src/resource.rs
View file

@ -64,7 +64,7 @@ impl<S> Resource<S> where S: 'static {
/// Register handler for specified method.
pub fn handler<F, R>(&mut self, method: Method, handler: F)
where F: Fn(&mut HttpRequest, &S) -> Result<R> + 'static,
where F: Fn(HttpRequest, &S) -> Result<R> + 'static,
R: Into<HttpResponse> + 'static,
{
self.routes.insert(method, Box::new(FnHandler::new(handler)));
@ -72,7 +72,7 @@ impl<S> Resource<S> where S: 'static {
/// Register async handler for specified method.
pub fn async<F, R>(&mut self, method: Method, handler: F)
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Stream<Item=Frame, Error=Error> + 'static,
{
self.routes.insert(method, Box::new(StreamHandler::new(handler)));
@ -125,7 +125,7 @@ impl<S> Resource<S> where S: 'static {
impl<S: 'static> RouteHandler<S> for Resource<S> {
fn handle(&self, req: &mut HttpRequest, state: Rc<S>) -> Task {
fn handle(&self, req: HttpRequest, state: Rc<S>) -> Task {
if let Some(handler) = self.routes.get(req.method()) {
handler.handle(req, state)
} else {

26
src/route.rs
View file

@ -33,7 +33,7 @@ impl Frame {
#[allow(unused_variables)]
pub trait RouteHandler<S>: 'static {
/// Handle request
fn handle(&self, req: &mut HttpRequest, state: Rc<S>) -> Task;
fn handle(&self, req: HttpRequest, state: Rc<S>) -> Task;
/// Set route prefix
fn set_prefix(&mut self, prefix: String) {}
@ -50,7 +50,7 @@ pub trait Route: Actor {
type State;
/// Handle `EXPECT` header. By default respones with `HTTP/1.1 100 Continue`
fn expect(req: &HttpRequest, ctx: &mut Self::Context) -> Result<(), Error>
fn expect(req: &mut HttpRequest, ctx: &mut Self::Context) -> Result<(), Error>
where Self: Actor<Context=HttpContext<Self>>
{
// handle expect header only for HTTP/1.1
@ -80,7 +80,7 @@ pub trait Route: Actor {
/// request/response or websocket connection.
/// In that case `HttpContext::start` and `HttpContext::write` has to be used
/// for writing response.
fn request(req: &mut HttpRequest, ctx: &mut Self::Context) -> RouteResult<Self>;
fn request(req: HttpRequest, ctx: &mut Self::Context) -> RouteResult<Self>;
/// This method creates `RouteFactory` for this actor.
fn factory() -> RouteFactory<Self, Self::State> {
@ -95,12 +95,12 @@ impl<A, S> RouteHandler<S> for RouteFactory<A, S>
where A: Actor<Context=HttpContext<A>> + Route<State=S>,
S: 'static
{
fn handle(&self, req: &mut HttpRequest, state: Rc<A::State>) -> Task {
fn handle(&self, mut req: HttpRequest, state: Rc<A::State>) -> Task {
let mut ctx = HttpContext::new(state);
// handle EXPECT header
if req.headers().contains_key(header::EXPECT) {
if let Err(resp) = A::expect(req, &mut ctx) {
if let Err(resp) = A::expect(&mut req, &mut ctx) {
return Task::reply(resp)
}
}
@ -114,7 +114,7 @@ impl<A, S> RouteHandler<S> for RouteFactory<A, S>
/// Fn() route handler
pub(crate)
struct FnHandler<S, R, F>
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Into<HttpResponse>,
S: 'static,
{
@ -123,7 +123,7 @@ struct FnHandler<S, R, F>
}
impl<S, R, F> FnHandler<S, R, F>
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Into<HttpResponse> + 'static,
S: 'static,
{
@ -133,11 +133,11 @@ impl<S, R, F> FnHandler<S, R, F>
}
impl<S, R, F> RouteHandler<S> for FnHandler<S, R, F>
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Into<HttpResponse> + 'static,
S: 'static,
{
fn handle(&self, req: &mut HttpRequest, state: Rc<S>) -> Task {
fn handle(&self, req: HttpRequest, state: Rc<S>) -> Task {
Task::reply((self.f)(req, &state).into())
}
}
@ -145,7 +145,7 @@ impl<S, R, F> RouteHandler<S> for FnHandler<S, R, F>
/// Async route handler
pub(crate)
struct StreamHandler<S, R, F>
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Stream<Item=Frame, Error=Error> + 'static,
S: 'static,
{
@ -154,7 +154,7 @@ struct StreamHandler<S, R, F>
}
impl<S, R, F> StreamHandler<S, R, F>
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Stream<Item=Frame, Error=Error> + 'static,
S: 'static,
{
@ -164,11 +164,11 @@ impl<S, R, F> StreamHandler<S, R, F>
}
impl<S, R, F> RouteHandler<S> for StreamHandler<S, R, F>
where F: Fn(&mut HttpRequest, &S) -> R + 'static,
where F: Fn(HttpRequest, &S) -> R + 'static,
R: Stream<Item=Frame, Error=Error> + 'static,
S: 'static,
{
fn handle(&self, req: &mut HttpRequest, state: Rc<S>) -> Task {
fn handle(&self, req: HttpRequest, state: Rc<S>) -> Task {
Task::with_stream((self.f)(req, &state))
}
}

2
src/staticfiles.rs
View file

@ -137,7 +137,7 @@ impl<S: 'static> RouteHandler<S> for StaticFiles {
}
}
fn handle(&self, req: &mut HttpRequest, _: Rc<S>) -> Task {
fn handle(&self, req: HttpRequest, _: Rc<S>) -> Task {
if !self.accessible {
Task::reply(HTTPNotFound)
} else {

4
src/ws.rs
View file

@ -22,14 +22,14 @@
//! impl Route for WsRoute {
//! type State = ();
//!
//! fn request(req: &mut HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
//! fn request(mut req: HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
//! {
//! // WebSocket handshake
//! let resp = ws::handshake(&req)?;
//! // Send handshake response to peer
//! ctx.start(resp);
//! // Map Payload into WsStream
//! ctx.add_stream(ws::WsStream::new(req));
//! ctx.add_stream(ws::WsStream::new(&mut req));
//! // Start ws messages processing
//! Reply::async(WsRoute)
//! }