mirrors/actix-web
1
0
Fork 0
mirror of https://github.com/actix/actix-web.git synced 2024-12-30 03:50:42 +00:00
Code Issues Projects Releases Wiki Activity

hide httpmessage mod

Browse source
This commit is contained in:
Rob Ede 2021-02-11 22:39:54 +00:00
parent 871ca5e4ae
commit 77efc09362
No known key found for this signature in database
GPG key ID: C2A3B36E841A91E6
35 changed files with 125 additions and 98 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
actix-http-test/src/lib.rs
View file

@ -150,7 +150,7 @@ impl TestServer {
} }
} }
/// Construct test https server url /// Construct test HTTPS server URL.
pub fn surl(&self, uri: &str) -> String { pub fn surl(&self, uri: &str) -> String {
if uri.starts_with('/') { if uri.starts_with('/') {
format!("https://localhost:{}{}", self.addr.port(), uri) format!("https://localhost:{}{}", self.addr.port(), uri)
@ -164,7 +164,7 @@ impl TestServer {
self.client.get(self.url(path.as_ref()).as_str()) self.client.get(self.url(path.as_ref()).as_str())
} }
/// Create https `GET` request /// Create HTTPS `GET` request
pub fn sget<S: AsRef<str>>(&self, path: S) -> ClientRequest { pub fn sget<S: AsRef<str>>(&self, path: S) -> ClientRequest {
self.client.get(self.surl(path.as_ref()).as_str()) self.client.get(self.surl(path.as_ref()).as_str())
} }
@ -174,7 +174,7 @@ impl TestServer {
self.client.post(self.url(path.as_ref()).as_str()) self.client.post(self.url(path.as_ref()).as_str())
} }
/// Create https `POST` request /// Create HTTPS `POST` request
pub fn spost<S: AsRef<str>>(&self, path: S) -> ClientRequest { pub fn spost<S: AsRef<str>>(&self, path: S) -> ClientRequest {
self.client.post(self.surl(path.as_ref()).as_str()) self.client.post(self.surl(path.as_ref()).as_str())
} }
@ -184,7 +184,7 @@ impl TestServer {
self.client.head(self.url(path.as_ref()).as_str()) self.client.head(self.url(path.as_ref()).as_str())
} }
/// Create https `HEAD` request /// Create HTTPS `HEAD` request
pub fn shead<S: AsRef<str>>(&self, path: S) -> ClientRequest { pub fn shead<S: AsRef<str>>(&self, path: S) -> ClientRequest {
self.client.head(self.surl(path.as_ref()).as_str()) self.client.head(self.surl(path.as_ref()).as_str())
} }
@ -194,7 +194,7 @@ impl TestServer {
self.client.put(self.url(path.as_ref()).as_str()) self.client.put(self.url(path.as_ref()).as_str())
} }
/// Create https `PUT` request /// Create HTTPS `PUT` request
pub fn sput<S: AsRef<str>>(&self, path: S) -> ClientRequest { pub fn sput<S: AsRef<str>>(&self, path: S) -> ClientRequest {
self.client.put(self.surl(path.as_ref()).as_str()) self.client.put(self.surl(path.as_ref()).as_str())
} }
@ -204,7 +204,7 @@ impl TestServer {
self.client.patch(self.url(path.as_ref()).as_str()) self.client.patch(self.url(path.as_ref()).as_str())
} }
/// Create https `PATCH` request /// Create HTTPS `PATCH` request
pub fn spatch<S: AsRef<str>>(&self, path: S) -> ClientRequest { pub fn spatch<S: AsRef<str>>(&self, path: S) -> ClientRequest {
self.client.patch(self.surl(path.as_ref()).as_str()) self.client.patch(self.surl(path.as_ref()).as_str())
} }
@ -214,7 +214,7 @@ impl TestServer {
self.client.delete(self.url(path.as_ref()).as_str()) self.client.delete(self.url(path.as_ref()).as_str())
} }
/// Create https `DELETE` request /// Create HTTPS `DELETE` request
pub fn sdelete<S: AsRef<str>>(&self, path: S) -> ClientRequest { pub fn sdelete<S: AsRef<str>>(&self, path: S) -> ClientRequest {
self.client.delete(self.surl(path.as_ref()).as_str()) self.client.delete(self.surl(path.as_ref()).as_str())
} }
@ -224,12 +224,12 @@ impl TestServer {
self.client.options(self.url(path.as_ref()).as_str()) self.client.options(self.url(path.as_ref()).as_str())
} }
/// Create https `OPTIONS` request /// Create HTTPS `OPTIONS` request
pub fn soptions<S: AsRef<str>>(&self, path: S) -> ClientRequest { pub fn soptions<S: AsRef<str>>(&self, path: S) -> ClientRequest {
self.client.options(self.surl(path.as_ref()).as_str()) self.client.options(self.surl(path.as_ref()).as_str())
} }
/// Connect to test http server /// Connect to test HTTP server
pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest { pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest {
self.client.request(method, path.as_ref()) self.client.request(method, path.as_ref())
} }
@ -263,7 +263,7 @@ impl TestServer {
self.ws_at("/").await self.ws_at("/").await
} }
/// Stop http server /// Stop HTTP server
fn stop(&mut self) { fn stop(&mut self) {
self.system.stop(); self.system.stop();
} }

