actix/actix-extras
1
0
Fork 0
mirror of https://github.com/actix/actix-extras.git synced 2024-11-27 17:22:57 +01:00
Code Issues Releases Wiki Activity

set server settings to HttpHandler

Browse Source
This commit is contained in:
Nikolay Kim 2017-12-08 09:24:05 -08:00
parent 2192d14eff
commit 1293619096
5 changed files with 92 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/channel.rs
View File

@ -1,3 +1,4 @@
use std::rc::Rc;
use std::net::SocketAddr;
use actix::dev::*;
@ -12,9 +13,13 @@ use httprequest::HttpRequest;
use server::ServerSettings;
/// Low level http request handler
#[allow(unused_variables)]
pub trait HttpHandler: 'static {
/// Handle request
fn handle(&self, req: HttpRequest) -> Result<Pipeline, HttpRequest>;
/// Set server settings
fn server_settings(&mut self, settings: ServerSettings) {}
}
/// Conversion helper trait
@ -51,17 +56,16 @@ pub struct HttpChannel<T, H>
impl<T, H> HttpChannel<T, H>
where T: AsyncRead + AsyncWrite + 'static, H: HttpHandler + 'static
{
pub fn new(settings: ServerSettings<H>,
stream: T, peer: Option<SocketAddr>, http2: bool) -> HttpChannel<T, H>
pub fn new(h: Rc<Vec<H>>, io: T, peer: Option<SocketAddr>, http2: bool) -> HttpChannel<T, H>
{
if http2 {
HttpChannel {
proto: Some(HttpProtocol::H2(
h2::Http2::new(settings, stream, peer, Bytes::new()))) }
h2::Http2::new(h, io, peer, Bytes::new()))) }
} else {
HttpChannel {
proto: Some(HttpProtocol::H1(
h1::Http1::new(settings, stream, peer))) }
h1::Http1::new(h, io, peer))) }
}
}
}
@ -97,8 +101,7 @@ impl<T, H> Future for HttpChannel<T, H>
return Err(()),
}
}
Some(HttpProtocol::H2(ref mut h2)) =>
return h2.poll(),
Some(HttpProtocol::H2(ref mut h2)) => return h2.poll(),
None => unreachable!(),
}
@ -106,9 +109,9 @@ impl<T, H> Future for HttpChannel<T, H>
let proto = self.proto.take().unwrap();
match proto {
HttpProtocol::H1(h1) => {
let (settings, stream, addr, buf) = h1.into_inner();
let (h, io, addr, buf) = h1.into_inner();
self.proto = Some(
HttpProtocol::H2(h2::Http2::new(settings, stream, addr, buf)));
HttpProtocol::H2(h2::Http2::new(h, io, addr, buf)));
self.poll()
}
_ => unreachable!()

22
src/h1.rs
View File

