Replace HTTP/2.0 by HTTP/2 😅
The protocol is named HTTP/2.
This commit is contained in:
Anthony Ramine
committed by
Sean McArthur
Sean McArthur
parent
c38c94cb16
commit
f52d5e6290
@@ -1,10 +1,10 @@
|
||||
//! Server implementation of the HTTP/2.0 protocol.
|
||||
//! Server implementation of the HTTP/2 protocol.
|
||||
//!
|
||||
//! # Getting started
|
||||
//!
|
||||
//! Running an HTTP/2.0 server requires the caller to manage accepting the
|
||||
//! Running an HTTP/2 server requires the caller to manage accepting the
|
||||
//! connections as well as getting the connections to a state that is ready to
|
||||
//! begin the HTTP/2.0 handshake. See [here](../index.html#handshake) for more
|
||||
//! begin the HTTP/2 handshake. See [here](../index.html#handshake) for more
|
||||
//! details.
|
||||
//!
|
||||
//! This could be as basic as using Tokio's [`TcpListener`] to accept
|
||||
@@ -12,8 +12,8 @@
|
||||
//! upgrades.
|
||||
//!
|
||||
//! Once a connection is obtained, it is passed to [`handshake`],
|
||||
//! which will begin the [HTTP/2.0 handshake]. This returns a future that
|
||||
//! completes once the handshake process is performed and HTTP/2.0 streams may
|
||||
//! which will begin the [HTTP/2 handshake]. This returns a future that
|
||||
//! completes once the handshake process is performed and HTTP/2 streams may
|
||||
//! be received.
|
||||
//!
|
||||
//! [`handshake`] uses default configuration values. There are a number of
|
||||
@@ -21,7 +21,7 @@
|
||||
//!
|
||||
//! # Inbound streams
|
||||
//!
|
||||
//! The [`Connection`] instance is used to accept inbound HTTP/2.0 streams. It
|
||||
//! The [`Connection`] instance is used to accept inbound HTTP/2 streams. It
|
||||
//! does this by implementing [`futures::Stream`]. When a new stream is
|
||||
//! received, a call to [`Connection::accept`] will return `(request, response)`.
|
||||
//! The `request` handle (of type [`http::Request<RecvStream>`]) contains the
|
||||
@@ -59,9 +59,9 @@
|
||||
//!
|
||||
//! # Example
|
||||
//!
|
||||
//! A basic HTTP/2.0 server example that runs over TCP and assumes [prior
|
||||
//! A basic HTTP/2 server example that runs over TCP and assumes [prior
|
||||
//! knowledge], i.e. both the client and the server assume that the TCP socket
|
||||
//! will use the HTTP/2.0 protocol without prior negotiation.
|
||||
//! will use the HTTP/2 protocol without prior negotiation.
|
||||
//!
|
||||
//! ```no_run
|
||||
//! use h2::server;
|
||||
@@ -77,9 +77,9 @@
|
||||
//! if let Ok((socket, _peer_addr)) = listener.accept().await {
|
||||
//! // Spawn a new task to process each connection.
|
||||
//! tokio::spawn(async {
|
||||
//! // Start the HTTP/2.0 connection handshake
|
||||
//! // Start the HTTP/2 connection handshake
|
||||
//! let mut h2 = server::handshake(socket).await.unwrap();
|
||||
//! // Accept all inbound HTTP/2.0 streams sent over the
|
||||
//! // Accept all inbound HTTP/2 streams sent over the
|
||||
//! // connection.
|
||||
//! while let Some(request) = h2.accept().await {
|
||||
//! let (request, mut respond) = request.unwrap();
|
||||
@@ -104,7 +104,7 @@
|
||||
//!
|
||||
//! [prior knowledge]: http://httpwg.org/specs/rfc7540.html#known-http
|
||||
//! [`handshake`]: fn.handshake.html
|
||||
//! [HTTP/2.0 handshake]: http://httpwg.org/specs/rfc7540.html#ConnectionHeader
|
||||
//! [HTTP/2 handshake]: http://httpwg.org/specs/rfc7540.html#ConnectionHeader
|
||||
//! [`Builder`]: struct.Builder.html
|
||||
//! [`Connection`]: struct.Connection.html
|
||||
//! [`Connection::poll`]: struct.Connection.html#method.poll
|
||||
@@ -130,7 +130,7 @@ use std::{convert, fmt, io, mem};
|
||||
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
|
||||
use tracing::instrument::{Instrument, Instrumented};
|
||||
|
||||
/// In progress HTTP/2.0 connection handshake future.
|
||||
/// In progress HTTP/2 connection handshake future.
|
||||
///
|
||||
/// This type implements `Future`, yielding a `Connection` instance once the
|
||||
/// handshake has completed.
|
||||
@@ -154,10 +154,10 @@ pub struct Handshake<T, B: Buf = Bytes> {
|
||||
span: tracing::Span,
|
||||
}
|
||||
|
||||
/// Accepts inbound HTTP/2.0 streams on a connection.
|
||||
/// Accepts inbound HTTP/2 streams on a connection.
|
||||
///
|
||||
/// A `Connection` is backed by an I/O resource (usually a TCP socket) and
|
||||
/// implements the HTTP/2.0 server logic for that connection. It is responsible
|
||||
/// implements the HTTP/2 server logic for that connection. It is responsible
|
||||
/// for receiving inbound streams initiated by the client as well as driving the
|
||||
/// internal state forward.
|
||||
///
|
||||
@@ -202,7 +202,7 @@ pub struct Connection<T, B: Buf> {
|
||||
/// Methods can be chained in order to set the configuration values.
|
||||
///
|
||||
/// The server is constructed by calling [`handshake`] and passing the I/O
|
||||
/// handle that will back the HTTP/2.0 server.
|
||||
/// handle that will back the HTTP/2 server.
|
||||
///
|
||||
/// New instances of `Builder` are obtained via [`Builder::new`].
|
||||
///
|
||||
@@ -221,7 +221,7 @@ pub struct Connection<T, B: Buf> {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .initial_window_size(1_000_000)
|
||||
@@ -257,7 +257,7 @@ pub struct Builder {
|
||||
/// stream.
|
||||
///
|
||||
/// If the `SendResponse` instance is dropped without sending a response, then
|
||||
/// the HTTP/2.0 stream will be reset.
|
||||
/// the HTTP/2 stream will be reset.
|
||||
///
|
||||
/// See [module] level docs for more details.
|
||||
///
|
||||
@@ -276,7 +276,7 @@ pub struct SendResponse<B: Buf> {
|
||||
/// It can not be used to initiate push promises.
|
||||
///
|
||||
/// If the `SendPushedResponse` instance is dropped without sending a response, then
|
||||
/// the HTTP/2.0 stream will be reset.
|
||||
/// the HTTP/2 stream will be reset.
|
||||
///
|
||||
/// See [module] level docs for more details.
|
||||
///
|
||||
@@ -318,18 +318,18 @@ pub(crate) struct Peer;
|
||||
|
||||
const PREFACE: [u8; 24] = *b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
|
||||
|
||||
/// Creates a new configured HTTP/2.0 server with default configuration
|
||||
/// Creates a new configured HTTP/2 server with default configuration
|
||||
/// values backed by `io`.
|
||||
///
|
||||
/// It is expected that `io` already be in an appropriate state to commence
|
||||
/// the [HTTP/2.0 handshake]. See [Handshake] for more details.
|
||||
/// the [HTTP/2 handshake]. See [Handshake] for more details.
|
||||
///
|
||||
/// Returns a future which resolves to the [`Connection`] instance once the
|
||||
/// HTTP/2.0 handshake has been completed. The returned [`Connection`]
|
||||
/// HTTP/2 handshake has been completed. The returned [`Connection`]
|
||||
/// instance will be using default configuration values. Use [`Builder`] to
|
||||
/// customize the configuration values used by a [`Connection`] instance.
|
||||
///
|
||||
/// [HTTP/2.0 handshake]: http://httpwg.org/specs/rfc7540.html#ConnectionHeader
|
||||
/// [HTTP/2 handshake]: http://httpwg.org/specs/rfc7540.html#ConnectionHeader
|
||||
/// [Handshake]: ../index.html#handshake
|
||||
/// [`Connection`]: struct.Connection.html
|
||||
///
|
||||
@@ -343,8 +343,8 @@ const PREFACE: [u8; 24] = *b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
|
||||
/// # async fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # {
|
||||
/// let connection = server::handshake(my_io).await.unwrap();
|
||||
/// // The HTTP/2.0 handshake has completed, now use `connection` to
|
||||
/// // accept inbound HTTP/2.0 streams.
|
||||
/// // The HTTP/2 handshake has completed, now use `connection` to
|
||||
/// // accept inbound HTTP/2 streams.
|
||||
/// # }
|
||||
/// #
|
||||
/// # pub fn main() {}
|
||||
@@ -603,7 +603,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .initial_window_size(1_000_000)
|
||||
@@ -642,7 +642,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .initial_window_size(1_000_000)
|
||||
@@ -676,7 +676,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .initial_connection_window_size(1_000_000)
|
||||
@@ -691,7 +691,7 @@ impl Builder {
|
||||
self
|
||||
}
|
||||
|
||||
/// Indicates the size (in octets) of the largest HTTP/2.0 frame payload that the
|
||||
/// Indicates the size (in octets) of the largest HTTP/2 frame payload that the
|
||||
/// configured server is able to accept.
|
||||
///
|
||||
/// The sender may send data frames that are **smaller** than this value,
|
||||
@@ -709,7 +709,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .max_frame_size(1_000_000)
|
||||
@@ -748,7 +748,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .max_header_list_size(16 * 1024)
|
||||
@@ -783,7 +783,7 @@ impl Builder {
|
||||
/// a protocol level error. Instead, the `h2` library will immediately reset
|
||||
/// the stream.
|
||||
///
|
||||
/// See [Section 5.1.2] in the HTTP/2.0 spec for more details.
|
||||
/// See [Section 5.1.2] in the HTTP/2 spec for more details.
|
||||
///
|
||||
/// [Section 5.1.2]: https://http2.github.io/http2-spec/#rfc.section.5.1.2
|
||||
///
|
||||
@@ -796,7 +796,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .max_concurrent_streams(1000)
|
||||
@@ -815,7 +815,7 @@ impl Builder {
|
||||
///
|
||||
/// When a stream is explicitly reset by either calling
|
||||
/// [`SendResponse::send_reset`] or by dropping a [`SendResponse`] instance
|
||||
/// before completing the stream, the HTTP/2.0 specification requires that
|
||||
/// before completing the stream, the HTTP/2 specification requires that
|
||||
/// any further frames received for that stream must be ignored for "some
|
||||
/// time".
|
||||
///
|
||||
@@ -842,7 +842,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .max_concurrent_reset_streams(1000)
|
||||
@@ -861,7 +861,7 @@ impl Builder {
|
||||
///
|
||||
/// When a stream is explicitly reset by either calling
|
||||
/// [`SendResponse::send_reset`] or by dropping a [`SendResponse`] instance
|
||||
/// before completing the stream, the HTTP/2.0 specification requires that
|
||||
/// before completing the stream, the HTTP/2 specification requires that
|
||||
/// any further frames received for that stream must be ignored for "some
|
||||
/// time".
|
||||
///
|
||||
@@ -889,7 +889,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .reset_stream_duration(Duration::from_secs(10))
|
||||
@@ -904,18 +904,18 @@ impl Builder {
|
||||
self
|
||||
}
|
||||
|
||||
/// Creates a new configured HTTP/2.0 server backed by `io`.
|
||||
/// Creates a new configured HTTP/2 server backed by `io`.
|
||||
///
|
||||
/// It is expected that `io` already be in an appropriate state to commence
|
||||
/// the [HTTP/2.0 handshake]. See [Handshake] for more details.
|
||||
/// the [HTTP/2 handshake]. See [Handshake] for more details.
|
||||
///
|
||||
/// Returns a future which resolves to the [`Connection`] instance once the
|
||||
/// HTTP/2.0 handshake has been completed.
|
||||
/// HTTP/2 handshake has been completed.
|
||||
///
|
||||
/// This function also allows the caller to configure the send payload data
|
||||
/// type. See [Outbound data type] for more details.
|
||||
///
|
||||
/// [HTTP/2.0 handshake]: http://httpwg.org/specs/rfc7540.html#ConnectionHeader
|
||||
/// [HTTP/2 handshake]: http://httpwg.org/specs/rfc7540.html#ConnectionHeader
|
||||
/// [Handshake]: ../index.html#handshake
|
||||
/// [`Connection`]: struct.Connection.html
|
||||
/// [Outbound data type]: ../index.html#outbound-data-type.
|
||||
@@ -931,7 +931,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut = Builder::new()
|
||||
/// .handshake(my_io);
|
||||
@@ -951,7 +951,7 @@ impl Builder {
|
||||
/// # fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
|
||||
/// # -> Handshake<T, &'static [u8]>
|
||||
/// # {
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2.0
|
||||
/// // `server_fut` is a future representing the completion of the HTTP/2
|
||||
/// // handshake.
|
||||
/// let server_fut: Handshake<_, &'static [u8]> = Builder::new()
|
||||
/// .handshake(my_io);
|
||||
|
||||
Reference in New Issue
Block a user