ntex 4.0.0-beta.5

Framework for composable network services
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Http protocol support.
mod config;
#[cfg(feature = "compress")]
pub mod encoding;
pub(crate) mod helpers;
mod httpcodes;
mod httpmessage;
mod message;
mod payload;
mod request;
mod response;
mod service;

pub mod error;
pub mod h1;
pub mod h2;
pub mod test;

pub(crate) use self::message::Message;

pub use self::config::{DateService, HttpServiceConfig, KeepAlive};
pub use self::error::ResponseError;
pub use self::httpmessage::HttpMessage;
pub use self::message::{ConnectionType, RequestHead, ResponseHead};
pub use self::payload::{Payload, PayloadStream};
pub use self::request::Request;
pub use self::response::{Response, ResponseBuilder};
pub use self::service::HttpService;
pub use crate::io::types::HttpProtocol;

// re-exports
pub use ntex_http::uri::{self, Uri};
pub use ntex_http::{HeaderMap, Method, StatusCode, Version, body, header};

pub const ALPN_PROTO_H1: &[&str] = &["http/1.1"];
pub const ALPN_PROTO_H2: &[&str] = &["h2"];
pub const ALPN_PROTOS: &[&str] = &["h2", "http/1.1"];

/// Header item
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct HeaderItem {
    pub name: header::HeaderName,
    pub origin: crate::util::ByteString,
    pub value: header::HeaderValue,
}

#[cfg(feature = "openssl")]
use crate::server::openssl::{SslAcceptor, SslFilter};
#[cfg(any(feature = "openssl", feature = "rustls"))]
use crate::{IntoService, Service, io::Filter, io::Io, io::Layer, server::TlsError};

#[cfg(feature = "openssl")]
/// Create openssl based service
pub fn openssl<F, S, St>(
    acceptor: tls_openssl::ssl::SslAcceptor,
    service: impl IntoService<S, St, Io<Layer<SslFilter, F>>>,
) -> impl Service<St, Io<F>, Res = S::Res, Error = TlsError<S::Error>>
where
    F: Filter,
    S: Service<St, Io<Layer<SslFilter, F>>>,
{
    SslAcceptor::new(acceptor)
        .map_err(TlsError::Tls)
        .and_then(service.into_service().map_err(TlsError::Service))
}

#[cfg(feature = "rustls")]
use crate::server::rustls::{TlsAcceptor, TlsServerFilter};

#[cfg(feature = "rustls")]
/// Create rustls based service.
///
/// You must specify alpns protocols to negotiate for h2 server
pub fn rustls<F, S, St>(
    mut config: tls_rustls::ServerConfig,
    protos: &[&str],
    service: impl IntoService<S, St, Io<Layer<TlsServerFilter, F>>>,
) -> impl Service<St, Io<F>, Res = S::Res, Error = TlsError<S::Error>>
where
    F: Filter,
    S: Service<St, Io<Layer<TlsServerFilter, F>>>,
{
    if !protos.is_empty() && config.alpn_protocols.is_empty() {
        config.alpn_protocols = protos.iter().map(|s| s.to_string().into()).collect();
    }

    TlsAcceptor::new(std::sync::Arc::new(config))
        .map_err(TlsError::Tls)
        .and_then(service.into_service().map_err(TlsError::Service))
}

use crate::service::pipeline::PipelineFactory;

type HttpPipeline<St, Err> = PipelineFactory<St, Request, Response, Err, error::DispatchError>;
type Ctl1Pipeline<St, F, Err> = PipelineFactory<
    St,
    h1::Control<F, Err>,
    h1::ControlAck<F>,
    error::DispatchError,
    error::DispatchError,
>;
type Ctl2Pipeline<St> = PipelineFactory<
    St,
    h2::Control<error::H2Error>,
    h2::ControlAck,
    error::DispatchError,
    error::DispatchError,
>;