1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-10-11 04:32:28 +00:00
actix-web/src/httpresponse.rs

940 lines
29 KiB
Rust
Raw Normal View History

2018-01-28 06:03:03 +00:00
//! Http response
2017-12-04 04:09:46 +00:00
use std::{mem, str, fmt};
2018-01-12 00:22:27 +00:00
use std::io::Write;
2017-12-16 00:24:15 +00:00
use std::cell::RefCell;
use std::collections::VecDeque;
2017-10-07 04:48:14 +00:00
2018-01-28 06:03:03 +00:00
use cookie::{Cookie, CookieJar};
2018-01-12 00:22:27 +00:00
use bytes::{Bytes, BytesMut, BufMut};
2017-10-22 16:13:29 +00:00
use http::{StatusCode, Version, HeaderMap, HttpTryFrom, Error as HttpError};
2017-10-10 06:07:32 +00:00
use http::header::{self, HeaderName, HeaderValue};
2017-11-27 18:39:47 +00:00
use serde_json;
use serde::Serialize;
2017-12-08 00:40:29 +00:00
2017-10-24 06:25:32 +00:00
use body::Body;
2017-11-25 17:03:44 +00:00
use error::Error;
2017-12-14 17:43:42 +00:00
use handler::Responder;
2018-01-12 02:41:33 +00:00
use headers::ContentEncoding;
2017-12-03 01:14:55 +00:00
use httprequest::HttpRequest;
/// Represents various types of connection
2017-10-08 04:48:00 +00:00
#[derive(Copy, Clone, PartialEq, Debug)]
pub enum ConnectionType {
/// Close connection after response
2017-10-08 04:48:00 +00:00
Close,
/// Keep connection alive after response
2017-10-08 04:48:00 +00:00
KeepAlive,
/// Connection is upgraded to different type
2017-10-08 04:48:00 +00:00
Upgrade,
}
2017-12-16 00:24:15 +00:00
/// An HTTP Response
pub struct HttpResponse(Option<Box<InnerHttpResponse>>);
impl Drop for HttpResponse {
fn drop(&mut self) {
if let Some(inner) = self.0.take() {
Pool::release(inner)
}
}
}
2017-10-07 06:14:13 +00:00
impl HttpResponse {
2017-10-10 23:03:32 +00:00
2017-12-16 00:24:15 +00:00
#[inline(always)]
2017-12-16 04:00:12 +00:00
#[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
2017-12-16 00:24:15 +00:00
fn get_ref(&self) -> &InnerHttpResponse {
self.0.as_ref().unwrap()
}
#[inline(always)]
2017-12-16 04:00:12 +00:00
#[cfg_attr(feature = "cargo-clippy", allow(inline_always))]
2017-12-16 00:24:15 +00:00
fn get_mut(&mut self) -> &mut InnerHttpResponse {
self.0.as_mut().unwrap()
}
2017-11-27 06:31:29 +00:00
/// Create http response builder with specific status.
2017-10-10 23:03:32 +00:00
#[inline]
2017-11-27 06:31:29 +00:00
pub fn build(status: StatusCode) -> HttpResponseBuilder {
2017-10-15 21:17:41 +00:00
HttpResponseBuilder {
2017-12-16 04:00:12 +00:00
response: Some(Pool::get(status)),
2017-10-10 23:03:32 +00:00
err: None,
2017-12-14 00:44:35 +00:00
cookies: None,
2017-10-10 23:03:32 +00:00
}
}
2017-10-07 06:14:13 +00:00
/// Constructs a response
2017-10-07 04:48:14 +00:00
#[inline]
2017-10-10 23:03:32 +00:00
pub fn new(status: StatusCode, body: Body) -> HttpResponse {
2017-12-16 04:00:12 +00:00
HttpResponse(Some(Pool::with_body(status, body)))
2017-10-07 04:48:14 +00:00
}
2017-11-25 17:03:44 +00:00
/// Constructs a error response
#[inline]
pub fn from_error(error: Error) -> HttpResponse {
let mut resp = error.cause().error_response();
2017-12-16 00:24:15 +00:00
resp.get_mut().error = Some(error);
2017-11-25 17:03:44 +00:00
resp
}
/// The source `error` for this response
#[inline]
pub fn error(&self) -> Option<&Error> {
2017-12-16 00:24:15 +00:00
self.get_ref().error.as_ref()
2017-11-25 17:03:44 +00:00
}
/// Get the HTTP version of this response
2017-10-07 04:48:14 +00:00
#[inline]
2017-10-11 00:14:30 +00:00
pub fn version(&self) -> Option<Version> {
2017-12-16 00:24:15 +00:00
self.get_ref().version
2017-10-07 04:48:14 +00:00
}
/// Get the headers from the response
2017-10-07 04:48:14 +00:00
#[inline]
2017-10-10 06:07:32 +00:00
pub fn headers(&self) -> &HeaderMap {
2017-12-16 00:24:15 +00:00
&self.get_ref().headers
2017-10-07 04:48:14 +00:00
}
/// Get a mutable reference to the headers
2017-10-07 04:48:14 +00:00
#[inline]
2017-10-10 06:07:32 +00:00
pub fn headers_mut(&mut self) -> &mut HeaderMap {
2017-12-16 00:24:15 +00:00
&mut self.get_mut().headers
2017-10-07 04:48:14 +00:00
}
/// Get the response status code
2017-10-07 04:48:14 +00:00
#[inline]
pub fn status(&self) -> StatusCode {
2017-12-16 00:24:15 +00:00
self.get_ref().status
2017-10-07 04:48:14 +00:00
}
/// Set the `StatusCode` for this response
2017-10-07 04:48:14 +00:00
#[inline]
2017-10-10 23:03:32 +00:00
pub fn status_mut(&mut self) -> &mut StatusCode {
2017-12-16 00:24:15 +00:00
&mut self.get_mut().status
2017-10-07 04:48:14 +00:00
}
/// Get custom reason for the response
2017-10-14 17:01:53 +00:00
#[inline]
pub fn reason(&self) -> &str {
2017-12-16 00:24:15 +00:00
if let Some(reason) = self.get_ref().reason {
2017-10-14 17:01:53 +00:00
reason
} else {
2017-12-16 00:24:15 +00:00
self.get_ref().status.canonical_reason().unwrap_or("<unknown status code>")
2017-10-14 17:01:53 +00:00
}
}
/// Set the custom reason for the response
2017-10-08 04:48:00 +00:00
#[inline]
2017-10-10 23:03:32 +00:00
pub fn set_reason(&mut self, reason: &'static str) -> &mut Self {
2017-12-16 00:24:15 +00:00
self.get_mut().reason = Some(reason);
2017-10-08 04:48:00 +00:00
self
}
/// Set connection type
2017-10-14 17:01:53 +00:00
pub fn set_connection_type(&mut self, conn: ConnectionType) -> &mut Self {
2017-12-16 00:24:15 +00:00
self.get_mut().connection_type = Some(conn);
2017-10-08 04:48:00 +00:00
self
}
/// Connection upgrade status
2018-01-01 01:26:32 +00:00
#[inline]
2017-10-08 04:48:00 +00:00
pub fn upgrade(&self) -> bool {
2017-12-16 00:24:15 +00:00
self.get_ref().connection_type == Some(ConnectionType::Upgrade)
2017-10-08 04:48:00 +00:00
}
2017-10-07 04:48:14 +00:00
/// Keep-alive status for this connection
2017-10-10 23:03:32 +00:00
pub fn keep_alive(&self) -> Option<bool> {
2017-12-16 00:24:15 +00:00
if let Some(ct) = self.get_ref().connection_type {
2017-10-23 05:54:11 +00:00
match ct {
ConnectionType::KeepAlive => Some(true),
ConnectionType::Close | ConnectionType::Upgrade => Some(false),
}
2017-10-07 04:48:14 +00:00
} else {
2017-10-10 23:03:32 +00:00
None
2017-10-07 04:48:14 +00:00
}
}
2017-10-08 04:48:00 +00:00
2017-10-07 04:48:14 +00:00
/// is chunked encoding enabled
2018-01-01 01:26:32 +00:00
#[inline]
pub fn chunked(&self) -> Option<bool> {
2017-12-16 00:24:15 +00:00
self.get_ref().chunked
2017-10-07 04:48:14 +00:00
}
/// Content encoding
2018-01-01 01:26:32 +00:00
#[inline]
pub fn content_encoding(&self) -> Option<ContentEncoding> {
self.get_ref().encoding
}
/// Set content encoding
pub fn set_content_encoding(&mut self, enc: ContentEncoding) -> &mut Self {
self.get_mut().encoding = Some(enc);
self
}
2017-10-07 06:14:13 +00:00
/// Get body os this response
2018-01-01 01:26:32 +00:00
#[inline]
2017-10-07 04:48:14 +00:00
pub fn body(&self) -> &Body {
2017-12-16 00:24:15 +00:00
&self.get_ref().body
2017-10-07 04:48:14 +00:00
}
2017-10-08 04:48:00 +00:00
/// Set a body
2017-10-10 23:03:32 +00:00
pub fn set_body<B: Into<Body>>(&mut self, body: B) {
2017-12-16 00:24:15 +00:00
self.get_mut().body = body.into();
2017-10-08 04:48:00 +00:00
}
2017-10-07 06:14:13 +00:00
/// Set a body and return previous body value
2017-10-08 04:48:00 +00:00
pub fn replace_body<B: Into<Body>>(&mut self, body: B) -> Body {
2017-12-16 00:24:15 +00:00
mem::replace(&mut self.get_mut().body, body.into())
2017-10-07 04:48:14 +00:00
}
2017-11-10 20:29:54 +00:00
/// Size of response in bytes, excluding HTTP headers
pub fn response_size(&self) -> u64 {
2017-12-16 00:24:15 +00:00
self.get_ref().response_size
2017-11-10 20:29:54 +00:00
}
/// Set content encoding
pub(crate) fn set_response_size(&mut self, size: u64) {
2017-12-16 00:24:15 +00:00
self.get_mut().response_size = size;
2017-11-10 20:29:54 +00:00
}
2017-10-07 04:48:14 +00:00
}
2017-10-10 23:03:32 +00:00
2017-11-09 03:31:25 +00:00
impl fmt::Debug for HttpResponse {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let res = write!(f, "\nHttpResponse {:?} {}{}\n",
2017-12-16 00:24:15 +00:00
self.get_ref().version, self.get_ref().status,
self.get_ref().reason.unwrap_or(""));
let _ = write!(f, " encoding: {:?}\n", self.get_ref().encoding);
2017-11-09 03:31:25 +00:00
let _ = write!(f, " headers:\n");
2017-12-16 00:24:15 +00:00
for key in self.get_ref().headers.keys() {
let vals: Vec<_> = self.get_ref().headers.get_all(key).iter().collect();
2017-11-09 03:31:25 +00:00
if vals.len() > 1 {
let _ = write!(f, " {:?}: {:?}\n", key, vals);
} else {
let _ = write!(f, " {:?}: {:?}\n", key, vals[0]);
}
}
res
}
}
2017-10-10 23:03:32 +00:00
/// An HTTP response builder
///
/// This type can be used to construct an instance of `HttpResponse` through a
/// builder-like pattern.
#[derive(Debug)]
2017-10-15 21:17:41 +00:00
pub struct HttpResponseBuilder {
2017-12-16 00:24:15 +00:00
response: Option<Box<InnerHttpResponse>>,
2017-10-22 16:13:29 +00:00
err: Option<HttpError>,
2017-12-14 00:44:35 +00:00
cookies: Option<CookieJar>,
2017-10-10 23:03:32 +00:00
}
2017-10-15 21:17:41 +00:00
impl HttpResponseBuilder {
2017-12-21 07:19:21 +00:00
/// Set HTTP version of this response.
///
/// By default response's http version depends on request's version.
2017-10-10 23:03:32 +00:00
#[inline]
pub fn version(&mut self, version: Version) -> &mut Self {
2017-12-14 00:44:35 +00:00
if let Some(parts) = parts(&mut self.response, &self.err) {
2017-10-11 00:14:30 +00:00
parts.version = Some(version);
2017-10-10 23:03:32 +00:00
}
self
}
/// Set a header.
2017-12-21 07:19:21 +00:00
///
/// ```rust
/// # extern crate http;
/// # extern crate actix_web;
/// # use actix_web::*;
/// # use actix_web::httpcodes::*;
/// #
/// use http::header;
///
/// fn index(req: HttpRequest) -> Result<HttpResponse> {
2018-03-02 03:12:59 +00:00
/// Ok(HttpOk.build()
2017-12-21 07:19:21 +00:00
/// .header("X-TEST", "value")
/// .header(header::CONTENT_TYPE, "application/json")
/// .finish()?)
/// }
/// fn main() {}
/// ```
2017-10-10 23:03:32 +00:00
pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
where HeaderName: HttpTryFrom<K>,
HeaderValue: HttpTryFrom<V>
{
2017-12-14 00:44:35 +00:00
if let Some(parts) = parts(&mut self.response, &self.err) {
2017-10-10 23:03:32 +00:00
match HeaderName::try_from(key) {
Ok(key) => {
match HeaderValue::try_from(value) {
Ok(value) => { parts.headers.append(key, value); }
Err(e) => self.err = Some(e.into()),
}
},
Err(e) => self.err = Some(e.into()),
};
}
self
}
/// Set the custom reason for the response.
#[inline]
pub fn reason(&mut self, reason: &'static str) -> &mut Self {
2017-12-14 00:44:35 +00:00
if let Some(parts) = parts(&mut self.response, &self.err) {
2017-10-10 23:03:32 +00:00
parts.reason = Some(reason);
}
self
}
2017-11-06 09:24:49 +00:00
/// Set content encoding.
///
/// By default `ContentEncoding::Auto` is used, which automatically
/// negotiates content encoding based on request's `Accept-Encoding` headers.
2017-11-30 15:42:02 +00:00
/// To enforce specific encoding, use specific ContentEncoding` value.
2017-12-04 04:47:15 +00:00
#[inline]
2017-11-06 09:24:49 +00:00
pub fn content_encoding(&mut self, enc: ContentEncoding) -> &mut Self {
2017-12-14 00:44:35 +00:00
if let Some(parts) = parts(&mut self.response, &self.err) {
parts.encoding = Some(enc);
2017-11-06 09:24:49 +00:00
}
self
}
2017-10-10 23:03:32 +00:00
/// Set connection type
2017-12-04 04:47:15 +00:00
#[inline]
2017-12-21 07:19:21 +00:00
#[doc(hidden)]
2017-10-14 17:01:53 +00:00
pub fn connection_type(&mut self, conn: ConnectionType) -> &mut Self {
2017-12-14 00:44:35 +00:00
if let Some(parts) = parts(&mut self.response, &self.err) {
2017-10-10 23:03:32 +00:00
parts.connection_type = Some(conn);
}
self
}
2017-10-14 17:01:53 +00:00
/// Set connection type to Upgrade
2017-12-04 04:47:15 +00:00
#[inline]
2017-12-21 07:19:21 +00:00
#[doc(hidden)]
2017-10-14 17:01:53 +00:00
pub fn upgrade(&mut self) -> &mut Self {
self.connection_type(ConnectionType::Upgrade)
}
/// Force close connection, even if it is marked as keep-alive
2017-12-04 04:47:15 +00:00
#[inline]
2017-10-14 17:01:53 +00:00
pub fn force_close(&mut self) -> &mut Self {
self.connection_type(ConnectionType::Close)
}
2017-10-10 23:03:32 +00:00
/// Enables automatic chunked transfer encoding
2017-12-04 04:47:15 +00:00
#[inline]
2017-12-14 06:36:28 +00:00
pub fn chunked(&mut self) -> &mut Self {
2017-12-14 00:44:35 +00:00
if let Some(parts) = parts(&mut self.response, &self.err) {
parts.chunked = Some(true);
}
self
}
/// Force disable chunked encoding
#[inline]
pub fn no_chunking(&mut self) -> &mut Self {
if let Some(parts) = parts(&mut self.response, &self.err) {
parts.chunked = Some(false);
2017-10-10 23:03:32 +00:00
}
self
}
2017-10-14 17:01:53 +00:00
/// Set response content type
2017-12-04 04:47:15 +00:00
#[inline]
2017-10-14 17:01:53 +00:00
pub fn content_type<V>(&mut self, value: V) -> &mut Self
where HeaderValue: HttpTryFrom<V>
{
2017-12-14 00:44:35 +00:00
if let Some(parts) = parts(&mut self.response, &self.err) {
2017-10-14 17:01:53 +00:00
match HeaderValue::try_from(value) {
Ok(value) => { parts.headers.insert(header::CONTENT_TYPE, value); },
Err(e) => self.err = Some(e.into()),
};
}
self
}
2018-01-12 00:22:27 +00:00
/// Set content length
#[inline]
pub fn content_length(&mut self, len: u64) -> &mut Self {
let mut wrt = BytesMut::new().writer();
let _ = write!(wrt, "{}", len);
self.header(header::CONTENT_LENGTH, wrt.get_mut().take().freeze())
}
2017-10-14 17:40:58 +00:00
/// Set a cookie
2017-12-21 07:19:21 +00:00
///
/// ```rust
/// # extern crate actix_web;
/// # use actix_web::*;
/// # use actix_web::httpcodes::*;
/// #
/// use actix_web::headers::Cookie;
///
/// fn index(req: HttpRequest) -> Result<HttpResponse> {
2018-03-02 03:12:59 +00:00
/// Ok(HttpOk.build()
2017-12-21 07:19:21 +00:00
/// .cookie(
/// Cookie::build("name", "value")
/// .domain("www.rust-lang.org")
/// .path("/")
/// .secure(true)
/// .http_only(true)
/// .finish())
/// .finish()?)
/// }
/// fn main() {}
/// ```
2017-10-14 17:40:58 +00:00
pub fn cookie<'c>(&mut self, cookie: Cookie<'c>) -> &mut Self {
2017-12-14 00:44:35 +00:00
if self.cookies.is_none() {
let mut jar = CookieJar::new();
jar.add(cookie.into_owned());
self.cookies = Some(jar)
} else {
self.cookies.as_mut().unwrap().add(cookie.into_owned());
2017-10-14 17:40:58 +00:00
}
self
}
2017-12-21 07:19:21 +00:00
/// Remove cookie, cookie has to be cookie from `HttpRequest::cookies()` method.
2017-10-14 17:40:58 +00:00
pub fn del_cookie<'a>(&mut self, cookie: &Cookie<'a>) -> &mut Self {
2017-12-14 00:44:35 +00:00
{
if self.cookies.is_none() {
self.cookies = Some(CookieJar::new())
2017-12-13 05:32:58 +00:00
}
2017-12-14 00:44:35 +00:00
let jar = self.cookies.as_mut().unwrap();
2017-10-14 17:40:58 +00:00
let cookie = cookie.clone().into_owned();
2017-12-13 05:32:58 +00:00
jar.add_original(cookie.clone());
jar.remove(cookie);
2017-10-14 17:40:58 +00:00
}
self
}
2017-12-21 07:19:21 +00:00
/// This method calls provided closure with builder reference if value is true.
2017-10-29 21:51:02 +00:00
pub fn if_true<F>(&mut self, value: bool, f: F) -> &mut Self
2018-01-10 21:41:33 +00:00
where F: FnOnce(&mut HttpResponseBuilder)
2017-10-29 21:51:02 +00:00
{
if value {
f(self);
}
self
}
2018-01-10 07:55:42 +00:00
/// This method calls provided closure with builder reference if value is Some.
pub fn if_some<T, F>(&mut self, value: Option<T>, f: F) -> &mut Self
where F: FnOnce(T, &mut HttpResponseBuilder)
2018-01-10 07:55:42 +00:00
{
if let Some(val) = value {
f(val, self);
}
self
}
2017-11-27 18:39:47 +00:00
/// Set a body and generate `HttpResponse`.
2017-12-21 07:19:21 +00:00
///
2017-11-27 18:39:47 +00:00
/// `HttpResponseBuilder` can not be used after this call.
2017-10-22 16:13:29 +00:00
pub fn body<B: Into<Body>>(&mut self, body: B) -> Result<HttpResponse, HttpError> {
2017-10-10 23:03:32 +00:00
if let Some(e) = self.err.take() {
return Err(e)
}
2017-12-14 00:44:35 +00:00
let mut response = self.response.take().expect("cannot reuse response builder");
if let Some(ref jar) = self.cookies {
2017-12-13 05:32:58 +00:00
for cookie in jar.delta() {
2017-12-14 00:44:35 +00:00
response.headers.append(
2017-12-13 05:32:58 +00:00
header::SET_COOKIE,
HeaderValue::from_str(&cookie.to_string())?);
}
2017-10-14 17:40:58 +00:00
}
2017-12-14 00:44:35 +00:00
response.body = body.into();
2017-12-16 04:00:12 +00:00
Ok(HttpResponse(Some(response)))
2017-10-10 23:03:32 +00:00
}
2017-10-24 06:52:20 +00:00
2017-11-27 18:39:47 +00:00
/// Set a json body and generate `HttpResponse`
2017-12-21 07:19:21 +00:00
///
/// `HttpResponseBuilder` can not be used after this call.
2017-11-27 18:39:47 +00:00
pub fn json<T: Serialize>(&mut self, value: T) -> Result<HttpResponse, Error> {
let body = serde_json::to_string(&value)?;
2017-12-14 00:44:35 +00:00
let contains = if let Some(parts) = parts(&mut self.response, &self.err) {
2017-11-27 18:39:47 +00:00
parts.headers.contains_key(header::CONTENT_TYPE)
} else {
true
};
if !contains {
self.header(header::CONTENT_TYPE, "application/json");
}
Ok(self.body(body)?)
}
/// Set an empty body and generate `HttpResponse`
2017-12-21 07:19:21 +00:00
///
/// `HttpResponseBuilder` can not be used after this call.
2017-10-24 06:52:20 +00:00
pub fn finish(&mut self) -> Result<HttpResponse, HttpError> {
self.body(Body::Empty)
}
2018-01-01 01:26:32 +00:00
/// This method construct new `HttpResponseBuilder`
pub fn take(&mut self) -> HttpResponseBuilder {
HttpResponseBuilder {
response: self.response.take(),
err: self.err.take(),
cookies: self.cookies.take(),
}
}
2017-10-10 23:03:32 +00:00
}
2017-12-16 04:00:12 +00:00
#[inline]
2017-12-16 00:24:15 +00:00
#[cfg_attr(feature = "cargo-clippy", allow(borrowed_box))]
fn parts<'a>(parts: &'a mut Option<Box<InnerHttpResponse>>, err: &Option<HttpError>)
-> Option<&'a mut Box<InnerHttpResponse>>
2017-10-10 23:03:32 +00:00
{
if err.is_some() {
return None
}
parts.as_mut()
}
2017-10-23 05:54:11 +00:00
2017-11-28 21:52:53 +00:00
/// Helper converters
impl<I: Into<HttpResponse>, E: Into<Error>> From<Result<I, E>> for HttpResponse {
fn from(res: Result<I, E>) -> Self {
match res {
Ok(val) => val.into(),
Err(err) => err.into().into(),
}
}
}
2017-11-29 17:17:00 +00:00
impl From<HttpResponseBuilder> for HttpResponse {
fn from(mut builder: HttpResponseBuilder) -> Self {
builder.finish().into()
}
}
2017-12-14 17:43:42 +00:00
impl Responder for HttpResponseBuilder {
type Item = HttpResponse;
type Error = HttpError;
2017-12-16 04:00:12 +00:00
#[inline]
2017-12-14 17:43:42 +00:00
fn respond_to(mut self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
self.finish()
2017-12-03 01:14:55 +00:00
}
}
2017-11-28 21:52:53 +00:00
impl From<&'static str> for HttpResponse {
2017-11-29 17:17:00 +00:00
fn from(val: &'static str) -> Self {
2017-11-28 21:52:53 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("text/plain; charset=utf-8")
.body(val)
.into()
}
}
2017-12-14 17:43:42 +00:00
impl Responder for &'static str {
type Item = HttpResponse;
type Error = HttpError;
2017-12-14 17:43:42 +00:00
fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
2017-12-03 01:14:55 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("text/plain; charset=utf-8")
.body(self)
}
}
2017-11-28 21:52:53 +00:00
impl From<&'static [u8]> for HttpResponse {
2017-11-29 17:17:00 +00:00
fn from(val: &'static [u8]) -> Self {
2017-11-28 21:52:53 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("application/octet-stream")
.body(val)
.into()
}
}
2017-12-14 17:43:42 +00:00
impl Responder for &'static [u8] {
type Item = HttpResponse;
type Error = HttpError;
2017-12-14 17:43:42 +00:00
fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
2017-12-03 01:14:55 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("application/octet-stream")
.body(self)
}
}
2017-11-28 21:52:53 +00:00
impl From<String> for HttpResponse {
2017-11-29 17:17:00 +00:00
fn from(val: String) -> Self {
2017-11-28 21:52:53 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("text/plain; charset=utf-8")
.body(val)
.into()
}
}
2017-12-14 17:43:42 +00:00
impl Responder for String {
type Item = HttpResponse;
type Error = HttpError;
2017-12-14 17:43:42 +00:00
fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
2017-12-03 01:14:55 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("text/plain; charset=utf-8")
.body(self)
}
}
2017-11-28 21:52:53 +00:00
impl<'a> From<&'a String> for HttpResponse {
2017-11-29 17:17:00 +00:00
fn from(val: &'a String) -> Self {
2017-11-28 21:52:53 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("text/plain; charset=utf-8")
.body(val)
.into()
}
}
2017-12-14 17:43:42 +00:00
impl<'a> Responder for &'a String {
type Item = HttpResponse;
type Error = HttpError;
2017-12-14 17:43:42 +00:00
fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
2017-12-03 01:14:55 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("text/plain; charset=utf-8")
.body(self)
}
}
2017-11-28 21:52:53 +00:00
impl From<Bytes> for HttpResponse {
2017-11-29 17:17:00 +00:00
fn from(val: Bytes) -> Self {
2017-11-28 21:52:53 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("application/octet-stream")
.body(val)
.into()
}
}
2017-12-14 17:43:42 +00:00
impl Responder for Bytes {
type Item = HttpResponse;
type Error = HttpError;
2017-12-14 17:43:42 +00:00
fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
2017-12-03 01:14:55 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("application/octet-stream")
.body(self)
}
}
2017-11-28 21:52:53 +00:00
impl From<BytesMut> for HttpResponse {
2017-11-29 17:17:00 +00:00
fn from(val: BytesMut) -> Self {
2017-11-28 21:52:53 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("application/octet-stream")
.body(val)
.into()
}
}
2017-12-14 17:43:42 +00:00
impl Responder for BytesMut {
type Item = HttpResponse;
type Error = HttpError;
2017-12-14 17:43:42 +00:00
fn respond_to(self, _: HttpRequest) -> Result<HttpResponse, HttpError> {
2017-12-03 01:14:55 +00:00
HttpResponse::build(StatusCode::OK)
.content_type("application/octet-stream")
.body(self)
}
}
2017-12-16 04:00:12 +00:00
#[derive(Debug)]
struct InnerHttpResponse {
version: Option<Version>,
headers: HeaderMap,
status: StatusCode,
reason: Option<&'static str>,
body: Body,
chunked: Option<bool>,
encoding: Option<ContentEncoding>,
2017-12-16 04:00:12 +00:00
connection_type: Option<ConnectionType>,
response_size: u64,
error: Option<Error>,
}
impl InnerHttpResponse {
#[inline]
fn new(status: StatusCode, body: Body) -> InnerHttpResponse {
InnerHttpResponse {
2018-02-26 22:33:56 +00:00
status,
body,
2017-12-16 04:00:12 +00:00
version: None,
2017-12-16 06:49:48 +00:00
headers: HeaderMap::with_capacity(16),
2017-12-16 04:00:12 +00:00
reason: None,
chunked: None,
encoding: None,
2017-12-16 04:00:12 +00:00
connection_type: None,
response_size: 0,
error: None,
}
}
}
/// Internal use only! unsafe
struct Pool(VecDeque<Box<InnerHttpResponse>>);
2017-12-16 06:49:48 +00:00
thread_local!(static POOL: RefCell<Pool> =
RefCell::new(Pool(VecDeque::with_capacity(128))));
2017-12-16 04:00:12 +00:00
impl Pool {
2017-12-16 06:49:48 +00:00
#[inline]
2017-12-16 04:00:12 +00:00
fn get(status: StatusCode) -> Box<InnerHttpResponse> {
POOL.with(|pool| {
if let Some(mut resp) = pool.borrow_mut().0.pop_front() {
resp.body = Body::Empty;
resp.status = status;
resp
} else {
Box::new(InnerHttpResponse::new(status, Body::Empty))
}
})
}
2017-12-16 06:49:48 +00:00
#[inline]
2017-12-16 04:00:12 +00:00
fn with_body(status: StatusCode, body: Body) -> Box<InnerHttpResponse> {
POOL.with(|pool| {
if let Some(mut resp) = pool.borrow_mut().0.pop_front() {
resp.status = status;
resp.body = body;
2017-12-16 04:00:12 +00:00
resp
} else {
Box::new(InnerHttpResponse::new(status, body))
}
})
}
2017-12-16 06:49:48 +00:00
#[inline(always)]
#[cfg_attr(feature = "cargo-clippy", allow(boxed_local, inline_always))]
2017-12-16 04:00:12 +00:00
fn release(mut inner: Box<InnerHttpResponse>) {
POOL.with(|pool| {
let v = &mut pool.borrow_mut().0;
if v.len() < 128 {
inner.headers.clear();
inner.version = None;
inner.chunked = None;
2017-12-16 04:00:12 +00:00
inner.reason = None;
inner.encoding = None;
2017-12-16 04:00:12 +00:00
inner.connection_type = None;
inner.response_size = 0;
inner.error = None;
v.push_front(inner);
}
})
}
}
2017-10-23 05:54:11 +00:00
#[cfg(test)]
mod tests {
use super::*;
2017-12-13 19:16:26 +00:00
use std::str::FromStr;
use time::Duration;
use http::{Method, Uri};
2017-11-28 21:52:53 +00:00
use body::Binary;
2017-12-13 19:16:26 +00:00
use {headers, httpcodes};
#[test]
fn test_debug() {
let resp = HttpResponse::Ok().finish().unwrap();
let dbg = format!("{:?}", resp);
assert!(dbg.contains("HttpResponse"));
}
#[test]
fn test_response_cookies() {
let mut headers = HeaderMap::new();
headers.insert(header::COOKIE,
header::HeaderValue::from_static("cookie1=value1; cookie2=value2"));
let req = HttpRequest::new(
Method::GET, Uri::from_str("/").unwrap(), Version::HTTP_11, headers, None);
let cookies = req.cookies().unwrap();
2018-03-02 03:12:59 +00:00
let resp = httpcodes::HttpOk
2017-12-13 19:16:26 +00:00
.build()
.cookie(headers::Cookie::build("name", "value")
.domain("www.rust-lang.org")
.path("/test")
.http_only(true)
.max_age(Duration::days(1))
.finish())
.del_cookie(&cookies[0])
.body(Body::Empty);
assert!(resp.is_ok());
let resp = resp.unwrap();
let mut val: Vec<_> = resp.headers().get_all("Set-Cookie")
.iter().map(|v| v.to_str().unwrap().to_owned()).collect();
val.sort();
assert!(val[0].starts_with("cookie1=; Max-Age=0;"));
assert_eq!(
val[1],"name=value; HttpOnly; Path=/test; Domain=www.rust-lang.org; Max-Age=86400");
}
2017-10-23 05:54:11 +00:00
2017-11-28 22:29:22 +00:00
#[test]
fn test_basic_builder() {
let resp = HttpResponse::Ok()
2017-12-04 04:09:46 +00:00
.header("X-TEST", "value")
2017-11-28 22:29:22 +00:00
.version(Version::HTTP_10)
.finish().unwrap();
assert_eq!(resp.version(), Some(Version::HTTP_10));
2017-12-21 07:36:52 +00:00
assert_eq!(resp.status(), StatusCode::OK);
2017-11-28 22:29:22 +00:00
}
2017-10-23 05:54:11 +00:00
#[test]
fn test_upgrade() {
2017-11-27 06:31:29 +00:00
let resp = HttpResponse::build(StatusCode::OK)
2017-10-23 05:54:11 +00:00
.upgrade().body(Body::Empty).unwrap();
assert!(resp.upgrade())
}
#[test]
fn test_force_close() {
2017-11-27 06:31:29 +00:00
let resp = HttpResponse::build(StatusCode::OK)
2017-10-23 05:54:11 +00:00
.force_close().body(Body::Empty).unwrap();
assert!(!resp.keep_alive().unwrap())
}
#[test]
fn test_content_type() {
2017-11-27 06:31:29 +00:00
let resp = HttpResponse::build(StatusCode::OK)
2017-10-23 05:54:11 +00:00
.content_type("text/plain").body(Body::Empty).unwrap();
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(), "text/plain")
}
#[test]
fn test_content_encoding() {
2017-11-27 06:31:29 +00:00
let resp = HttpResponse::build(StatusCode::OK).finish().unwrap();
assert_eq!(resp.content_encoding(), None);
2017-11-27 06:31:29 +00:00
let resp = HttpResponse::build(StatusCode::OK)
.content_encoding(ContentEncoding::Br).finish().unwrap();
assert_eq!(resp.content_encoding(), Some(ContentEncoding::Br));
2017-11-07 00:23:58 +00:00
}
2017-11-27 18:39:47 +00:00
#[test]
fn test_json() {
let resp = HttpResponse::build(StatusCode::OK)
.json(vec!["v1", "v2", "v3"]).unwrap();
let ct = resp.headers().get(header::CONTENT_TYPE).unwrap();
assert_eq!(ct, header::HeaderValue::from_static("application/json"));
assert_eq!(*resp.body(), Body::from(Bytes::from_static(b"[\"v1\",\"v2\",\"v3\"]")));
}
#[test]
fn test_json_ct() {
let resp = HttpResponse::build(StatusCode::OK)
.header(header::CONTENT_TYPE, "text/json")
.json(vec!["v1", "v2", "v3"]).unwrap();
let ct = resp.headers().get(header::CONTENT_TYPE).unwrap();
assert_eq!(ct, header::HeaderValue::from_static("text/json"));
assert_eq!(*resp.body(), Body::from(Bytes::from_static(b"[\"v1\",\"v2\",\"v3\"]")));
}
2017-11-28 21:52:53 +00:00
impl Body {
pub(crate) fn binary(&self) -> Option<&Binary> {
match *self {
Body::Binary(ref bin) => Some(bin),
_ => None,
}
}
}
#[test]
fn test_into_response() {
let req = HttpRequest::default();
2017-11-28 21:52:53 +00:00
let resp: HttpResponse = "test".into();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("text/plain; charset=utf-8"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from("test"));
2017-12-14 17:43:42 +00:00
let resp: HttpResponse = "test".respond_to(req.clone()).ok().unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("text/plain; charset=utf-8"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from("test"));
2017-11-28 21:52:53 +00:00
let resp: HttpResponse = b"test".as_ref().into();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("application/octet-stream"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(b"test".as_ref()));
2017-12-14 17:43:42 +00:00
let resp: HttpResponse = b"test".as_ref().respond_to(req.clone()).ok().unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("application/octet-stream"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(b"test".as_ref()));
2017-11-28 21:52:53 +00:00
let resp: HttpResponse = "test".to_owned().into();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("text/plain; charset=utf-8"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from("test".to_owned()));
2017-12-14 17:43:42 +00:00
let resp: HttpResponse = "test".to_owned().respond_to(req.clone()).ok().unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("text/plain; charset=utf-8"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from("test".to_owned()));
2017-11-28 21:52:53 +00:00
let resp: HttpResponse = (&"test".to_owned()).into();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("text/plain; charset=utf-8"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(&"test".to_owned()));
2017-11-28 21:52:53 +00:00
2017-12-14 17:43:42 +00:00
let resp: HttpResponse = (&"test".to_owned()).respond_to(req.clone()).ok().unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("text/plain; charset=utf-8"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(&"test".to_owned()));
2017-11-28 21:52:53 +00:00
let b = Bytes::from_static(b"test");
let resp: HttpResponse = b.into();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("application/octet-stream"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(Bytes::from_static(b"test")));
let b = Bytes::from_static(b"test");
2017-12-14 17:43:42 +00:00
let resp: HttpResponse = b.respond_to(req.clone()).ok().unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("application/octet-stream"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(Bytes::from_static(b"test")));
2017-11-28 21:52:53 +00:00
let b = BytesMut::from("test");
let resp: HttpResponse = b.into();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("application/octet-stream"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(BytesMut::from("test")));
let b = BytesMut::from("test");
2017-12-14 17:43:42 +00:00
let resp: HttpResponse = b.respond_to(req.clone()).ok().unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("application/octet-stream"));
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.body().binary().unwrap(), &Binary::from(BytesMut::from("test")));
2017-11-28 21:52:53 +00:00
}
2017-10-23 05:54:11 +00:00
}