@ -1,4 +1,5 @@
use std::{self, io, ptr};
use std::rc::Rc;
use std::net::SocketAddr;
use std::time::Duration;
use std::collections::VecDeque;
@ -20,7 +21,6 @@ use httpcodes::HTTPNotFound;
use httprequest::HttpRequest;
use error::{ParseError, PayloadError, ResponseError};
use payload::{Payload, PayloadWriter, DEFAULT_BUFFER_SIZE};
use server::ServerSettings;
const KEEPALIVE_PERIOD: u64 = 15; // seconds
const INIT_BUFFER_SIZE: usize = 8192;
@ -31,7 +31,6 @@ const HTTP2_PREFACE: [u8; 14] = *b"PRI * HTTP/2.0";
bitflags! {
struct Flags: u8 {
const SECURE = 0b0000_0001;
const ERROR = 0b0000_0010;
const KEEPALIVE = 0b0000_0100;
const H2 = 0b0000_1000;
@ -60,7 +59,7 @@ enum Item {
pub(crate) struct Http1<T: AsyncWrite + 'static, H: 'static> {
flags: Flags,
settings: ServerSettings<H>,
handlers: Rc<Vec<H>>,
addr: Option<SocketAddr>,
stream: H1Writer<T>,
reader: Reader,
@ -78,14 +77,9 @@ impl<T, H> Http1<T, H>
where T: AsyncRead + AsyncWrite + 'static,
H: HttpHandler + 'static
{
pub fn new(settings: ServerSettings<H>, stream: T, addr: Option<SocketAddr>) -> Self {
let flags = if settings.secure() {
Flags::SECURE | Flags::KEEPALIVE
} else {
Flags::KEEPALIVE
};
Http1{ flags: flags,
settings: settings,
pub fn new(h: Rc<Vec<H>>, stream: T, addr: Option<SocketAddr>) -> Self {
Http1{ flags: Flags::KEEPALIVE,
handlers: h,
addr: addr,
stream: H1Writer::new(stream),
reader: Reader::new(),
@ -94,8 +88,8 @@ impl<T, H> Http1<T, H>
keepalive_timer: None }
}
pub fn into_inner(mut self) -> (ServerSettings<H>, T, Option<SocketAddr>, Bytes) {
(self.settings, self.stream.unwrap(), self.addr, self.read_buf.freeze())
pub fn into_inner(mut self) -> (Rc<Vec<H>>, T, Option<SocketAddr>, Bytes) {
(self.handlers, self.stream.unwrap(), self.addr, self.read_buf.freeze())
}
pub fn poll(&mut self) -> Poll<Http1Result, ()> {
@ -204,7 +198,7 @@ impl<T, H> Http1<T, H>
// start request processing
let mut pipe = None;
for h in self.settings.handlers() {
for h in self.handlers.iter() {
req = match h.handle(req) {
Ok(t) => {
pipe = Some(t);

17
src/h2.rs
View File

@ -1,4 +1,5 @@
use std::{io, cmp, mem};
use std::rc::Rc;
use std::io::{Read, Write};
use std::time::Duration;
use std::net::SocketAddr;
@ -21,13 +22,11 @@ use encoding::PayloadType;
use httpcodes::HTTPNotFound;
use httprequest::HttpRequest;
use payload::{Payload, PayloadWriter};
use server::ServerSettings;
const KEEPALIVE_PERIOD: u64 = 15; // seconds
bitflags! {
struct Flags: u8 {
const SECURE = 0b0000_0001;
const DISCONNECTED = 0b0000_0010;
}
}
@ -37,7 +36,7 @@ pub(crate) struct Http2<T, H>
where T: AsyncRead + AsyncWrite + 'static, H: 'static
{
flags: Flags,
settings: ServerSettings<H>,
handlers: Rc<Vec<H>>,
addr: Option<SocketAddr>,
state: State<IoWrapper<T>>,
tasks: VecDeque<Entry>,
@ -54,10 +53,10 @@ impl<T, H> Http2<T, H>
where T: AsyncRead + AsyncWrite + 'static,
H: HttpHandler + 'static
{
pub fn new(settings: ServerSettings<H>, stream: T, addr: Option<SocketAddr>, buf: Bytes) -> Self
pub fn new(h: Rc<Vec<H>>, stream: T, addr: Option<SocketAddr>, buf: Bytes) -> Self
{
Http2{ flags: if settings.secure() { Flags::SECURE } else { Flags::empty() },
settings: settings,
Http2{ flags: Flags::empty(),
handlers: h,
addr: addr,
tasks: VecDeque::new(),
state: State::Handshake(
@ -152,7 +151,7 @@ impl<T, H> Http2<T, H>
self.keepalive_timer.take();
self.tasks.push_back(
Entry::new(parts, body, resp, self.addr, &self.settings));
Entry::new(parts, body, resp, self.addr, &self.handlers));
}
Ok(Async::NotReady) => {
// start keep-alive timer
@ -231,7 +230,7 @@ impl Entry {
recv: RecvStream,
resp: Respond<Bytes>,
addr: Option<SocketAddr>,
settings: &ServerSettings<H>) -> Entry
handlers: &Rc<Vec<H>>) -> Entry
where H: HttpHandler + 'static
{
// Payload and Content-Encoding
@ -248,7 +247,7 @@ impl Entry {
// start request processing
let mut task = None;
for h in settings.handlers() {
for h in handlers.iter() {
req = match h.handle(req) {
Ok(t) => {
task = Some(t);

3
src/httprequest.rs
View File

@ -142,7 +142,8 @@ impl<S> HttpRequest<S> {
&self.0.headers
}
#[cfg(test)]
#[doc(hidden)]
#[inline]
pub fn headers_mut(&mut self) -> &mut HeaderMap {
&mut self.as_mut().headers
}

132
src/server.rs
View File

@ -5,6 +5,8 @@ use std::marker::PhantomData;
use actix::dev::*;
use futures::Stream;
use http::HttpTryFrom;
use http::header::HeaderValue;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_core::net::{TcpListener, TcpStream};
@ -27,49 +29,41 @@ use tokio_openssl::{SslStream, SslAcceptorExt};
use channel::{HttpChannel, HttpHandler, IntoHttpHandler};
/// Various server settings
pub struct ServerSettings<H> (Rc<InnerServerSettings<H>>);
struct InnerServerSettings<H> {
h: Vec<H>,
#[derive(Debug, Clone)]
pub struct ServerSettings {
addr: Option<SocketAddr>,
secure: bool,
sethost: bool,
host: Option<HeaderValue>,
}
impl<H> Clone for ServerSettings<H> {
fn clone(&self) -> Self {
ServerSettings(Rc::clone(&self.0))
}
}
impl<H> ServerSettings<H> {
impl ServerSettings {
/// Crate server settings instance
fn new(h: Vec<H>, addr: Option<SocketAddr>, secure: bool, sethost: bool) -> Self {
ServerSettings(
Rc::new(InnerServerSettings {
h: h,
addr: addr,
secure: secure,
sethost: sethost }))
fn new(addr: Option<SocketAddr>, secure: bool) -> Self {
let host = if let Some(ref addr) = addr {
HeaderValue::try_from(format!("{}", addr).as_str()).ok()
} else {
None
};
ServerSettings {
addr: addr,
secure: secure,
host: host,
}
}
/// Returns list of http handlers
pub fn handlers(&self) -> &Vec<H> {
&self.0.h
}
/// Returns the socket address of the local half of this TCP connection
pub fn local_addr(&self) -> Option<SocketAddr> {
self.0.addr
self.addr
}
/// Returns true if connection is secure(https)
pub fn secure(&self) -> bool {
self.0.secure
self.secure
}
/// Should http channel set *HOST* header
pub fn set_host_header(&self) -> bool {
self.0.sethost
/// Returns host header value
pub fn host(&self) -> Option<&HeaderValue> {
self.host.as_ref()
}
}
@ -81,10 +75,9 @@ impl<H> ServerSettings<H> {
///
/// `H` - request handler
pub struct HttpServer<T, A, H> {
h: Option<Vec<H>>,
h: Rc<Vec<H>>,
io: PhantomData<T>,
addr: PhantomData<A>,
sethost: bool,
}
impl<T: 'static, A: 'static, H: 'static> Actor for HttpServer<T, A, H> {
@ -99,16 +92,9 @@ impl<T, A, H> HttpServer<T, A, H> where H: HttpHandler
{
let apps: Vec<_> = handler.into_iter().map(|h| h.into_handler()).collect();
HttpServer {h: Some(apps),
HttpServer{ h: Rc::new(apps),
io: PhantomData,
addr: PhantomData,
sethost: false}
}
/// Set *HOST* header if not set
pub fn set_host_header(mut self) -> Self {
self.sethost = true;
self
addr: PhantomData }
}
}
@ -122,14 +108,17 @@ impl<T, A, H> HttpServer<T, A, H>
where Self: ActorAddress<Self, Addr>,
S: Stream<Item=(T, A), Error=io::Error> + 'static
{
// set server settings
let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addr), secure, self.sethost);
let settings = ServerSettings::new(Some(addr), secure);
for h in Rc::get_mut(&mut self.h).unwrap().iter_mut() {
h.server_settings(settings.clone());
}
// start server
Ok(HttpServer::create(move |ctx| {
ctx.add_stream(stream.map(
move |(t, _)| IoStream{settings: settings.clone(),
io: t, peer: None, http2: false}));
move |(t, _)| IoStream{io: t, peer: None, http2: false}));
self
}))
}
@ -170,16 +159,20 @@ impl<H: HttpHandler> HttpServer<TcpStream, net::SocketAddr, H> {
S: net::ToSocketAddrs,
{
let addrs = self.bind(addr)?;
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addrs[0].0), false, self.sethost);
// set server settings
let settings = ServerSettings::new(Some(addrs[0].0), false);
for h in Rc::get_mut(&mut self.h).unwrap().iter_mut() {
h.server_settings(settings.clone());
}
// start server
Ok(HttpServer::create(move |ctx| {
for (addr, tcp) in addrs {
info!("Starting http server on {}", addr);
let s = settings.clone();
ctx.add_stream(tcp.incoming().map(
move |(t, a)| IoStream{settings: s.clone(),
io: t, peer: Some(a), http2: false}));
move |(t, a)| IoStream{io: t, peer: Some(a), http2: false}));
}
self
}))
@ -198,8 +191,12 @@ impl<H: HttpHandler> HttpServer<TlsStream<TcpStream>, net::SocketAddr, H> {
S: net::ToSocketAddrs,
{
let addrs = self.bind(addr)?;
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addrs[0].0.clone()), true, self.sethost);
// set server settings
let settings = ServerSettings::new(Some(addrs[0].0), true);
for h in Rc::get_mut(&mut self.h).unwrap().iter_mut() {
h.server_settings(settings.clone());
}
let acceptor = match TlsAcceptor::builder(pkcs12) {
Ok(builder) => {
@ -211,18 +208,15 @@ impl<H: HttpHandler> HttpServer<TlsStream<TcpStream>, net::SocketAddr, H> {
Err(err) => return Err(io::Error::new(io::ErrorKind::Other, err))
};
// start server
Ok(HttpServer::create(move |ctx| {
for (srv, tcp) in addrs {
info!("Starting tls http server on {}", srv);
let st = settings.clone();
let acc = acceptor.clone();
ctx.add_stream(tcp.incoming().and_then(move |(stream, addr)| {
let st2 = st.clone();
TlsAcceptorExt::accept_async(acc.as_ref(), stream)
.map(move |t|
IoStream{settings: st2.clone(),
io: t, peer: Some(addr), http2: false})
.map(move |t| IoStream{io: t, peer: Some(addr), http2: false})
.map_err(|err| {
trace!("Error during handling tls connection: {}", err);
io::Error::new(io::ErrorKind::Other, err)
@ -246,8 +240,12 @@ impl<H: HttpHandler> HttpServer<SslStream<TcpStream>, net::SocketAddr, H> {
S: net::ToSocketAddrs,
{
let addrs = self.bind(addr)?;
let settings = ServerSettings::new(
self.h.take().unwrap(), Some(addrs[0].0.clone()), true, self.sethost);
// set server settings
let settings = ServerSettings::new(Some(addrs[0].0), true);
for h in Rc::get_mut(&mut self.h).unwrap().iter_mut() {
h.server_settings(settings.clone());
}
let acceptor = match SslAcceptorBuilder::mozilla_intermediate(
SslMethod::tls(), &identity.pkey, &identity.cert, &identity.chain)
@ -265,10 +263,8 @@ impl<H: HttpHandler> HttpServer<SslStream<TcpStream>, net::SocketAddr, H> {
for (srv, tcp) in addrs {
info!("Starting tls http server on {}", srv);
let st = settings.clone();
let acc = acceptor.clone();
ctx.add_stream(tcp.incoming().and_then(move |(stream, addr)| {
let st2 = st.clone();
SslAcceptorExt::accept_async(&acc, stream)
.map(move |stream| {
let http2 = if let Some(p) =
@ -278,8 +274,7 @@ impl<H: HttpHandler> HttpServer<SslStream<TcpStream>, net::SocketAddr, H> {
} else {
false
};
IoStream{settings: st2.clone(),
io: stream, peer: Some(addr), http2: http2}
IoStream{io: stream, peer: Some(addr), http2: http2}
})
.map_err(|err| {
trace!("Error during handling tls connection: {}", err);
@ -292,26 +287,25 @@ impl<H: HttpHandler> HttpServer<SslStream<TcpStream>, net::SocketAddr, H> {
}
}
struct IoStream<T, H> {
struct IoStream<T> {
io: T,
peer: Option<SocketAddr>,
http2: bool,
settings: ServerSettings<H>,
}
impl<T, H> ResponseType for IoStream<T, H>
impl<T> ResponseType for IoStream<T>
where T: AsyncRead + AsyncWrite + 'static
{
type Item = ();
type Error = ();
}
impl<T, A, H> StreamHandler<IoStream<T, H>, io::Error> for HttpServer<T, A, H>
impl<T, A, H> StreamHandler<IoStream<T>, io::Error> for HttpServer<T, A, H>
where T: AsyncRead + AsyncWrite + 'static,
H: HttpHandler + 'static,
A: 'static {}
impl<T, A, H> Handler<IoStream<T, H>, io::Error> for HttpServer<T, A, H>
impl<T, A, H> Handler<IoStream<T>, io::Error> for HttpServer<T, A, H>
where T: AsyncRead + AsyncWrite + 'static,
H: HttpHandler + 'static,
A: 'static,
@ -320,11 +314,11 @@ impl<T, A, H> Handler<IoStream<T, H>, io::Error> for HttpServer<T, A, H>
debug!("Error handling request: {}", err)
}
fn handle(&mut self, msg: IoStream<T, H>, _: &mut Context<Self>)
-> Response<Self, IoStream<T, H>>
fn handle(&mut self, msg: IoStream<T>, _: &mut Context<Self>)
-> Response<Self, IoStream<T>>
{
Arbiter::handle().spawn(
HttpChannel::new(msg.settings, msg.io, msg.peer, msg.http2));
HttpChannel::new(Rc::clone(&self.h), msg.io, msg.peer, msg.http2));
Self::empty()
}
}