18
actix-http/src/body.rs
View file

@ -1,6 +1,10 @@
use std::pin::Pin; //! Traits and structures to aid consuming and writing HTTP payloads.
use std::task::{Context, Poll};
use std::{fmt, mem}; use std::{
fmt, mem,
pin::Pin,
task::{Context, Poll},
};
use bytes::{Bytes, BytesMut}; use bytes::{Bytes, BytesMut};
use futures_core::{ready, Stream}; use futures_core::{ready, Stream};
@ -8,8 +12,8 @@ use pin_project::pin_project;
use crate::error::Error; use crate::error::Error;
/// Body size hint.
#[derive(Debug, PartialEq, Copy, Clone)] #[derive(Debug, PartialEq, Copy, Clone)]
/// Body size hint
pub enum BodySize { pub enum BodySize {
None, None,
Empty, Empty,
@ -23,7 +27,7 @@ impl BodySize {
} }
} }
/// Type that provides this trait can be streamed to a peer. /// Type that implement this trait can be streamed to a peer.
pub trait MessageBody { pub trait MessageBody {
fn size(&self) -> BodySize; fn size(&self) -> BodySize;
@ -80,7 +84,7 @@ impl ResponseBody<Body> {
impl<B> ResponseBody<B> { impl<B> ResponseBody<B> {
pub fn take_body(&mut self) -> ResponseBody<B> { pub fn take_body(&mut self) -> ResponseBody<B> {
std::mem::replace(self, ResponseBody::Other(Body::None)) mem::replace(self, ResponseBody::Other(Body::None))
} }
} }
@ -127,7 +131,7 @@ impl<B: MessageBody> Stream for ResponseBody<B> {
} }
} }
/// Represents various types of http message body. /// Represents various types of HTTP message body.
pub enum Body { pub enum Body {
/// Empty response. `Content-Length` header is not set. /// Empty response. `Content-Length` header is not set.
None, None,

8
actix-http/src/client/connector.rs
View file

@ -34,7 +34,8 @@ enum SslConnector {
#[cfg(not(any(feature = "openssl", feature = "rustls")))] #[cfg(not(any(feature = "openssl", feature = "rustls")))]
type SslConnector = (); type SslConnector = ();
/// Manages http client network connectivity /// Manages HTTP client network connectivity.
///
/// The `Connector` type uses a builder-like combinator pattern for service /// The `Connector` type uses a builder-like combinator pattern for service
/// construction that finishes by calling the `.finish()` method. /// construction that finishes by calling the `.finish()` method.
/// ///
@ -160,8 +161,9 @@ where
self self
} }
/// Maximum supported http major version /// Maximum supported HTTP major version.
/// Supported versions http/1.1, http/2 ///
/// Supported versions are HTTP/1.1 and HTTP/2.
pub fn max_http_version(mut self, val: http::Version) -> Self { pub fn max_http_version(mut self, val: http::Version) -> Self {
let versions = match val { let versions = match val {
http::Version::HTTP_11 => vec![b"http/1.1".to_vec()], http::Version::HTTP_11 => vec![b"http/1.1".to_vec()],

22
actix-http/src/client/error.rs
View file

@ -65,13 +65,16 @@ impl From<actix_tls::connect::ConnectError> for ConnectError {
#[derive(Debug, Display, From)] #[derive(Debug, Display, From)]
pub enum InvalidUrl { pub enum InvalidUrl {
#[display(fmt = "Missing url scheme")] #[display(fmt = "Missing URL scheme")]
MissingScheme, MissingScheme,
#[display(fmt = "Unknown url scheme")]
#[display(fmt = "Unknown URL scheme")]
UnknownScheme, UnknownScheme,
#[display(fmt = "Missing host name")] #[display(fmt = "Missing host name")]
MissingHost, MissingHost,
#[display(fmt = "Url parse error: {}", _0)]
#[display(fmt = "URL parse error: {}", _0)]
HttpError(http::Error), HttpError(http::Error),
} }
@ -83,25 +86,33 @@ pub enum SendRequestError {
/// Invalid URL /// Invalid URL
#[display(fmt = "Invalid URL: {}", _0)] #[display(fmt = "Invalid URL: {}", _0)]
Url(InvalidUrl), Url(InvalidUrl),
/// Failed to connect to host /// Failed to connect to host
#[display(fmt = "Failed to connect to host: {}", _0)] #[display(fmt = "Failed to connect to host: {}", _0)]
Connect(ConnectError), Connect(ConnectError),
/// Error sending request /// Error sending request
Send(io::Error), Send(io::Error),
/// Error parsing response /// Error parsing response
Response(ParseError), Response(ParseError),
/// Http error /// Http error
#[display(fmt = "{}", _0)] #[display(fmt = "{}", _0)]
Http(HttpError), Http(HttpError),
/// Http2 error /// Http2 error
#[display(fmt = "{}", _0)] #[display(fmt = "{}", _0)]
H2(h2::Error), H2(h2::Error),
/// Response took too long /// Response took too long
#[display(fmt = "Timeout while waiting for response")] #[display(fmt = "Timeout while waiting for response")]
Timeout, Timeout,
/// Tunnels are not supported for http2 connection
/// Tunnels are not supported for HTTP/2 connection
#[display(fmt = "Tunnels are not supported for http2 connection")] #[display(fmt = "Tunnels are not supported for http2 connection")]
TunnelNotSupported, TunnelNotSupported,
/// Error sending request body /// Error sending request body
Body(Error), Body(Error),
} }
@ -127,7 +138,8 @@ pub enum FreezeRequestError {
/// Invalid URL /// Invalid URL
#[display(fmt = "Invalid URL: {}", _0)] #[display(fmt = "Invalid URL: {}", _0)]
Url(InvalidUrl), Url(InvalidUrl),
/// Http error
/// HTTP error
#[display(fmt = "{}", _0)] #[display(fmt = "{}", _0)]
Http(HttpError), Http(HttpError),
} }

3
actix-http/src/client/mod.rs
View file

@ -1,4 +1,5 @@
//! Http client api //! HTTP client.
use http::Uri; use http::Uri;
mod config; mod config;

0
actix-http/src/clinu/mod.rs
View file

10
actix-http/src/config.rs
View file

@ -95,32 +95,32 @@ impl ServiceConfig {
})) }))
} }
/// Returns true if connection is secure (HTTPS)
#[inline] #[inline]
/// Returns true if connection is secure(https)
pub fn secure(&self) -> bool { pub fn secure(&self) -> bool {
self.0.secure self.0.secure
} }
#[inline]
/// Returns the local address that this server is bound to. /// Returns the local address that this server is bound to.
#[inline]
pub fn local_addr(&self) -> Option<net::SocketAddr> { pub fn local_addr(&self) -> Option<net::SocketAddr> {
self.0.local_addr self.0.local_addr
} }
#[inline]
/// Keep alive duration if configured. /// Keep alive duration if configured.
#[inline]
pub fn keep_alive(&self) -> Option<Duration> { pub fn keep_alive(&self) -> Option<Duration> {
self.0.keep_alive self.0.keep_alive
} }
#[inline]
/// Return state of connection keep-alive functionality /// Return state of connection keep-alive functionality
#[inline]
pub fn keep_alive_enabled(&self) -> bool { pub fn keep_alive_enabled(&self) -> bool {
self.0.ka_enabled self.0.ka_enabled
} }
#[inline]
/// Client timeout for first request. /// Client timeout for first request.
#[inline]
pub fn client_timer(&self) -> Option<Sleep> { pub fn client_timer(&self) -> Option<Sleep> {
let delay_time = self.0.client_timeout; let delay_time = self.0.client_timeout;
if delay_time != 0 { if delay_time != 0 {

6
actix-http/src/encoding/decoder.rs
View file

@ -1,7 +1,7 @@
use std::future::Future; //! Stream decoders.
use std::io::{self, Write};
use std::pin::Pin;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use std::{future::Future, io, io::Write as _, pin::Pin};
use actix_rt::task::{spawn_blocking, JoinHandle}; use actix_rt::task::{spawn_blocking, JoinHandle};
use brotli2::write::BrotliDecoder; use brotli2::write::BrotliDecoder;

7
actix-http/src/encoding/encoder.rs
View file

@ -1,8 +1,7 @@
//! Stream encoder //! Stream encoders.
use std::future::Future;
use std::io::{self, Write};
use std::pin::Pin;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use std::{future::Future, io, io::Write as _, pin::Pin};
use actix_rt::task::{spawn_blocking, JoinHandle}; use actix_rt::task::{spawn_blocking, JoinHandle};
use brotli2::write::BrotliEncoder; use brotli2::write::BrotliEncoder;

3
actix-http/src/encoding/mod.rs
View file

@ -1,4 +1,5 @@
//! Content-Encoding support //! Content-Encoding support.
use std::io; use std::io;
use bytes::{Bytes, BytesMut}; use bytes::{Bytes, BytesMut};

4
actix-http/src/error.rs
View file

@ -38,7 +38,7 @@ pub type Result<T, E = Error> = result::Result<T, E>;
/// converting errors with `into()`. /// converting errors with `into()`.
/// ///
/// Whenever it is created from an external object a response error is created /// Whenever it is created from an external object a response error is created
/// for it that can be used to create an http response from it this means that /// for it that can be used to create an HTTP response from it this means that
/// if you have access to an actix `Error` you can always get a /// if you have access to an actix `Error` you can always get a
/// `ResponseError` reference from it. /// `ResponseError` reference from it.
pub struct Error { pub struct Error {
@ -404,7 +404,7 @@ impl ResponseError for crate::cookie::ParseError {
} }
#[derive(Debug, Display, From)] #[derive(Debug, Display, From)]
/// A set of errors that can occur during dispatching http requests /// A set of errors that can occur during dispatching HTTP requests
pub enum DispatchError { pub enum DispatchError {
/// Service error /// Service error
Service(Error), Service(Error),

2
actix-http/src/h1/dispatcher.rs
View file

@ -178,7 +178,7 @@ where
) )
} }
/// Create http/1 dispatcher with slow request timeout. /// Create HTTP/1 dispatcher with slow request timeout.
pub(crate) fn with_timeout( pub(crate) fn with_timeout(
io: T, io: T,
codec: Codec, codec: Codec,

2
actix-http/src/h1/mod.rs
View file

@ -1,4 +1,4 @@
//! HTTP/1 implementation //! HTTP/1 protocol implementation.
use bytes::{Bytes, BytesMut}; use bytes::{Bytes, BytesMut};
mod client; mod client;

2
actix-http/src/h2/mod.rs
View file

@ -1,4 +1,4 @@
//! HTTP/2 implementation. //! HTTP/2 protocol.
use std::{ use std::{
pin::Pin, pin::Pin,

2
actix-http/src/h2/service.rs
View file

@ -243,7 +243,7 @@ where
} }
} }
/// `Service` implementation for http/2 transport /// `Service` implementation for HTTP/2 transport
pub struct H2ServiceHandler<T, S, B> pub struct H2ServiceHandler<T, S, B>
where where
S: Service<Request>, S: Service<Request>,

2
actix-http/src/header/as_name.rs
View file

@ -1,4 +1,6 @@
//! Helper trait for types that can be effectively borrowed as a [HeaderValue]. //! Helper trait for types that can be effectively borrowed as a [HeaderValue].
//!
//! [HeaderValue]: crate::http::HeaderValue
use std::{borrow::Cow, str::FromStr}; use std::{borrow::Cow, str::FromStr};

0
actix-http/src/httpcodes.rs → actix-http/src/http_codes.rs
View file

4
actix-http/src/lib.rs
View file

@ -25,8 +25,8 @@ pub mod encoding;
mod extensions; mod extensions;
mod header; mod header;
mod helpers; mod helpers;
mod httpcodes; mod http_codes;
pub mod httpmessage; mod httpmessage;
mod message; mod message;
mod payload; mod payload;
mod request; mod request;

10
actix-http/src/request.rs
View file

@ -107,7 +107,7 @@ impl<P> Request<P> {
#[inline] #[inline]
#[doc(hidden)] #[doc(hidden)]
/// Mutable reference to a http message part of the request /// Mutable reference to a HTTP message part of the request
pub fn head_mut(&mut self) -> &mut RequestHead { pub fn head_mut(&mut self) -> &mut RequestHead {
&mut *self.head &mut *self.head
} }
@ -158,10 +158,12 @@ impl<P> Request<P> {
self.head().method == Method::CONNECT self.head().method == Method::CONNECT
} }
/// Peer socket address /// Peer socket address.
/// ///
/// Peer address is actual socket address, if proxy is used in front of /// Peer address is the directly connected peer's socket address. If a proxy is used in front of
/// actix http server, then peer address would be address of this proxy. /// the Actix Web server, then it would be address of this proxy.
///
/// Will only return None when called in unit tests.
#[inline] #[inline]
pub fn peer_addr(&self) -> Option<net::SocketAddr> { pub fn peer_addr(&self) -> Option<net::SocketAddr> {
self.head().peer_addr self.head().peer_addr

6
actix-http/src/response.rs
View file

@ -32,13 +32,13 @@ pub struct Response<B = Body> {
} }
impl Response<Body> { impl Response<Body> {
/// Create http response builder with specific status. /// Create HTTP response builder with specific status.
#[inline] #[inline]
pub fn build(status: StatusCode) -> ResponseBuilder { pub fn build(status: StatusCode) -> ResponseBuilder {
ResponseBuilder::new(status) ResponseBuilder::new(status)
} }
/// Create http response builder /// Create HTTP response builder
#[inline] #[inline]
pub fn build_from<T: Into<ResponseBuilder>>(source: T) -> ResponseBuilder { pub fn build_from<T: Into<ResponseBuilder>>(source: T) -> ResponseBuilder {
source.into() source.into()
@ -97,7 +97,7 @@ impl<B> Response<B> {
} }
#[inline] #[inline]
/// Mutable reference to a http message part of the response /// Mutable reference to a HTTP message part of the response
pub fn head_mut(&mut self) -> &mut ResponseHead { pub fn head_mut(&mut self) -> &mut ResponseHead {
&mut *self.head &mut *self.head
} }

2
actix-http/src/service.rs
View file

@ -432,7 +432,7 @@ where
} }
} }
/// `Service` implementation for http transport /// `Service` implementation for HTTP transport
pub struct HttpServiceHandler<T, S, B, X, U> pub struct HttpServiceHandler<T, S, B, X, U>
where where
S: Service<Request>, S: Service<Request>,

2
actix-http/tests/test_openssl.rs
View file

@ -7,7 +7,7 @@ use std::io;
use actix_http::error::{ErrorBadRequest, PayloadError}; use actix_http::error::{ErrorBadRequest, PayloadError};
use actix_http::http::header::{self, HeaderName, HeaderValue}; use actix_http::http::header::{self, HeaderName, HeaderValue};
use actix_http::http::{Method, StatusCode, Version}; use actix_http::http::{Method, StatusCode, Version};
use actix_http::httpmessage::HttpMessage; use actix_http::HttpMessage;
use actix_http::{body, Error, HttpService, Request, Response}; use actix_http::{body, Error, HttpService, Request, Response};
use actix_http_test::test_server; use actix_http_test::test_server;
use actix_service::{fn_service, ServiceFactoryExt}; use actix_service::{fn_service, ServiceFactoryExt};

2
actix-http/tests/test_server.rs
View file

@ -10,7 +10,7 @@ use futures_util::future::{self, err, ok, ready, FutureExt};
use futures_util::stream::{once, StreamExt}; use futures_util::stream::{once, StreamExt};
use regex::Regex; use regex::Regex;
use actix_http::httpmessage::HttpMessage; use actix_http::HttpMessage;
use actix_http::{ use actix_http::{
body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response, body, error, http, http::header, Error, HttpService, KeepAlive, Request, Response,
}; };

2
actix-web-actors/src/context.rs
View file

@ -15,7 +15,7 @@ use bytes::Bytes;
use futures_core::Stream; use futures_core::Stream;
use tokio::sync::oneshot::Sender; use tokio::sync::oneshot::Sender;
/// Execution context for http actors /// Execution context for HTTP actors
pub struct HttpContext<A> pub struct HttpContext<A>
where where
A: Actor<Context = HttpContext<A>>, A: Actor<Context = HttpContext<A>>,

5
awc/src/builder.rs
View file

@ -82,8 +82,9 @@ impl ClientBuilder {
self self
} }
/// Maximum supported http major version /// Maximum supported HTTP major version.
/// Supported versions http/1.1, http/2 ///
/// Supported versions are HTTP/1.1 and HTTP/2.
pub fn max_http_version(mut self, val: http::Version) -> Self { pub fn max_http_version(mut self, val: http::Version) -> Self {
self.max_http_version = Some(val); self.max_http_version = Some(val);
self self

2
awc/src/lib.rs
View file

@ -134,7 +134,7 @@ use self::connect::{Connect, ConnectorWrapper};
/// ///
/// let res = client.get("http://www.rust-lang.org") // <- Create request builder /// let res = client.get("http://www.rust-lang.org") // <- Create request builder
/// .insert_header(("User-Agent", "Actix-web")) /// .insert_header(("User-Agent", "Actix-web"))
/// .send() // <- Send http request /// .send() // <- Send HTTP request
/// .await; // <- send request and wait for response /// .await; // <- send request and wait for response
/// ///
/// println!("Response: {:?}", res); /// println!("Response: {:?}", res);

6
awc/src/request.rs
View file

@ -42,10 +42,10 @@ cfg_if::cfg_if! {
/// let response = awc::Client::new() /// let response = awc::Client::new()
/// .get("http://www.rust-lang.org") // <- Create request builder /// .get("http://www.rust-lang.org") // <- Create request builder
/// .insert_header(("User-Agent", "Actix-web")) /// .insert_header(("User-Agent", "Actix-web"))
/// .send() // <- Send http request /// .send() // <- Send HTTP request
/// .await; /// .await;
/// ///
/// response.and_then(|response| { // <- server http response /// response.and_then(|response| { // <- server HTTP response
/// println!("Response: {:?}", response); /// println!("Response: {:?}", response);
/// Ok(()) /// Ok(())
/// }); /// });
@ -219,7 +219,7 @@ impl ClientRequest {
} }
/// Force close connection instead of returning it back to connections pool. /// Force close connection instead of returning it back to connections pool.
/// This setting affect only http/1 connections. /// This setting affect only HTTP/1 connections.
#[inline] #[inline]
pub fn force_close(mut self) -> Self { pub fn force_close(mut self) -> Self {
self.head.set_connection_type(ConnectionType::Close); self.head.set_connection_type(ConnectionType::Close);

4
awc/src/response.rs
View file

@ -109,7 +109,7 @@ impl<S> ClientResponse<S>
where where
S: Stream<Item = Result<Bytes, PayloadError>>, S: Stream<Item = Result<Bytes, PayloadError>>,
{ {
/// Loads http response's body. /// Loads HTTP response's body.
pub fn body(&mut self) -> MessageBody<S> { pub fn body(&mut self) -> MessageBody<S> {
MessageBody::new(self) MessageBody::new(self)
} }
@ -151,7 +151,7 @@ impl<S> fmt::Debug for ClientResponse<S> {
} }
} }
/// Future that resolves to a complete http message body. /// Future that resolves to a complete HTTP message body.
pub struct MessageBody<S> { pub struct MessageBody<S> {
length: Option<usize>, length: Option<usize>,
err: Option<PayloadError>, err: Option<PayloadError>,

4
src/app.rs
View file

@ -72,7 +72,7 @@ where
/// Set application data. Application data could be accessed /// Set application data. Application data could be accessed
/// by using `Data<T>` extractor where `T` is data type. /// by using `Data<T>` extractor where `T` is data type.
/// ///
/// **Note**: http server accepts an application factory rather than /// **Note**: HTTP server accepts an application factory rather than
/// an application instance. Http server constructs an application /// an application instance. Http server constructs an application
/// instance for each thread, thus application data must be constructed /// instance for each thread, thus application data must be constructed
/// multiple times. If you want to share data between different /// multiple times. If you want to share data between different
@ -207,7 +207,7 @@ where
) )
} }
/// Register http service. /// Register HTTP service.
/// ///
/// Http service is any type that implements `HttpServiceFactory` trait. /// Http service is any type that implements `HttpServiceFactory` trait.
/// ///

2
src/data.rs
View file

@ -27,7 +27,7 @@ pub(crate) type FnDataFactory =
/// ///
/// Application data can be accessed by using `Data<T>` extractor where `T` is data type. /// Application data can be accessed by using `Data<T>` extractor where `T` is data type.
/// ///
/// **Note**: http server accepts an application factory rather than an application instance. HTTP /// **Note**: HTTP server accepts an application factory rather than an application instance. HTTP
/// server constructs an application instance for each thread, thus application data must be /// server constructs an application instance for each thread, thus application data must be
/// constructed multiple times. If you want to share data between different threads, a shareable /// constructed multiple times. If you want to share data between different threads, a shareable
/// object should be used, e.g. `Send + Sync`. Application data does not need to be `Send` /// object should be used, e.g. `Send + Sync`. Application data does not need to be `Send`

22
src/guard.rs
View file

@ -176,7 +176,7 @@ impl Guard for NotGuard {
} }
} }
/// Http method guard /// HTTP method guard.
#[doc(hidden)] #[doc(hidden)]
pub struct MethodGuard(http::Method); pub struct MethodGuard(http::Method);
@ -186,52 +186,52 @@ impl Guard for MethodGuard {
} }
} }
/// Guard to match *GET* http method /// Guard to match *GET* HTTP method.
pub fn Get() -> MethodGuard { pub fn Get() -> MethodGuard {
MethodGuard(http::Method::GET) MethodGuard(http::Method::GET)
} }
/// Predicate to match *POST* http method /// Predicate to match *POST* HTTP method.
pub fn Post() -> MethodGuard { pub fn Post() -> MethodGuard {
MethodGuard(http::Method::POST) MethodGuard(http::Method::POST)
} }
/// Predicate to match *PUT* http method /// Predicate to match *PUT* HTTP method.
pub fn Put() -> MethodGuard { pub fn Put() -> MethodGuard {
MethodGuard(http::Method::PUT) MethodGuard(http::Method::PUT)
} }
/// Predicate to match *DELETE* http method /// Predicate to match *DELETE* HTTP method.
pub fn Delete() -> MethodGuard { pub fn Delete() -> MethodGuard {
MethodGuard(http::Method::DELETE) MethodGuard(http::Method::DELETE)
} }
/// Predicate to match *HEAD* http method /// Predicate to match *HEAD* HTTP method.
pub fn Head() -> MethodGuard { pub fn Head() -> MethodGuard {
MethodGuard(http::Method::HEAD) MethodGuard(http::Method::HEAD)
} }
/// Predicate to match *OPTIONS* http method /// Predicate to match *OPTIONS* HTTP method.
pub fn Options() -> MethodGuard { pub fn Options() -> MethodGuard {
MethodGuard(http::Method::OPTIONS) MethodGuard(http::Method::OPTIONS)
} }
/// Predicate to match *CONNECT* http method /// Predicate to match *CONNECT* HTTP method.
pub fn Connect() -> MethodGuard { pub fn Connect() -> MethodGuard {
MethodGuard(http::Method::CONNECT) MethodGuard(http::Method::CONNECT)
} }
/// Predicate to match *PATCH* http method /// Predicate to match *PATCH* HTTP method.
pub fn Patch() -> MethodGuard { pub fn Patch() -> MethodGuard {
MethodGuard(http::Method::PATCH) MethodGuard(http::Method::PATCH)
} }
/// Predicate to match *TRACE* http method /// Predicate to match *TRACE* HTTP method.
pub fn Trace() -> MethodGuard { pub fn Trace() -> MethodGuard {
MethodGuard(http::Method::TRACE) MethodGuard(http::Method::TRACE)
} }
/// Predicate to match specified http method /// Predicate to match specified HTTP method.
pub fn Method(method: http::Method) -> MethodGuard { pub fn Method(method: http::Method) -> MethodGuard {
MethodGuard(method) MethodGuard(method)
} }

10
src/request.rs
View file

@ -62,7 +62,7 @@ impl HttpRequest {
} }
/// This method returns mutable reference to the request head. /// This method returns mutable reference to the request head.
/// panics if multiple references of http request exists. /// panics if multiple references of HTTP request exists.
#[inline] #[inline]
pub(crate) fn head_mut(&mut self) -> &mut RequestHead { pub(crate) fn head_mut(&mut self) -> &mut RequestHead {
&mut Rc::get_mut(&mut self.inner).unwrap().head &mut Rc::get_mut(&mut self.inner).unwrap().head
@ -202,12 +202,14 @@ impl HttpRequest {
&self.app_state().rmap() &self.app_state().rmap()
} }
/// Peer socket address /// Peer socket address.
/// ///
/// Peer address is actual socket address, if proxy is used in front of /// Peer address is the directly connected peer's socket address. If a proxy is used in front of
/// actix http server, then peer address would be address of this proxy. /// the Actix Web server, then it would be address of this proxy.
/// ///
/// To get client connection information `.connection_info()` should be used. /// To get client connection information `.connection_info()` should be used.
///
/// Will only return None when called in unit tests.
#[inline] #[inline]
pub fn peer_addr(&self) -> Option<net::SocketAddr> { pub fn peer_addr(&self) -> Option<net::SocketAddr> {
self.head().peer_addr self.head().peer_addr

11
src/server.rs
View file

@ -40,7 +40,7 @@ struct Config {
/// An HTTP Server. /// An HTTP Server.
/// ///
/// Create new http server with application factory. /// Create new HTTP server with application factory.
/// ///
/// ```rust,no_run /// ```rust,no_run
/// use actix_web::{web, App, HttpResponse, HttpServer}; /// use actix_web::{web, App, HttpResponse, HttpServer};
@ -86,7 +86,7 @@ where
S::Service: 'static, S::Service: 'static,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
/// Create new http server with application factory /// Create new HTTP server with application factory
pub fn new(factory: F) -> Self { pub fn new(factory: F) -> Self {
HttpServer { HttpServer {
factory, factory,
@ -131,8 +131,7 @@ where
/// Set number of workers to start. /// Set number of workers to start.
/// ///
/// By default http server uses number of available logical cpu as threads /// By default, server uses number of available logical CPU as thread count.
/// count.
pub fn workers(mut self, num: usize) -> Self { pub fn workers(mut self, num: usize) -> Self {
self.builder = self.builder.workers(num); self.builder = self.builder.workers(num);
self self
@ -257,7 +256,7 @@ where
/// Get addresses of bound sockets and the scheme for it. /// Get addresses of bound sockets and the scheme for it.
/// ///
/// This is useful when the server is bound from different sources /// This is useful when the server is bound from different sources
/// with some sockets listening on http and some listening on https /// with some sockets listening on HTTP and some listening on HTTPS
/// and the user should be presented with an enumeration of which /// and the user should be presented with an enumeration of which
/// socket requires which protocol. /// socket requires which protocol.
pub fn addrs_with_scheme(&self) -> Vec<(net::SocketAddr, &str)> { pub fn addrs_with_scheme(&self) -> Vec<(net::SocketAddr, &str)> {
@ -610,7 +609,7 @@ where
{ {
/// Start listening for incoming connections. /// Start listening for incoming connections.
/// ///
/// This method starts number of http workers in separate threads. /// This method starts number of HTTP workers in separate threads.
/// For each address this method starts separate thread which does /// For each address this method starts separate thread which does
/// `accept()` in a loop. /// `accept()` in a loop.
/// ///

8
src/service.rs
View file

@ -164,12 +164,14 @@ impl ServiceRequest {
} }
} }
/// Peer socket address /// Peer socket address.
/// ///
/// Peer address is actual socket address, if proxy is used in front of /// Peer address is the directly connected peer's socket address. If a proxy is used in front of
/// actix http server, then peer address would be address of this proxy. /// the Actix Web server, then it would be address of this proxy.
/// ///
/// To get client connection information `ConnectionInfo` should be used. /// To get client connection information `ConnectionInfo` should be used.
///
/// Will only return None when called in unit tests.
#[inline] #[inline]
pub fn peer_addr(&self) -> Option<net::SocketAddr> { pub fn peer_addr(&self) -> Option<net::SocketAddr> {
self.head().peer_addr self.head().peer_addr

10
src/test.rs
View file

@ -851,13 +851,13 @@ impl TestServerConfig {
} }
} }
/// Start http/1.1 server only /// Start HTTP/1.1 server only
pub fn h1(mut self) -> Self { pub fn h1(mut self) -> Self {
self.tp = HttpVer::Http1; self.tp = HttpVer::Http1;
self self
} }
/// Start http/2 server only /// Start HTTP/2 server only
pub fn h2(mut self) -> Self { pub fn h2(mut self) -> Self {
self.tp = HttpVer::Http2; self.tp = HttpVer::Http2;
self self
@ -956,7 +956,7 @@ impl TestServer {
self.client.options(self.url(path.as_ref()).as_str()) self.client.options(self.url(path.as_ref()).as_str())
} }
/// Connect to test http server /// Connect to test HTTP server
pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest { pub fn request<S: AsRef<str>>(&self, method: Method, path: S) -> ClientRequest {
self.client.request(method, path.as_ref()) self.client.request(method, path.as_ref())
} }
@ -990,7 +990,7 @@ impl TestServer {
self.ws_at("/").await self.ws_at("/").await
} }
/// Gracefully stop http server /// Gracefully stop HTTP server
pub async fn stop(self) { pub async fn stop(self) {
self.server.stop(true).await; self.server.stop(true).await;
self.system.stop(); self.system.stop();
@ -1006,7 +1006,7 @@ impl Drop for TestServer {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use actix_http::httpmessage::HttpMessage; use actix_http::HttpMessage;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::time::SystemTime; use std::time::SystemTime;